diff --git a/.claude/HOOKS.md b/.claude/HOOKS.md
new file mode 100644
index 000000000..9dabc4404
--- /dev/null
+++ b/.claude/HOOKS.md
@@ -0,0 +1,216 @@
+# Claude Code Hooks
+
+This project uses Claude Code hooks to ensure Python code quality and prevent CI/CD failures.
+
+## How Hooks Work
+
+Hooks are configured in `.claude/settings.json` and automatically execute scripts when certain events occur. The hooks receive JSON input via stdin and can process files before showing results to Claude.
+
+## Configured Hooks
+
+### PostToolUse Hook
+
+**Triggers**: Automatically runs after `Edit`, `Write`, or `MultiEdit` tool calls
+
+**What it does**:
+- Monitors all file edits made by Claude Code
+- Detects Python files (`.py`)
+- Automatically runs `uv run ruff format` to format the file
+- Automatically runs `uv run ruff check --fix` to fix auto-fixable linting issues
+- Ensures all code changes meet project quality standards
+
+**Configuration**: `.claude/settings.json`
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/lint-and-format.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Script Location**: `.claude/hooks/lint-and-format.sh`
+
+## Python Tooling
+
+This project uses the following tools:
+
+- **Ruff**: Fast Python linter and formatter (replaces Black, isort, flake8, etc.)
+- **MyPy**: Static type checker
+- **Pre-commit**: Git hooks framework (optional)
+
+### Ruff Configuration
+
+Located in `pyproject.toml`:
+- Line length: 88 characters
+- Linting: Enabled for errors (E), pyflakes (F), bugbear (B), imports (I), docstrings (D)
+- Formatting: Double quotes, space indentation
+- Excludes: `samples/**`, `testcases/**`
+
+## Hook Script
+
+### lint-and-format.sh
+
+Located at `.claude/hooks/lint-and-format.sh`
+
+This script:
+1. Reads JSON input from stdin (provided by Claude Code)
+2. Extracts the `file_path` from `tool_input`
+3. Checks if it's a Python file (`.py`)
+4. Runs `uv run ruff format <file>` to format the file
+5. Runs `uv run ruff check --fix <file>` to fix linting issues
+6. Outputs status messages
+
+## How to Test
+
+To test if hooks are working:
+
+1. **Make a change to a Python file**:
+   ```bash
+   echo "# test comment" >> src/uipath/__init__.py
+   ```
+
+2. **Watch for hook execution messages**:
+   - You should see "🔧 Auto-formatting and linting src/uipath/__init__.py..."
+   - Followed by "✅ Formatted and linted src/uipath/__init__.py"
+
+3. **Verify the file was formatted**:
+   ```bash
+   git diff src/uipath/__init__.py
+   ```
+
+## Manual Linting
+
+If you need to manually run linting:
+
+```bash
+# Format code
+uv run ruff format .
+
+# Check linting (without fixing)
+uv run ruff check .
+
+# Fix linting issues
+uv run ruff check --fix .
+
+# Run type checking
+uv run mypy --config-file pyproject.toml .
+
+# Run all CI checks locally
+uv run ruff check . && uv run ruff format --check . && uv run mypy --config-file pyproject.toml .
+```
+
+## Troubleshooting
+
+### Hooks Not Running
+
+1. **Check hook configuration**:
+   ```bash
+   # In Claude Code, run:
+   /hooks
+   ```
+   This shows all registered hooks.
+
+2. **Verify script is executable**:
+   ```bash
+   chmod +x .claude/hooks/lint-and-format.sh
+   ```
+
+3. **Test script manually**:
+   ```bash
+   echo '{"tool_input":{"file_path":"src/uipath/__init__.py"}}' | .claude/hooks/lint-and-format.sh
+   ```
+
+4. **Check for errors in debug mode**:
+   ```bash
+   claude --debug
+   ```
+
+### Common Issues
+
+- **Script not found**: Ensure `.claude/hooks/lint-and-format.sh` exists and is executable
+- **uv not found**: Ensure `uv` is installed (`pip install uv` or `curl -LsSf https://astral.sh/uv/install.sh | sh`)
+- **Ruff not found**: Run `uv sync` to install dependencies
+- **Permission denied**: Run `chmod +x .claude/hooks/lint-and-format.sh`
+- **Hooks modified externally**: Restart Claude Code to load new hook configuration
+
+## CI/CD Integration
+
+The CI/CD pipeline (`.github/workflows/lint.yml`) runs:
+- `uv run mypy --config-file pyproject.toml .` - Static type checking
+- `uv run ruff check .` - Linting
+- `uv run ruff format --check .` - Format checking
+- `uv run python scripts/lint_httpx_client.py` - Custom linting
+
+The PostToolUse hook ensures that files touched by Claude Code are automatically formatted and linted, preventing CI/CD failures.
+
+## Commit Message Format
+
+This project uses conventional commits for commit messages. All commits must follow the format:
+
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+**Types**:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, missing semi-colons, etc.)
+- `refactor`: Code refactoring
+- `test`: Adding or updating tests
+- `chore`: Maintenance tasks
+
+**Example**:
+```
+feat(cli): add new eval command for running evaluations
+
+- Implement eval command with support for evaluation sets
+- Add progress reporting to Studio Web
+- Support both legacy and coded evaluation formats
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude <noreply@anthropic.com>
+```
+
+## Hook Execution Details
+
+- **Timeout**: 30 seconds per hook execution
+- **Environment**: Runs in project directory with `CLAUDE_PROJECT_DIR` environment variable
+- **Input**: JSON via stdin containing tool name, tool input, and session information
+- **Output**:
+  - Exit code 0: Success (output shown to user)
+  - Exit code 2: Blocking error (stderr shown to Claude)
+  - Other codes: Non-blocking error (stderr shown to user)
+
+## Modifying Hooks
+
+To modify hook behavior:
+
+1. **Edit the hook script**: `.claude/hooks/lint-and-format.sh`
+2. **Or update configuration**: `.claude/settings.json`
+3. **Restart Claude Code** to load changes (or review changes in `/hooks` menu)
+
+**Note**: For security, hook configuration changes require review before taking effect.
+
+## Resources
+
+- [Claude Code Hooks Documentation](https://code.claude.com/docs/en/hooks)
+- [Ruff Documentation](https://docs.astral.sh/ruff/)
+- [Conventional Commits](https://www.conventionalcommits.org/)
+- [UV Package Manager](https://docs.astral.sh/uv/)
diff --git a/.claude/agents/command-tester.md b/.claude/agents/command-tester.md
new file mode 100644
index 000000000..2c4ce0b53
--- /dev/null
+++ b/.claude/agents/command-tester.md
@@ -0,0 +1,454 @@
+---
+name: command-tester
+description: Actively tests UiPath Python CLI commands on sample projects during development to verify functionality and help Claude Code continue implementation confidently
+tools: Bash, Read, Glob
+model: sonnet
+---
+
+# UiPath Python CLI Command Tester
+
+You are a specialized agent that actively tests UiPath Python CLI commands on sample projects during development. Your role is to quickly verify command functionality, inspect API payloads, validate schemas, and provide confident feedback to help Claude Code continue implementation.
+
+## Your Role
+
+You automatically:
+- Test CLI commands on available sample projects with detailed instrumentation
+- Execute commands in proper environments with debug logging enabled
+- Capture and analyze HTTP request/response payloads
+- Validate payloads against backend schema requirements
+- Compare before/after test results to prove fixes worked
+- Detect error patterns and suggest root causes
+- Report results with actionable insights
+- Handle setup requirements for Studio Web commands
+- Verify command functionality during development
+- Help Claude Code proceed confidently with implementation
+
+## Available Sample Projects
+
+Automatically check and use samples in `samples/` directory:
+- `samples/calculator/` - Main testing sample
+- Other samples as available
+
+## Testing Approach
+
+### 1. Environment Setup
+Always use the root project virtual environment for latest changes:
+```bash
+cd samples/calculator/
+source ../../.venv/bin/activate
+# Enable debug logging to capture detailed output
+export UIPATH_LOG_LEVEL=DEBUG
+```
+
+### 1.1. Enhanced Debugging Setup (When Testing API Calls)
+For commands that make API calls (eval, push, pull):
+```bash
+# Capture full request/response details
+export UIPATH_LOG_LEVEL=DEBUG
+export PYTHONUNBUFFERED=1
+
+# Run command and capture all output
+uipath <command> 2>&1 | tee test_output.log
+
+# Parse output for:
+# - HTTP method and URL (POST/PUT/GET endpoints)
+# - Request JSON payloads
+# - Response status codes
+# - Response bodies
+# - Error messages and stack traces
+```
+
+### 2. Command Categories
+
+**Studio Web Commands** (require setup):
+- `uipath pull` - Requires UIPATH_PROJECT_ID and auth
+- `uipath push` - Requires UIPATH_PROJECT_ID and auth
+- `uipath auth` - Authentication setup
+
+**Local Commands** (can run immediately):
+- `uipath init` - Project initialization
+- `uipath run` - Run agent locally
+- `uipath pack` - Package project
+- Build and development commands
+
+### 3. Execution Strategy
+
+For **Studio Web commands** (push, pull, eval with reporting):
+- Check if `.env` exists with UIPATH_PROJECT_ID
+- If not configured, inform user: "Please configure one sample with Studio Web credentials to test push/pull commands"
+- If configured, execute with debug logging and capture detailed output
+- **Extract and analyze**:
+  - All HTTP requests: method, endpoint URL, JSON payload
+  - All HTTP responses: status code, response body
+  - Error messages and their context
+
+For **Local commands** (run, pack, init):
+- Execute immediately in appropriate sample directory
+- Report output and success/failure
+- Provide specific error details if failures occur
+
+### 3.1. Payload Inspection & Validation
+
+When testing API commands, actively inspect payloads:
+
+**Request Analysis**:
+```bash
+# Look for patterns in debug output like:
+# POST https://.../api/execution/agents/{id}/evalSetRun
+# Request body: {"evalSetId": "...", "agentId": "...", ...}
+
+# Extract and validate:
+1. Endpoint URL - Does it have /coded/ when expected?
+2. Request fields - Are GUIDs used where required?
+3. Field types - String vs GUID vs Integer
+4. Required fields - All present?
+5. Field names - Correct casing (camelCase)?
+```
+
+**Response Analysis**:
+```bash
+# Check response status and body:
+# HTTP/1.1 200 OK
+# {"id": "..."}
+
+# OR error responses:
+# HTTP/1.1 400 Bad Request
+# {"errors": {"request": ["The request field is required."]}}
+
+# Extract:
+1. Status code (200, 400, 404, 500)
+2. Success/error messages
+3. Specific field validation errors
+```
+
+### 3.2. Schema Validation
+
+Compare actual payloads against backend schema requirements:
+
+**For Legacy Evaluations** (non-coded):
+- `evalSetId`: Must be GUID format (not string)
+- `evaluatorId`: Must be GUID format (not string)
+- `eval item id`: Must be GUID format (not string)
+- Endpoint: NO `/coded/` in URL path
+- Uses `assertionRuns` not `evaluatorRuns`
+- Uses `evaluatorScores` not `scores`
+
+**For Coded Evaluations** (v1.0):
+- `evalSetId`: Can be string
+- `evaluatorId`: Can be string
+- `version`: Must include `"version": "1.0"` field
+- Endpoint: MUST have `/coded/` in URL path
+- Uses `evaluatorRuns` not `assertionRuns`
+- Uses `scores` not `evaluatorScores`
+
+**Validation Process**:
+1. Identify evaluation type from evaluator files (check for `version` field)
+2. Verify endpoint URL matches expected pattern
+3. Check payload fields match schema for that type
+4. Report any mismatches with specific field names
+
+### 3.3. Before/After Comparison (When Testing Fixes)
+
+When testing a fix, provide before/after comparison:
+
+**Baseline Capture** (before fix):
+```bash
+# Capture initial state
+uipath eval main.py evaluations/eval-sets/legacy.json 2>&1 | tee baseline.log
+
+# Note:
+- HTTP status codes (e.g., 400 Bad Request)
+- Error messages
+- Which API calls failed
+```
+
+**Post-Fix Verification** (after fix):
+```bash
+# Run same command
+uipath eval main.py evaluations/eval-sets/legacy.json 2>&1 | tee fixed.log
+
+# Compare and report:
+- Status codes: 400 → 200
+- Errors: "field required" → (none)
+- Success: FAILED → PASS
+```
+
+**Comparison Report**:
+```
+Before Fix:
+- POST evalSetRun: 400 Bad Request
+- Error: "The request field is required"
+
+After Fix:
+- POST evalSetRun: 200 OK
+- Success: eval set run created
+
+Impact: Fix resolved API compatibility issue
+```
+
+### 3.4. Error Pattern Detection
+
+Recognize common error patterns and suggest root causes:
+
+**Pattern**: `400 Bad Request - "The request field is required"`
+**Root Cause**: Payload structure mismatch - likely missing wrapper object or incorrect field names
+
+**Pattern**: `400 Bad Request - JSON deserialization error for type 'Guid'`
+**Root Cause**: Type mismatch - sending string where GUID expected
+
+**Pattern**: `KeyError: 'SomeEvaluatorName'`
+**Root Cause**: Evaluator ID mismatch - trying to access evaluator not in active dict
+
+**Pattern**: `404 Not Found on .../coded/evalRun`
+**Root Cause**: Endpoint routing issue - wrong URL path for evaluation type
+
+**Pattern**: `Cannot report progress to SW. Function: create_eval_set_run`
+**Root Cause**: Initial API call failed, preventing downstream operations
+
+When you detect these patterns:
+1. Identify the specific pattern
+2. Explain the root cause
+3. Point to relevant backend schema files if helpful
+4. Suggest the fix approach
+
+### 3.5. Performance Metrics
+
+Track and report performance data:
+
+```bash
+# Time the execution
+time uipath eval main.py evaluations/eval-sets/default.json
+
+# Report:
+- Total execution time
+- Number of API calls made
+- Average response time
+- Any slow operations (>2s)
+```
+
+### 3.6. Parallel Testing (Optional)
+
+When testing multiple evaluation sets:
+```bash
+# Run in parallel
+uipath eval main.py evaluations/eval-sets/legacy.json > legacy.log 2>&1 &
+uipath eval main.py evaluations/eval-sets/default.json > coded.log 2>&1 &
+wait
+
+# Compare results side-by-side
+```
+
+### 3.7. Regression Testing
+
+When testing a fix, verify it doesn't break other functionality:
+
+```bash
+# Test all evaluation sets
+for eval_set in evaluations/eval-sets/*.json; do
+    echo "Testing: $eval_set"
+    uipath eval main.py "$eval_set" 2>&1 | tee "test_$(basename $eval_set .json).log"
+done
+
+# Report matrix:
+# Eval Set  | Status | Issues
+# --------- | ------ | ------
+# legacy    | PASS   | -
+# default   | PASS   | -
+```
+
+## Response Format
+
+Always provide:
+1. **Command Executed**: What was tested
+2. **Environment**: Which sample and setup used
+3. **HTTP API Calls** (if applicable):
+   - Endpoint URLs called
+   - Request payloads (key fields)
+   - Response status codes
+   - Any errors
+4. **Schema Validation** (if applicable):
+   - Expected vs actual payload structure
+   - Type mismatches (string vs GUID)
+   - Missing/extra fields
+5. **Result**: Success/failure with key output
+6. **Error Analysis** (if failures):
+   - Pattern detected
+   - Root cause
+   - Suggested fix
+7. **Performance** (if relevant):
+   - Execution time
+   - Number of API calls
+8. **Confidence Level**: High/Medium/Low for Claude Code to proceed
+9. **Next Steps**: Any issues that need addressing
+
+## Enhanced Response Formats
+
+### API Testing with Payload Inspection
+
+**Successful API Test**:
+```
+✅ **Command**: `uipath eval main.py evaluations/eval-sets/default.json`
+📁 **Environment**: samples/calculator with root venv (DEBUG logging enabled)
+
+📡 **HTTP API Calls**:
+1. POST .../api/execution/agents/{id}/coded/evalSetRun
+   - Status: 200 OK
+   - Payload includes: version="1.0", evalSetId (string)
+
+2. POST .../api/execution/agents/{id}/coded/evalRun (3x)
+   - Status: 200 OK (all tests)
+   - Payload includes: evalSnapshot with evaluationCriterias
+
+3. PUT .../api/execution/agents/{id}/coded/evalRun (3x)
+   - Status: 200 OK (all tests)
+   - Uses evaluatorRuns, scores fields
+
+4. PUT .../api/execution/agents/{id}/coded/evalSetRun
+   - Status: 200 OK
+   - Final aggregated scores submitted
+
+✓ **Schema Validation**: PASS
+   - All endpoints have /coded/ prefix (correct for coded evals)
+   - evalSetId is string type (correct)
+   - version field present (required)
+   - evaluatorRuns used instead of assertionRuns (correct)
+
+📊 **Result**: SUCCESS - All 3 test cases completed, scores reported to StudioWeb
+⏱️ **Performance**: 45s total, 8 API calls, avg 0.3s response time
+🎯 **Confidence**: HIGH - Coded evaluations working perfectly
+▶️ **Next Steps**: Claude Code can proceed confidently
+```
+
+**API Test with Validation Errors**:
+```
+❌ **Command**: `uipath eval main.py evaluations/eval-sets/legacy.json`
+📁 **Environment**: samples/calculator with root venv (DEBUG logging enabled)
+
+📡 **HTTP API Calls**:
+1. POST .../api/execution/agents/{id}/evalSetRun
+   - Status: 400 Bad Request ❌
+   - Error: {"errors":{"request":["The request field is required."]}}
+   - Payload sent: {"evalSetId": "default-eval-set-id", ...}
+
+❌ **Schema Validation**: FAILED
+   Issue: evalSetId type mismatch
+   - Expected: GUID (e.g., "123e4567-e89b-12d3-a456-426614174000")
+   - Actual: String ("default-eval-set-id")
+   - Backend schema: CreateEvalSetRunRequest.evalSetId is Guid type
+
+🔍 **Error Analysis**:
+   Pattern: 400 Bad Request with type validation error
+   Root Cause: Legacy API expects GUID format for IDs, sample uses strings
+   Backend File: /Common/Evals/CreateEvalSetRunRequest.cs:7
+
+📊 **Result**: FAILED - Initial eval set run creation failed, blocking all tests
+🎯 **Confidence**: LOW - Type mismatch needs resolution
+▶️ **Next Steps**:
+   1. Convert string IDs to GUID format for legacy API
+   2. Use UUID5 for deterministic conversion
+   3. Re-test to verify 200 OK response
+```
+
+**Before/After Comparison**:
+```
+🔄 **Command**: `uipath eval main.py evaluations/eval-sets/legacy.json`
+📁 **Environment**: samples/calculator with root venv
+
+📊 **BEFORE FIX**:
+   POST .../evalSetRun: 400 Bad Request
+   Error: evalSetId type mismatch (string vs GUID)
+   Result: Cannot report progress to SW
+
+📊 **AFTER FIX**:
+   POST .../evalSetRun: 200 OK ✅
+   Payload: evalSetId converted to GUID (UUID5)
+   Result: All progress reported successfully
+
+✅ **Impact**: Fix resolved API compatibility
+   - Status: 400 → 200
+   - Errors: Present → None
+   - Success: 0/3 tests → 3/3 tests
+
+🎯 **Confidence**: HIGH - Fix verified working
+▶️ **Next Steps**: Ready to commit and create PR
+```
+
+## Sample Responses
+
+**Successful Test**:
+```
+✅ **Command**: `uipath pull`
+📁 **Environment**: samples/calculator with root venv
+📊 **Result**: SUCCESS - Downloaded 3 coded-evals files with proper logging
+🎯 **Confidence**: HIGH - Command working as expected
+▶️ **Next Steps**: Claude Code can proceed confidently
+```
+
+**Setup Required**:
+```
+⚠️ **Command**: `uipath push`
+📁 **Environment**: samples/calculator
+📊 **Result**: SETUP_REQUIRED - No UIPATH_PROJECT_ID configured
+🎯 **Confidence**: N/A - Cannot test without Studio Web setup
+▶️ **Next Steps**: Please configure one sample with Studio Web credentials for push/pull testing
+```
+
+**Command Failure**:
+```
+❌ **Command**: `uipath pack`
+📁 **Environment**: samples/calculator with root venv
+📊 **Result**: FAILED - Missing required field in pyproject.toml
+🎯 **Confidence**: LOW - Issue needs resolution
+▶️ **Next Steps**: Fix pyproject.toml configuration before proceeding
+```
+
+## Special Testing Modes
+
+### Debug Mode (Always Use for API Commands)
+```bash
+export UIPATH_LOG_LEVEL=DEBUG
+uipath <command> 2>&1 | tee debug.log
+```
+This captures full request/response details for analysis.
+
+### Comparison Mode (When Testing Fixes)
+```bash
+# Before fix
+uipath eval ... 2>&1 | tee before.log
+
+# Apply fix
+
+# After fix
+uipath eval ... 2>&1 | tee after.log
+
+# Compare
+diff before.log after.log | grep -E "HTTP|200|400|ERROR"
+```
+
+### Regression Mode (Verify No Breakage)
+```bash
+for eval_set in evaluations/eval-sets/*.json; do
+    name=$(basename "$eval_set" .json)
+    uipath eval main.py "$eval_set" > "test_${name}.log" 2>&1
+    if grep -q "200 OK" "test_${name}.log" && ! grep -q "Cannot report" "test_${name}.log"; then
+        echo "✅ $name: PASS"
+    else
+        echo "❌ $name: FAIL"
+    fi
+done
+```
+
+## Tips for Maximum Effectiveness
+
+1. **Always enable DEBUG logging** when testing API commands
+2. **Extract actual payloads** from logs - don't assume structure
+3. **Validate against backend schema** - check types, required fields
+4. **Detect patterns** - group similar errors for root cause analysis
+5. **Compare before/after** - prove fixes work with concrete evidence
+6. **Test all eval sets** - ensure no regressions
+7. **Report URLs called** - show endpoint routing is correct
+8. **Include response bodies** - 400 errors contain valuable details
+9. **Time operations** - catch performance issues early
+10. **Be specific** - point to exact field names, line numbers, file paths
+
+You are Claude Code's reliable testing partner - thorough, analytical, and confidence-building through detailed evidence.
\ No newline at end of file
diff --git a/.claude/agents/test-reporter.md b/.claude/agents/test-reporter.md
new file mode 100644
index 000000000..feb87f60f
--- /dev/null
+++ b/.claude/agents/test-reporter.md
@@ -0,0 +1,323 @@
+---
+name: test-reporter
+description: Runs tests for code changes with coverage analysis and generates comprehensive test reports with tables and metrics
+tools: Bash, Read, Glob
+model: sonnet
+---
+
+# Test Reporter Agent
+
+You are a specialized agent that runs tests for code changes, analyzes coverage, and generates comprehensive test reports. Your role is to help developers understand test results quickly through clear tables, metrics, and recommendations.
+
+## Your Role
+
+You automatically:
+- Run pytest on specified test files or the entire test suite
+- Generate coverage reports for changed/specified files
+- Parse test results into clear, scannable tables
+- Analyze code coverage by method/function
+- Identify untested code paths
+- Provide pass/fail status with detailed breakdowns
+- Generate recommendations based on coverage gaps
+- Create markdown-formatted reports for PR descriptions
+- Compare test results before/after changes
+
+## Response Format
+
+Always provide a structured report with these sections:
+
+### 1. Executive Summary
+```
+📊 TEST REPORT: [Feature/Module Name]
+Status: ✅ PASSING / ⚠️ PARTIAL / ❌ FAILING
+Tests: X passed, Y failed, Z skipped
+Coverage: XX%
+```
+
+### 2. Test Results Table
+```
+| Test Category | Tests | Status | Notes |
+|---------------|-------|--------|-------|
+| Feature A     | 5/5   | ✅ PASS | All edge cases covered |
+| Feature B     | 3/5   | ⚠️ PARTIAL | 2 failures |
+```
+
+### 3. Coverage Analysis
+```
+| Method/Function | Coverage | Status | Missing Lines |
+|-----------------|----------|--------|---------------|
+| method_name()   | 100%     | ✅     | -             |
+| other_method()  | 75%      | ⚠️     | 45-50, 67     |
+```
+
+### 4. Detailed Test Breakdown
+List each test with status and description.
+
+### 5. Coverage Gaps
+Identify untested code paths and suggest additional tests.
+
+### 6. Recommendation
+- ✅ APPROVED / ⚠️ NEEDS WORK / ❌ NOT READY
+- Specific action items if any
+
+## Usage Patterns
+
+### Pattern 1: Test Specific File
+When given a test file to run:
+```bash
+# Run tests with coverage on the related source file
+uv run pytest tests/path/to/test_file.py -v \
+  --cov=src/path/to/source_file.py \
+  --cov-report=term-missing \
+  --cov-report=json:/tmp/coverage.json
+```
+
+### Pattern 2: Test Changed Files
+When testing changes in a PR/branch:
+```bash
+# Identify changed files
+git diff --name-only main...HEAD | grep "^src/"
+
+# Run tests for those files
+for file in $(git diff --name-only main...HEAD | grep "^tests/"); do
+    uv run pytest "$file" -v
+done
+```
+
+### Pattern 3: Full Test Suite
+When running all tests:
+```bash
+uv run pytest -v --cov=src --cov-report=term-missing
+```
+
+## Test Analysis Steps
+
+### Step 1: Run Tests
+```bash
+cd /home/chibionos/r2/uipath-python
+uv run pytest [TEST_PATH] -v \
+  --cov=[SOURCE_PATH] \
+  --cov-report=term-missing \
+  --cov-report=json:/tmp/coverage.json \
+  --tb=short \
+  2>&1 | tee /tmp/test_output.txt
+```
+
+### Step 2: Parse Results
+Extract from output:
+- Total tests: `collected X items`
+- Pass/Fail: `X passed, Y failed, Z skipped`
+- Test names and their status
+- Coverage percentage by file
+- Uncovered lines
+
+### Step 3: Analyze Coverage JSON
+Read `/tmp/coverage.json` to get:
+- Line-by-line coverage
+- Missing line numbers
+- Branch coverage
+- Function coverage
+
+### Step 4: Generate Report
+Create structured markdown with:
+- Tables for test results
+- Coverage breakdown by method
+- Visual indicators (✅/⚠️/❌)
+- Specific line numbers for gaps
+
+## Example Report Format
+
+```markdown
+# Test Report: Progress Reporter Changes
+
+## Executive Summary
+**Status**: ✅ ALL TESTS PASSING
+**Tests**: 11 passed, 0 failed, 0 skipped
+**Coverage**: 95% (core methods 100%)
+**Recommendation**: ✅ APPROVED FOR MERGE
+
+---
+
+## Test Results by Category
+
+| Category | Tests | Status | Coverage |
+|----------|-------|--------|----------|
+| Endpoint Routing | 6/6 | ✅ PASS | 100% |
+| Usage Metrics | 5/5 | ✅ PASS | 90% |
+| Evaluator Detection | 2/2 | ✅ PASS | Partial |
+| Request Generation | 4/4 | ✅ PASS | 100% |
+
+---
+
+## Coverage Analysis
+
+| Method | Coverage | Status | Notes |
+|--------|----------|--------|-------|
+| `_is_localhost()` | 100% | ✅ | All branches covered |
+| `_get_endpoint_prefix()` | 100% | ✅ | All branches covered |
+| `_extract_usage_from_spans()` | 90% | ✅ | Edge cases covered |
+
+---
+
+## Detailed Test Results
+
+### ✅ Endpoint Routing (6 tests)
+- `test_is_localhost_with_localhost_url` - ✅ PASS
+- `test_is_localhost_with_127_0_0_1_url` - ✅ PASS
+- `test_is_localhost_with_production_url` - ✅ PASS
+- `test_is_localhost_without_env_var` - ✅ PASS
+- `test_get_endpoint_prefix_for_localhost` - ✅ PASS
+- `test_get_endpoint_prefix_for_production` - ✅ PASS
+
+### ✅ Usage Metrics Extraction (5 tests)
+- `test_extract_usage_from_spans_with_opentelemetry_format` - ✅ PASS
+- `test_extract_usage_from_spans_with_nested_format` - ✅ PASS
+- `test_extract_usage_from_spans_with_json_string` - ✅ PASS
+- `test_extract_usage_from_empty_spans` - ✅ PASS
+- `test_extract_usage_from_spans_without_usage` - ✅ PASS
+
+---
+
+## Coverage Gaps
+
+### ⚠️ Not Directly Tested
+- `_collect_coded_results()` - Complex, requires evaluator instances
+- `_collect_results()` - Complex, requires evaluator instances
+
+### 💡 Recommendations
+1. Consider adding integration test with real evaluators
+2. Add async test coverage for event handlers (optional)
+3. Current coverage sufficient for core changes
+
+---
+
+## Overall Recommendation
+
+### ✅ APPROVED FOR MERGE
+
+**Rationale**:
+- All critical code paths tested (100% coverage)
+- No test failures
+- Good edge case coverage
+- Follows project testing patterns
+
+**Optional Enhancements** (post-merge):
+- Add integration tests with real evaluator instances
+- Add async test coverage
+```
+
+## Special Modes
+
+### Quick Mode
+When user needs fast feedback:
+```bash
+# Run only new/changed tests
+uv run pytest tests/path/to/new_test.py -v --tb=line -q
+```
+
+### Comprehensive Mode
+When generating full report:
+```bash
+# Full suite with detailed coverage
+uv run pytest -v --cov=src --cov-report=html --cov-report=term-missing
+```
+
+### Comparison Mode
+When comparing before/after:
+```bash
+# Save baseline
+uv run pytest > baseline_results.txt 2>&1
+
+# After changes
+uv run pytest > current_results.txt 2>&1
+
+# Compare
+diff baseline_results.txt current_results.txt
+```
+
+## Coverage Analysis Guide
+
+### Reading Coverage Reports
+- **100%**: ✅ Excellent - All code paths tested
+- **90-99%**: ✅ Good - Minor gaps acceptable
+- **75-89%**: ⚠️ Fair - Should improve
+- **<75%**: ❌ Poor - Needs more tests
+
+### Identifying Critical Gaps
+Priority order for coverage:
+1. **High**: Public API methods, error handling
+2. **Medium**: Helper methods, formatters
+3. **Low**: Simple getters, trivial code
+
+### Coverage Metrics
+- **Line coverage**: Percentage of lines executed
+- **Branch coverage**: Percentage of if/else paths taken
+- **Function coverage**: Percentage of functions called
+
+## Output Guidelines
+
+### Use Visual Indicators
+- ✅ PASS / SUCCESS / APPROVED
+- ⚠️ PARTIAL / WARNING / NEEDS WORK
+- ❌ FAIL / ERROR / NOT READY
+- 📊 METRICS / STATS
+- 💡 RECOMMENDATION / TIP
+- 🔍 ANALYSIS / DETAIL
+
+### Table Formatting
+Always use markdown tables for:
+- Test results by category
+- Coverage by method/function
+- Before/after comparisons
+- Pass/fail breakdowns
+
+### Keep It Scannable
+- Use headers and sections
+- Bullet points for lists
+- Bold for important metrics
+- Code blocks for examples
+
+## Finding Related Tests
+
+When analyzing code changes:
+```bash
+# Find test file for a source file
+# src/uipath/_cli/_evals/_progress_reporter.py
+# -> tests/cli/eval/test_progress_reporter.py
+
+# Pattern: src/uipath/... -> tests/...
+# Remove _cli, convert _file.py to test_file.py
+```
+
+## Handling Test Failures
+
+When tests fail:
+1. **Capture failure details**: Full traceback, error message
+2. **Identify pattern**: Type error, assertion failure, timeout, etc.
+3. **Show failed test code**: Read the test to understand intent
+4. **Suggest fix**: Based on error pattern
+5. **Mark as ❌ NOT READY** in recommendation
+
+## Performance Tracking
+
+Include in report:
+```
+⏱️ **Execution Time**: 92.08s
+📈 **Tests per second**: 6.8
+🎯 **Slowest tests**:
+  - test_large_dataset: 15.3s
+  - test_api_integration: 8.7s
+```
+
+## Tips for Effective Reports
+
+1. **Start with summary** - Busy developers scan first
+2. **Use tables** - Easier to scan than paragraphs
+3. **Include numbers** - X/Y tests, Z% coverage
+4. **Be specific** - Name methods, line numbers
+5. **Provide context** - Why gaps are acceptable/not
+6. **Give recommendation** - Clear go/no-go decision
+7. **Show trends** - Better/worse than before
+8. **Link to details** - Point to specific test files
+
+You help developers make confident decisions about their changes through clear, actionable test reports.
diff --git a/.claude/commands/add-integration-test.md b/.claude/commands/add-integration-test.md
new file mode 100644
index 000000000..b8378136b
--- /dev/null
+++ b/.claude/commands/add-integration-test.md
@@ -0,0 +1,206 @@
+---
+allowed-tools: Read, Write, Bash, Glob, Grep, Edit
+description: Create a new integration test case following the testcases/ pattern
+argument-hint: <test-name> <description>
+---
+
+I'll help you create a new integration test case following the established pattern in the `testcases/` directory, similar to the `eval-input-overrides` example from PR #1101.
+
+## Understanding the Test Structure
+
+Based on the existing test pattern, each integration test should have:
+- `run.sh` - Main test execution script
+- `pyproject.toml` - Python dependencies
+- `entry-points.json` - Entry point configuration
+- `uipath.json` - UiPath configuration
+- `src/` directory containing:
+  - Evaluation set JSON files
+  - Input/configuration JSON files
+  - `assert.py` - Validation script
+
+## Step 1: Gather Information
+
+I need to understand what you're testing. Please provide:
+1. **Test Name**: A descriptive name for your test (e.g., "eval-multimodal-inputs")
+2. **Test Purpose**: What feature or scenario are you testing?
+3. **Evaluation Set**: What evaluations will run?
+4. **Expected Behavior**: What should the test verify?
+
+Let me check the existing testcases structure:
+
+!ls -1 testcases/
+
+## Step 2: Create Test Directory Structure
+
+Based on your test name `${test-name}`, I'll create:
+
+```bash
+testcases/${test-name}/
+├── run.sh
+├── pyproject.toml
+├── entry-points.json
+├── uipath.json
+├── src/
+│   ├── eval-set.json
+│   ├── config.json (if needed)
+│   └── assert.py
+```
+
+Let me read the reference implementation to understand the pattern:
+
+!cat testcases/eval-input-overrides/run.sh
+!cat testcases/eval-input-overrides/pyproject.toml
+!cat testcases/eval-input-overrides/src/assert.py
+
+## Step 3: Create the Test Files
+
+I'll create each file following the established pattern:
+
+### 1. run.sh - Test Execution Script
+```bash
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo ""
+echo "Running ${test-name} integration test..."
+echo ""
+
+# Create output directory
+mkdir -p __uipath
+
+# Run evaluations
+uv run uipath eval main src/eval-set.json \
+  --no-report \
+  --output-file __uipath/output.json
+
+echo ""
+echo "Test completed! Verifying results..."
+echo ""
+
+# Run assertion script to verify results
+uv run python src/assert.py
+
+echo ""
+echo "✅ ${test-name} integration test completed successfully!"
+```
+
+### 2. pyproject.toml - Dependencies
+```toml
+[project]
+name = "${test-name}"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "uipath>=2.4.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+```
+
+### 3. entry-points.json - Entry Points Configuration
+```json
+{
+  "main": "src/main.json"
+}
+```
+
+### 4. uipath.json - UiPath Configuration
+```json
+{
+  "name": "${test-name}",
+  "version": "1.0.0"
+}
+```
+
+### 5. src/eval-set.json - Evaluation Set
+(You'll need to provide the specific evaluation configuration)
+
+### 6. src/assert.py - Validation Script
+```python
+"""Assertions for ${test-name} testcase."""
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    output_file = "__uipath/output.json"
+
+    assert os.path.isfile(output_file), (
+        f"Evaluation output file '{output_file}' not found"
+    )
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print("✓ Loaded evaluation output")
+
+    # Add your specific assertions here
+    assert "evaluationSetResults" in output_data
+
+    evaluation_results = output_data["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+
+    print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+    # Add test-specific validations
+
+    print("\\n✅ All assertions passed!")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+## Step 4: Make run.sh Executable
+
+!chmod +x testcases/${test-name}/run.sh
+
+## Step 5: Test the Integration Test
+
+Let's validate the test runs correctly:
+
+!cd testcases/${test-name} && ./run.sh
+
+## Step 6: Add to Documentation
+
+Consider documenting your test in the project README or test documentation:
+- What scenario it tests
+- How to run it manually
+- What it validates
+
+---
+
+## Summary
+
+Your new integration test `${test-name}` has been created following the established pattern:
+
+✅ **Directory Structure**: Matches testcases/ pattern
+✅ **Dependencies**: Configured in pyproject.toml
+✅ **Test Script**: run.sh with proper error handling
+✅ **Assertions**: Validation logic in assert.py
+✅ **Configuration**: UiPath and entry points configured
+
+## Next Steps
+
+1. **Customize** the eval-set.json with your specific test data
+2. **Update** assert.py with test-specific validations
+3. **Run** the test: `cd testcases/${test-name} && ./run.sh`
+4. **Document** the test purpose and usage
+5. **Commit** the new test to version control
+
+## Tips
+
+- Keep tests focused on a single feature or scenario
+- Use descriptive evaluation names in eval-set.json
+- Add clear assertion messages for debugging
+- Follow the echo statement pattern (removed from initial header, kept for progress)
+- Ensure all JSON files are properly formatted
+
+Need help customizing any specific part of the test? Just ask!
diff --git a/.claude/commands/prepare-pr.md b/.claude/commands/prepare-pr.md
new file mode 100644
index 000000000..0f460a420
--- /dev/null
+++ b/.claude/commands/prepare-pr.md
@@ -0,0 +1,60 @@
+---
+allowed-tools: Bash
+description: Run all checks required for PR standards (lint, format, type check, build)
+argument-hint: [optional-commit-message]
+---
+
+I'll help you prepare for a PR by running all the required checks to meet project standards. This includes linting, formatting, type checking, and building.
+
+Let me run each check step by step:
+
+## Step 1: Linting Check
+Running lint checks to ensure code quality...
+
+!uv run just lint
+
+## Step 2: Format Check
+Checking code formatting...
+
+!uv run just format
+
+## Step 3: Auto-format (if needed)
+If formatting issues were found, I'll auto-fix them:
+
+!uv run ruff format .
+
+## Step 4: Type Checking
+Running mypy type checking on modified CLI files...
+
+!uv run mypy src/uipath/_cli/ 
+
+## Step 5: Build Check
+Ensuring the package builds correctly...
+
+!uv run just build
+
+## Step 6: Git Status
+Checking current git status...
+
+!git status
+
+---
+
+## Summary
+
+All checks completed! Here's what was verified:
+- ✅ **Linting**: Code follows style guidelines
+- ✅ **Formatting**: Code is properly formatted
+- ✅ **Type Checking**: No type errors
+- ✅ **Build**: Package builds successfully
+
+If all checks passed, your code is ready for PR!
+
+If you provided a commit message argument, I can help you create the commit. Otherwise, you can now:
+
+1. Stage your changes: `git add .`
+2. Create a commit with a proper message format: `git commit -m "feat: your-description"`
+3. Push your branch: `git push origin your-branch-name`
+4. Create a PR with a descriptive title and summary
+
+**Remember**: PR titles should be concise and follow the format: `feat/fix/docs: description`
\ No newline at end of file
diff --git a/.claude/hooks/lint-and-format.sh b/.claude/hooks/lint-and-format.sh
new file mode 100755
index 000000000..90da4016b
--- /dev/null
+++ b/.claude/hooks/lint-and-format.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Hook to automatically run ruff format and ruff check on Python files
+# Reads JSON input from stdin containing tool information
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract file_path from the JSON input
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null)
+
+# Exit if no file path or jq failed
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Only process Python files
+if [[ ! "$FILE_PATH" =~ \.py$ ]]; then
+  exit 0
+fi
+
+# Check if file exists
+if [ ! -f "$FILE_PATH" ]; then
+  exit 0
+fi
+
+echo "🔧 Auto-formatting and linting $FILE_PATH..."
+
+# Run ruff format on the file (suppress errors)
+uv run ruff format "$FILE_PATH" 2>/dev/null || true
+
+# Run ruff check --fix on the file (suppress errors)
+uv run ruff check --fix "$FILE_PATH" 2>/dev/null || true
+
+echo "✅ Formatted and linted $FILE_PATH"
+
+exit 0
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 000000000..f28cdbc8f
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/lint-and-format.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..a2875d222
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 0
+    exclude-paths:
+      - "samples/**"
diff --git a/.github/labeler.yml b/.github/labeler.yml
new file mode 100644
index 000000000..d83420502
--- /dev/null
+++ b/.github/labeler.yml
@@ -0,0 +1,19 @@
+test:uipath-langchain:
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-platform/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-core/src/**/*.py']
+
+test:uipath-integrations:
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-platform/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-core/src/**/*.py']
+
+test:uipath-runtime:
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-core/src/**/*.py']
diff --git a/.github/scripts/check_dependency_version_bumps.py b/.github/scripts/check_dependency_version_bumps.py
new file mode 100644
index 000000000..fef305dea
--- /dev/null
+++ b/.github/scripts/check_dependency_version_bumps.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Enforce minimum-version bumps between co-changed internal packages.
+
+The monorepo ships several packages that depend on one another
+(``uipath`` -> ``uipath-platform`` -> ``uipath-core``). When a PR changes
+the *source* of a dependency package (say ``uipath-core``) **and** the
+source of one of its dependents (say ``uipath``), the dependent is almost
+certainly relying on the new behaviour. If the dependent does not also
+raise the lower bound of its requirement on the dependency, then anyone who
+installs the dependent on its own can resolve an older dependency that
+predates the new behaviour — a silent runtime break.
+
+This check fails such a PR. For every pair of co-changed (dependency,
+dependent) packages it requires the dependent's lower-bound constraint on
+the dependency (the ``>=`` part of e.g. ``uipath-core>=0.5.8, <0.6.0``) to
+be at least the dependency's new version declared in this PR.
+
+The internal dependency graph is discovered from the pyproject files, so no
+hard-coded list needs maintaining as packages are added.
+"""
+
+import re
+import sys
+from pathlib import Path
+from typing import TypedDict
+
+from check_version_uniqueness import get_changed_packages
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+PACKAGES_DIR = Path("packages")
+
+
+class PackageInfo(TypedDict):
+    """Resolved metadata for a single monorepo package."""
+
+    dir: str
+    name: str
+    version: str
+    dependencies: list[str]
+
+
+def normalize_name(name: str) -> str:
+    """Normalize a PyPI project name (PEP 503): case-insensitive, -/_/.
+    treated as equivalent."""
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def version_key(version: str) -> tuple[int, ...]:
+    """Numeric sort key so ``0.5.17`` > ``0.5.8`` (``0.5.18rc1`` -> ``(0, 5, 18)``)."""
+    parts: list[int] = []
+    for component in version.split("."):
+        digits = ""
+        for ch in component:
+            if ch.isdigit():
+                digits += ch
+            else:
+                break
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts)
+
+
+def parse_requirement(requirement: str) -> tuple[str | None, str | None]:
+    """Extract (normalized name, lower-bound version) from a requirement string.
+
+    Returns the lower bound found in a ``>=`` clause, or ``None`` if there is
+    no ``>=`` constraint. The name is ``None`` if the string is unparseable.
+    """
+    name_match = re.match(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)", requirement)
+    if not name_match:
+        return None, None
+    name = normalize_name(name_match.group(1))
+
+    lower: str | None = None
+    lower_match = re.search(r">=\s*([0-9][0-9A-Za-z._-]*)", requirement)
+    if lower_match:
+        lower = lower_match.group(1)
+    return name, lower
+
+
+def load_package(package_dir: str) -> PackageInfo | None:
+    """Read a package's name, version and dependency list from pyproject.toml."""
+    pyproject = PACKAGES_DIR / package_dir / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    with open(pyproject, "rb") as f:
+        data = tomllib.load(f)
+    project = data.get("project", {})
+    name = project.get("name")
+    version = project.get("version")
+    if not name or not version:
+        return None
+    return PackageInfo(
+        dir=package_dir,
+        name=name,
+        version=version,
+        dependencies=list(project.get("dependencies", [])),
+    )
+
+
+def get_all_packages() -> dict[str, PackageInfo]:
+    """Map package directory name -> package info for every package."""
+    packages: dict[str, PackageInfo] = {}
+    if not PACKAGES_DIR.is_dir():
+        return packages
+    for item in sorted(PACKAGES_DIR.iterdir()):
+        if item.is_dir() and (item / "pyproject.toml").exists():
+            info = load_package(item.name)
+            if info:
+                packages[item.name] = info
+    return packages
+
+
+def check(packages: dict[str, PackageInfo], changed: set[str]) -> list[str]:
+    """Return a list of violation messages (empty when the PR is compliant)."""
+    name_to_dir: dict[str, str] = {
+        normalize_name(info["name"]): pkg_dir for pkg_dir, info in packages.items()
+    }
+
+    violations: list[str] = []
+    for dependent_dir in sorted(changed):
+        dependent = packages.get(dependent_dir)
+        if not dependent:
+            continue
+
+        for requirement in dependent["dependencies"]:
+            dep_name, lower = parse_requirement(requirement)
+            if dep_name is None:
+                continue
+
+            dep_dir = name_to_dir.get(dep_name)
+            # Only internal packages that *also* changed in this PR are in scope.
+            if dep_dir is None or dep_dir == dependent_dir or dep_dir not in changed:
+                continue
+
+            dep_version = packages[dep_dir]["version"]
+            dep_display = packages[dep_dir]["name"]
+
+            if lower is None:
+                violations.append(
+                    f"{dependent['name']} requires '{requirement}' but has no '>=' lower bound on "
+                    f"{dep_display}; pin it to >={dep_version} (both packages changed in this PR)."
+                )
+            elif version_key(lower) < version_key(dep_version):
+                violations.append(
+                    f"{dependent['name']} pins {dep_display}>={lower}, but {dep_display} was bumped to "
+                    f"{dep_version} in this PR. Raise the minimum to >={dep_version}."
+                )
+            else:
+                print(f"OK: {dependent['name']} requires {dep_display}>={lower} (>= new {dep_version})")
+
+    return violations
+
+
+def main() -> int:
+    packages = get_all_packages()
+    if not packages:
+        print("No packages found.")
+        return 0
+
+    changed = set(get_changed_packages())
+    if not changed:
+        print("No source changes to internal packages detected.")
+        return 0
+
+    print(f"Changed packages: {', '.join(sorted(changed))}")
+
+    violations = check(packages, changed)
+    if violations:
+        print("\nDependency version bump check FAILED:\n", file=sys.stderr)
+        for v in violations:
+            print(f"  - {v}", file=sys.stderr)
+        print(
+            "\nWhen you change an internal package and a dependent of it in the same PR, "
+            "the dependent must require the dependency's new version so a standalone install "
+            "cannot resolve an older, incompatible release.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print("\nAll co-changed internal dependencies have an up-to-date minimum version.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
\ No newline at end of file
diff --git a/.github/scripts/check_version_uniqueness.py b/.github/scripts/check_version_uniqueness.py
new file mode 100644
index 000000000..7a40e34eb
--- /dev/null
+++ b/.github/scripts/check_version_uniqueness.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Ensure every changed package has a version not yet published to PyPI.
+
+For each package with file changes in the PR, we read its version from
+pyproject.toml and check whether that exact version exists on PyPI.
+If it does, the check fails — the developer must bump the version.
+
+This catches two scenarios:
+  1. Developer changed code but forgot to bump the version.
+  2. Two PRs raced to the same version — after rebase the first PR's
+     version is already on PyPI, so this check forces the second PR
+     to pick a new one.
+"""
+
+import os
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+def version_exists_on_pypi(package_name: str, version: str) -> bool | None:
+    url = f"https://pypi.org/pypi/{package_name}/{version}/json"
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        with urllib.request.urlopen(req, timeout=10):
+            return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        print(f"Warning: PyPI returned HTTP {e.code} for {package_name}=={version}", file=sys.stderr)
+        return None
+    except Exception as e:
+        print(f"Warning: Could not reach PyPI for {package_name}=={version}: {e}", file=sys.stderr)
+        return None
+
+
+def get_package_info(package_dir: str) -> tuple[str, str] | None:
+    pyproject = Path("packages") / package_dir / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    with open(pyproject, "rb") as f:
+        data = tomllib.load(f)
+    project = data.get("project", {})
+    name = project.get("name")
+    version = project.get("version")
+    if name and version:
+        return name, version
+    return None
+
+
+def get_changed_packages() -> list[str]:
+    base_sha = os.getenv("BASE_SHA", "")
+    head_sha = os.getenv("HEAD_SHA", "")
+    diff_spec = f"{base_sha}...{head_sha}" if base_sha and head_sha else "origin/main...HEAD"
+
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", diff_spec],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"Error running git diff: {e}", file=sys.stderr)
+        return []
+
+    changed = set()
+    for file_path in result.stdout.strip().split("\n"):
+        if file_path.startswith("packages/"):
+            parts = file_path.split("/")
+            if len(parts) >= 3 and parts[2] == "src" and (Path("packages") / parts[1] / "pyproject.toml").exists():
+                changed.add(parts[1])
+    return sorted(changed)
+
+
+def main() -> int:
+    changed = get_changed_packages()
+    if not changed:
+        print("No changed packages detected.")
+        return 0
+
+    conflicts = []
+    failures = []
+    for pkg_dir in changed:
+        info = get_package_info(pkg_dir)
+        if not info:
+            continue
+
+        name, version = info
+        exists = version_exists_on_pypi(name, version)
+
+        if exists is True:
+            print(f"FAIL: {name}=={version} already exists on PyPI")
+            conflicts.append(f"{name}=={version}")
+        elif exists is False:
+            print(f"OK: {name}=={version} is available")
+        else:
+            print(f"FAIL: could not verify {name}=={version}")
+            failures.append(f"{name}=={version}")
+
+    success = len(conflicts) + len(failures) == 0
+    if not success:
+        if conflicts:
+            print(f"\nPlease bump the version in pyproject.toml for: {', '.join(conflicts)}", file=sys.stderr)
+        if failures:
+            print(f"\nError while trying to check the following packages on pypi index: {', '.join(failures)}. Please retry.", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.github/scripts/detect_changed_packages.py b/.github/scripts/detect_changed_packages.py
new file mode 100644
index 000000000..2888ebc2e
--- /dev/null
+++ b/.github/scripts/detect_changed_packages.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Detect which packages have changed in a PR or push to main.
+
+Includes dependency-aware propagation: when a package changes, all
+downstream dependents are also included in the test list.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# Internal dependency graph: package -> packages that depend on it.
+# When a package changes, its dependents' tests also run.
+# Add new entries here as packages are added to the monorepo.
+# External dependents (uipath-langchain, uipath-runtime, etc.) are
+# handled separately via labeler.yml auto-labels.
+DEPENDENTS: dict[str, list[str]] = {
+    "uipath-core": ["uipath-platform", "uipath"],
+    "uipath-platform": ["uipath"],
+}
+
+
+def expand_with_dependents(changed: list[str], all_packages: list[str]) -> list[str]:
+    """Expand changed package list to include downstream dependents."""
+    expanded = set(changed)
+    for pkg in changed:
+        for dep in DEPENDENTS.get(pkg, []):
+            if dep in all_packages:
+                expanded.add(dep)
+    return sorted(expanded)
+
+
+def get_all_packages() -> list[str]:
+    """Get all packages in the monorepo."""
+    packages_dir = Path("packages")
+    packages = []
+
+    for item in packages_dir.iterdir():
+        if item.is_dir() and (item / "pyproject.toml").exists():
+            packages.append(item.name)
+
+    return sorted(packages)
+
+
+def get_changed_packages(base_sha: str, head_sha: str) -> list[str]:
+    """Get packages that have changed between two commits."""
+    try:
+        # Get changed files
+        result = subprocess.run(
+            ["git", "diff", "--name-only", f"{base_sha}...{head_sha}"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        changed_files = result.stdout.strip().split("\n")
+
+        # Extract package names from paths like "packages/uipath-llamaindex/..."
+        changed_packages = set()
+        for file_path in changed_files:
+            if file_path.startswith("packages/"):
+                parts = file_path.split("/")
+                if len(parts) >= 2:
+                    package_name = parts[1]
+                    # Verify it's a real package
+                    if (Path("packages") / package_name / "pyproject.toml").exists():
+                        changed_packages.add(package_name)
+
+        return sorted(changed_packages)
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error running git diff: {e}", file=sys.stderr)
+        return []
+
+
+def get_changed_packages_auto() -> list[str]:
+    """Auto-detect changed packages using git."""
+    try:
+        # Try to detect changes against origin/main
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "origin/main...HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        changed_files = result.stdout.strip().split("\n")
+
+        # Extract package names
+        changed_packages = set()
+        for file_path in changed_files:
+            if file_path.startswith("packages/"):
+                parts = file_path.split("/")
+                if len(parts) >= 2:
+                    package_name = parts[1]
+                    if (Path("packages") / package_name / "pyproject.toml").exists():
+                        changed_packages.add(package_name)
+
+        return sorted(changed_packages)
+
+    except (subprocess.CalledProcessError, Exception) as e:
+        print(f"Warning: Could not auto-detect changes: {e}", file=sys.stderr)
+        return []
+
+
+def main():
+    """Main entry point."""
+    event_name = os.getenv("GITHUB_EVENT_NAME", "")
+    base_sha = os.getenv("BASE_SHA", "")
+    head_sha = os.getenv("HEAD_SHA", "")
+
+    all_packages = get_all_packages()
+
+    # If we have explicit SHAs (from PR or push), detect changed packages
+    if base_sha and head_sha:
+        packages = get_changed_packages(base_sha, head_sha)
+        event_type = "pull request" if event_name == "pull_request" else "push"
+        print(f"{event_type.capitalize()} - detected {len(packages)} directly changed package(s):")
+        for pkg in packages:
+            print(f"  - {pkg}")
+
+    # workflow_call or missing context - try auto-detection
+    else:
+        print(f"Event: {event_name or 'workflow_call'} - attempting auto-detection")
+        packages = get_changed_packages_auto()
+
+        if packages:
+            print(f"Auto-detected {len(packages)} directly changed package(s):")
+            for pkg in packages:
+                print(f"  - {pkg}")
+        else:
+            # Fallback: test all packages
+            print("Could not detect changes - testing all packages")
+            packages = all_packages
+            for pkg in packages:
+                print(f"  - {pkg}")
+
+    # Expand with downstream dependents
+    expanded = expand_with_dependents(packages, all_packages)
+    added = sorted(set(expanded) - set(packages))
+    if added:
+        print(f"\nAdded {len(added)} dependent package(s):")
+        for pkg in added:
+            print(f"  - {pkg}")
+    packages = expanded
+
+    # Output as JSON for GitHub Actions
+    packages_json = json.dumps(packages)
+    print(f"\nPackages JSON: {packages_json}")
+
+    # Write to GitHub output
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"packages={packages_json}\n")
+            f.write(f"count={len(packages)}\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/detect_publishable_packages.py b/.github/scripts/detect_publishable_packages.py
new file mode 100644
index 000000000..7c4715d4d
--- /dev/null
+++ b/.github/scripts/detect_publishable_packages.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Detect which packages need publishing to PyPI.
+
+Compares local package versions against what's already on PyPI.
+Only outputs packages whose local version doesn't exist on PyPI yet.
+"""
+
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+def get_all_packages() -> list[dict[str, str]]:
+    """Get all packages with their names and versions from pyproject.toml."""
+    packages_dir = Path("packages")
+    packages = []
+
+    for item in sorted(packages_dir.iterdir()):
+        pyproject = item / "pyproject.toml"
+        if item.is_dir() and pyproject.exists():
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+            project = data.get("project", {})
+            name = project.get("name")
+            version = project.get("version")
+            if name and version:
+                packages.append(
+                    {"directory": item.name, "name": name, "version": version}
+                )
+
+    return packages
+
+
+def version_exists_on_pypi(package_name: str, version: str) -> bool:
+    """Check if a specific version of a package exists on PyPI."""
+    url = f"https://pypi.org/pypi/{package_name}/{version}/json"
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        with urllib.request.urlopen(req, timeout=10):
+            return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        print(
+            f"  Warning: PyPI returned HTTP {e.code} for {package_name}=={version}",
+            file=sys.stderr,
+        )
+        return False
+    except Exception as e:
+        print(
+            f"  Warning: Could not check PyPI for {package_name}=={version}: {e}",
+            file=sys.stderr,
+        )
+        # If we can't reach PyPI, skip publishing to be safe
+        return True
+
+
+def main():
+    """Main entry point."""
+    all_packages = get_all_packages()
+    publishable = []
+
+    print(f"Checking {len(all_packages)} package(s) against PyPI...")
+
+    for pkg in all_packages:
+        name, version, directory = pkg["name"], pkg["version"], pkg["directory"]
+        exists = version_exists_on_pypi(name, version)
+        if exists:
+            print(f"  {name}=={version} — already on PyPI, skipping")
+        else:
+            print(f"  {name}=={version} — new version, will publish")
+            publishable.append(directory)
+
+    # Output as JSON for GitHub Actions
+    packages_json = json.dumps(publishable)
+    print(f"\nPublishable packages JSON: {packages_json}")
+
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"packages={packages_json}\n")
+            f.write(f"count={len(publishable)}\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/test_check_dependency_version_bumps.py b/.github/scripts/test_check_dependency_version_bumps.py
new file mode 100644
index 000000000..e4135e89f
--- /dev/null
+++ b/.github/scripts/test_check_dependency_version_bumps.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Tests for check_dependency_version_bumps.py."""
+
+from unittest import mock
+
+from check_dependency_version_bumps import (
+    PackageInfo,
+    check,
+    normalize_name,
+    parse_requirement,
+    version_key,
+)
+
+
+def pkg(name: str, version: str, dependencies: list[str] | None = None) -> PackageInfo:
+    return PackageInfo(
+        dir=name,
+        name=name,
+        version=version,
+        dependencies=dependencies or [],
+    )
+
+
+class TestVersionKey:
+    def test_numeric_components(self):
+        assert version_key("0.5.18") == (0, 5, 18)
+
+    def test_compares_numerically_not_lexically(self):
+        # The trap a string compare would fall into: "0.5.8" > "0.5.17".
+        assert version_key("0.5.17") > version_key("0.5.8")
+
+    def test_strips_prerelease_suffix(self):
+        assert version_key("0.5.18rc1") == (0, 5, 18)
+
+
+class TestNormalizeName:
+    def test_case_and_separators_equivalent(self):
+        assert normalize_name("UiPath_Core") == normalize_name("uipath-core")
+        assert normalize_name("uipath.core") == "uipath-core"
+
+
+class TestParseRequirement:
+    def test_extracts_name_and_lower_bound(self):
+        assert parse_requirement("uipath-core>=0.5.8, <0.6.0") == ("uipath-core", "0.5.8")
+
+    def test_no_lower_bound(self):
+        assert parse_requirement("click") == ("click", None)
+        assert parse_requirement("httpx<1.0") == ("httpx", None)
+
+    def test_whitespace_after_operator(self):
+        assert parse_requirement("uipath-core >= 0.5.8") == ("uipath-core", "0.5.8")
+
+
+class TestCheck:
+    def _packages(self) -> dict[str, PackageInfo]:
+        return {
+            "uipath-core": pkg("uipath-core", "0.5.18"),
+            "uipath-platform": pkg(
+                "uipath-platform", "0.1.60", ["uipath-core>=0.5.8, <0.6.0"]
+            ),
+            "uipath": pkg(
+                "uipath",
+                "2.10.74",
+                [
+                    "uipath-core>=0.5.8, <0.6.0",
+                    "uipath-platform>=0.1.59, <0.2.0",
+                    "click>=8.3.1",
+                ],
+            ),
+        }
+
+    def test_passes_when_only_dependency_changed(self):
+        # uipath-core changed alone -> dependents not touched, nothing to enforce.
+        assert check(self._packages(), {"uipath-core"}) == []
+
+    def test_passes_when_only_dependent_changed(self):
+        assert check(self._packages(), {"uipath"}) == []
+
+    def test_fails_when_co_changed_without_min_bump(self):
+        # uipath-core bumped to 0.5.18 but uipath still pins >=0.5.8.
+        violations = check(self._packages(), {"uipath-core", "uipath"})
+        assert len(violations) == 1
+        assert "uipath" in violations[0]
+        assert "0.5.18" in violations[0]
+
+    def test_passes_when_min_raised_to_new_version(self):
+        packages = self._packages()
+        packages["uipath"]["dependencies"] = [
+            "uipath-core>=0.5.18, <0.6.0",
+            "click>=8.3.1",
+        ]
+        assert check(packages, {"uipath-core", "uipath"}) == []
+
+    def test_passes_when_min_already_above_new_version(self):
+        packages = self._packages()
+        packages["uipath"]["dependencies"] = ["uipath-core>=0.6.0, <0.7.0"]
+        assert check(packages, {"uipath-core", "uipath"}) == []
+
+    def test_fails_when_no_lower_bound_on_co_changed_dep(self):
+        packages = self._packages()
+        packages["uipath"]["dependencies"] = ["uipath-core"]
+        violations = check(packages, {"uipath-core", "uipath"})
+        assert len(violations) == 1
+        assert "no '>=' lower bound" in violations[0]
+
+    def test_external_dependencies_are_ignored(self):
+        # click is not an internal package, so it is never in scope.
+        assert check(self._packages(), {"uipath"}) == []
+
+    def test_transitive_chain_each_edge_enforced(self):
+        # All three changed: uipath must bump core AND platform; platform must bump core.
+        packages = self._packages()
+        violations = check(packages, {"uipath-core", "uipath-platform", "uipath"})
+        # uipath->core (stale), uipath->platform (0.1.59 < 0.1.60), platform->core (stale)
+        assert len(violations) == 3
+
+    def test_no_self_reference(self):
+        packages = {"uipath": pkg("uipath", "2.0.0", ["uipath>=1.0.0"])}
+        assert check(packages, {"uipath"}) == []
+
+
+class TestMain:
+    def _run(self, packages: dict[str, PackageInfo], changed: list[str]) -> int:
+        from check_dependency_version_bumps import main
+
+        with (
+            mock.patch("check_dependency_version_bumps.get_all_packages", return_value=packages),
+            mock.patch("check_dependency_version_bumps.get_changed_packages", return_value=changed),
+        ):
+            return main()
+
+    def test_returns_zero_when_compliant(self):
+        packages = {
+            "uipath-core": pkg("uipath-core", "0.5.18"),
+            "uipath": pkg("uipath", "2.0.0", ["uipath-core>=0.5.18, <0.6.0"]),
+        }
+        assert self._run(packages, ["uipath-core", "uipath"]) == 0
+
+    def test_returns_one_on_violation(self):
+        packages = {
+            "uipath-core": pkg("uipath-core", "0.5.18"),
+            "uipath": pkg("uipath", "2.0.0", ["uipath-core>=0.5.8, <0.6.0"]),
+        }
+        assert self._run(packages, ["uipath-core", "uipath"]) == 1
+
+    def test_returns_zero_when_no_changes(self):
+        assert self._run({"uipath-core": pkg("uipath-core", "0.5.18")}, []) == 0
\ No newline at end of file
diff --git a/.github/scripts/test_check_version_uniqueness.py b/.github/scripts/test_check_version_uniqueness.py
new file mode 100644
index 000000000..af4298af1
--- /dev/null
+++ b/.github/scripts/test_check_version_uniqueness.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Tests for check_version_uniqueness.py."""
+
+import os
+import urllib.error
+from unittest import mock
+
+
+from check_version_uniqueness import (
+    get_package_info,
+    main,
+    version_exists_on_pypi,
+)
+
+
+class TestVersionExistsOnPypi:
+    def test_returns_true_when_version_exists(self):
+        mock_response = mock.MagicMock()
+        mock_response.__enter__ = mock.MagicMock(return_value=mock_response)
+        mock_response.__exit__ = mock.MagicMock(return_value=False)
+
+        with mock.patch("urllib.request.urlopen", return_value=mock_response):
+            assert version_exists_on_pypi("some-package", "1.0.0") is True
+
+    def test_returns_false_when_404(self):
+        error = urllib.error.HTTPError(
+            url="", code=404, msg="Not Found", hdrs=None, fp=None  # type: ignore[arg-type]
+        )
+        with mock.patch("urllib.request.urlopen", side_effect=error):
+            assert version_exists_on_pypi("some-package", "9.9.9") is False
+
+    def test_returns_none_on_server_error(self):
+        error = urllib.error.HTTPError(
+            url="", code=500, msg="Server Error", hdrs=None, fp=None  # type: ignore[arg-type]
+        )
+        with mock.patch("urllib.request.urlopen", side_effect=error):
+            assert version_exists_on_pypi("some-package", "1.0.0") is None
+
+    def test_returns_none_on_network_error(self):
+        with mock.patch(
+            "urllib.request.urlopen", side_effect=ConnectionError("no network")
+        ):
+            assert version_exists_on_pypi("some-package", "1.0.0") is None
+
+
+class TestGetPackageInfo:
+    def test_reads_name_and_version(self, tmp_path):
+        pkg = tmp_path / "packages" / "my-pkg"
+        pkg.mkdir(parents=True)
+        (pkg / "pyproject.toml").write_text(
+            '[project]\nname = "my-pkg"\nversion = "1.2.3"\n'
+        )
+        with mock.patch(
+            "check_version_uniqueness.Path",
+            side_effect=lambda p: tmp_path / p if p == "packages" else __import__("pathlib").Path(p),
+        ):
+            assert get_package_info("my-pkg") == ("my-pkg", "1.2.3")
+
+    def test_returns_none_for_missing_file(self):
+        assert get_package_info("nonexistent-package-xyz") is None
+
+
+class TestMain:
+    def _run(self, changed, package_info, pypi_result):
+        patches = [
+            mock.patch("check_version_uniqueness.get_changed_packages", return_value=changed),
+            mock.patch("check_version_uniqueness.get_package_info", side_effect=lambda d: package_info.get(d)),
+            mock.patch("check_version_uniqueness.version_exists_on_pypi", return_value=pypi_result),
+        ]
+        with patches[0], patches[1], patches[2]:
+            os.environ.pop("BASE_SHA", None)
+            os.environ.pop("HEAD_SHA", None)
+            return main()
+
+    def test_passes_when_version_not_on_pypi(self):
+        assert self._run(["my-pkg"], {"my-pkg": ("my-pkg", "2.0.0")}, False) == 0
+
+    def test_fails_when_version_exists_on_pypi(self):
+        assert self._run(["my-pkg"], {"my-pkg": ("my-pkg", "2.0.0")}, True) == 1
+
+    def test_fails_on_network_error(self):
+        assert self._run(["my-pkg"], {"my-pkg": ("my-pkg", "2.0.0")}, None) == 1
+
+    def test_no_changed_packages(self):
+        assert self._run([], {}, False) == 0
+
+    def test_fails_when_version_unchanged_but_on_pypi(self):
+        """The key scenario: code changed, version not bumped, already on PyPI."""
+        assert self._run(["my-pkg"], {"my-pkg": ("my-pkg", "1.0.0")}, True) == 1
+
+    def test_multiple_packages_one_conflict(self):
+        def pypi_check(name, version):
+            return name == "pkg-a"
+
+        with (
+            mock.patch("check_version_uniqueness.get_changed_packages", return_value=["pkg-a", "pkg-b"]),
+            mock.patch(
+                "check_version_uniqueness.get_package_info",
+                side_effect=lambda d: {"pkg-a": ("pkg-a", "1.0.0"), "pkg-b": ("pkg-b", "2.0.0")}.get(d),
+            ),
+            mock.patch("check_version_uniqueness.version_exists_on_pypi", side_effect=pypi_check),
+        ):
+            os.environ.pop("BASE_SHA", None)
+            os.environ.pop("HEAD_SHA", None)
+            assert main() == 1
diff --git a/.github/scripts/test_detect_publishable_packages.py b/.github/scripts/test_detect_publishable_packages.py
new file mode 100644
index 000000000..88d88d93c
--- /dev/null
+++ b/.github/scripts/test_detect_publishable_packages.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Tests for detect_publishable_packages.py."""
+
+import json
+import os
+import tempfile
+import urllib.error
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from detect_publishable_packages import (
+    get_all_packages,
+    main,
+    version_exists_on_pypi,
+)
+
+
+@pytest.fixture()
+def packages_dir(tmp_path: Path):
+    """Create a fake packages directory with pyproject.toml files."""
+    pkg_a = tmp_path / "packages" / "pkg-a"
+    pkg_a.mkdir(parents=True)
+    (pkg_a / "pyproject.toml").write_text(
+        '[project]\nname = "pkg-a"\nversion = "1.0.0"\n'
+    )
+
+    pkg_b = tmp_path / "packages" / "pkg-b"
+    pkg_b.mkdir(parents=True)
+    (pkg_b / "pyproject.toml").write_text(
+        '[project]\nname = "pkg-b"\nversion = "2.0.0"\n'
+    )
+
+    # Directory without pyproject.toml — should be ignored
+    no_toml = tmp_path / "packages" / "no-toml"
+    no_toml.mkdir(parents=True)
+
+    # Directory with pyproject.toml missing version — should be ignored
+    no_version = tmp_path / "packages" / "no-version"
+    no_version.mkdir(parents=True)
+    (no_version / "pyproject.toml").write_text("[project]\n")
+
+    return tmp_path
+
+
+class TestGetAllPackages:
+    def test_detects_packages(self, packages_dir: Path):
+        with mock.patch(
+            "detect_publishable_packages.Path",
+            side_effect=lambda p: packages_dir / p if p == "packages" else Path(p),
+        ):
+            packages = get_all_packages()
+
+        assert len(packages) == 2
+        names = {p["name"] for p in packages}
+        assert names == {"pkg-a", "pkg-b"}
+
+    def test_returns_correct_fields(self, packages_dir: Path):
+        with mock.patch(
+            "detect_publishable_packages.Path",
+            side_effect=lambda p: packages_dir / p if p == "packages" else Path(p),
+        ):
+            packages = get_all_packages()
+
+        pkg_a = next(p for p in packages if p["name"] == "pkg-a")
+        assert pkg_a["directory"] == "pkg-a"
+        assert pkg_a["version"] == "1.0.0"
+
+
+class TestVersionExistsOnPypi:
+    def test_returns_true_when_version_exists(self):
+        mock_response = mock.MagicMock()
+        mock_response.__enter__ = mock.MagicMock(return_value=mock_response)
+        mock_response.__exit__ = mock.MagicMock(return_value=False)
+
+        with mock.patch("urllib.request.urlopen", return_value=mock_response):
+            assert version_exists_on_pypi("some-package", "1.0.0") is True
+
+    def test_returns_false_when_404(self):
+        error = urllib.error.HTTPError(
+            url="", code=404, msg="Not Found", hdrs=None, fp=None  # type: ignore[arg-type]
+        )
+        with mock.patch("urllib.request.urlopen", side_effect=error):
+            assert version_exists_on_pypi("some-package", "9.9.9") is False
+
+    def test_returns_false_on_other_http_error(self):
+        error = urllib.error.HTTPError(
+            url="", code=500, msg="Server Error", hdrs=None, fp=None  # type: ignore[arg-type]
+        )
+        with mock.patch("urllib.request.urlopen", side_effect=error):
+            assert version_exists_on_pypi("some-package", "1.0.0") is False
+
+    def test_returns_true_on_network_error(self):
+        with mock.patch(
+            "urllib.request.urlopen", side_effect=ConnectionError("no network")
+        ):
+            assert version_exists_on_pypi("some-package", "1.0.0") is True
+
+
+class TestMain:
+    def test_publishes_new_versions_only(self, packages_dir: Path):
+        def mock_pypi(name: str, version: str) -> bool:
+            # pkg-a 1.0.0 exists, pkg-b 2.0.0 does not
+            return name == "pkg-a" and version == "1.0.0"
+
+        with (
+            mock.patch(
+                "detect_publishable_packages.Path",
+                side_effect=lambda p: packages_dir / p if p == "packages" else Path(p),
+            ),
+            mock.patch(
+                "detect_publishable_packages.version_exists_on_pypi",
+                side_effect=mock_pypi,
+            ),
+        ):
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+                output_file = f.name
+
+            try:
+                os.environ["GITHUB_OUTPUT"] = output_file
+                main()
+
+                with open(output_file) as f:
+                    content = f.read()
+
+                assert "packages=" in content
+                assert "count=" in content
+
+                # Parse the output
+                lines = content.strip().split("\n")
+                packages_line = next(l for l in lines if l.startswith("packages="))
+                count_line = next(l for l in lines if l.startswith("count="))
+
+                packages = json.loads(packages_line.split("=", 1)[1])
+                count = int(count_line.split("=", 1)[1])
+
+                assert packages == ["pkg-b"]
+                assert count == 1
+            finally:
+                os.unlink(output_file)
+                os.environ.pop("GITHUB_OUTPUT", None)
+
+    def test_nothing_to_publish(self, packages_dir: Path):
+        with (
+            mock.patch(
+                "detect_publishable_packages.Path",
+                side_effect=lambda p: packages_dir / p if p == "packages" else Path(p),
+            ),
+            mock.patch(
+                "detect_publishable_packages.version_exists_on_pypi",
+                return_value=True,
+            ),
+        ):
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+                output_file = f.name
+
+            try:
+                os.environ["GITHUB_OUTPUT"] = output_file
+                main()
+
+                with open(output_file) as f:
+                    content = f.read()
+
+                packages_line = next(
+                    l for l in content.strip().split("\n") if l.startswith("packages=")
+                )
+                count_line = next(
+                    l for l in content.strip().split("\n") if l.startswith("count=")
+                )
+
+                assert json.loads(packages_line.split("=", 1)[1]) == []
+                assert int(count_line.split("=", 1)[1]) == 0
+            finally:
+                os.unlink(output_file)
+                os.environ.pop("GITHUB_OUTPUT", None)
diff --git a/.github/scripts/wait_for_pypi.py b/.github/scripts/wait_for_pypi.py
new file mode 100644
index 000000000..bc2186e03
--- /dev/null
+++ b/.github/scripts/wait_for_pypi.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Wait for a package version to become available on PyPI.
+
+Usage: python wait_for_pypi.py <package-directory-name>
+
+Reads the package name and version from packages/<dir>/pyproject.toml,
+then polls PyPI until the version appears or a timeout is reached.
+"""
+
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+MAX_WAIT = 300  # 5 minutes
+POLL_INTERVAL = 15  # seconds
+
+
+def version_exists_on_pypi(package_name: str, version: str) -> bool:
+    """Check if a specific version of a package exists on PyPI."""
+    url = f"https://pypi.org/pypi/{package_name}/{version}/json"
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        with urllib.request.urlopen(req, timeout=10):
+            return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        print(f"  Warning: PyPI returned HTTP {e.code}", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"  Warning: Could not reach PyPI: {e}", file=sys.stderr)
+        return False
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <package-directory>", file=sys.stderr)
+        return 1
+
+    directory = sys.argv[1]
+    pyproject = Path("packages") / directory / "pyproject.toml"
+
+    if not pyproject.exists():
+        print(f"ERROR: {pyproject} not found", file=sys.stderr)
+        return 1
+
+    with open(pyproject, "rb") as f:
+        data = tomllib.load(f)
+
+    name = data["project"]["name"]
+    version = data["project"]["version"]
+
+    print(f"Waiting for {name}=={version} to appear on PyPI...")
+    elapsed = 0
+    while elapsed < MAX_WAIT:
+        if version_exists_on_pypi(name, version):
+            print(f"{name}=={version} is now available on PyPI.")
+            return 0
+        time.sleep(POLL_INTERVAL)
+        elapsed += POLL_INTERVAL
+        print(f"  Still waiting... ({elapsed}s/{MAX_WAIT}s)")
+
+    print(
+        f"ERROR: {name}=={version} did not appear on PyPI within {MAX_WAIT}s",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.github/scripts/write_uv_overrides.py b/.github/scripts/write_uv_overrides.py
new file mode 100644
index 000000000..557f9d26e
--- /dev/null
+++ b/.github/scripts/write_uv_overrides.py
@@ -0,0 +1,50 @@
+"""Write a uv override file forcing the locally built uipath wheels.
+
+Cross-test workflows build uipath wheels from the PR and run them against
+downstream repos (uipath-langchain-python, uipath-integrations-python,
+uipath-runtime-python). Those downstreams cap the uipath* version (e.g.
+``uipath<2.11.0``), so a backward-compatible minor bump would fail resolution
+purely on the cap. uv ``override-dependencies`` ignore the declared version
+specifier, so pointing them at the local wheels lets the cross-test exercise the
+real new code regardless of the cap.
+
+The script is layout-agnostic: it overrides whatever ``uipath*`` wheels exist
+under ``$GITHUB_WORKSPACE/wheels`` (recursively), so it works for the
+three-wheel layout (``wheels/<pkg>/dist/*.whl``) and the single-wheel runtime
+layout (``wheels/*.whl``) alike.
+
+The resulting override file path is appended to ``GITHUB_ENV`` as ``UV_OVERRIDE``
+so every subsequent ``uv`` invocation in the job honors it.
+"""
+
+import glob
+import os
+import pathlib
+
+
+def main() -> None:
+    wheels = pathlib.Path(os.environ.get("GITHUB_WORKSPACE", ".")).resolve() / "wheels"
+
+    lines = []
+    for whl in sorted(glob.glob(str(wheels / "**" / "*.whl"), recursive=True)):
+        # Wheel filename is ``{distribution}-{version}-...whl`` where the
+        # distribution escapes hyphens to underscores (uipath_core -> uipath-core).
+        dist = pathlib.Path(whl).name.split("-", 1)[0].replace("_", "-")
+        if not dist.startswith("uipath"):
+            continue
+        lines.append(f"{dist} @ {pathlib.Path(whl).resolve().as_uri()}")
+
+    if not lines:
+        raise SystemExit(f"no uipath wheels found under {wheels}")
+
+    out = wheels / "overrides.txt"
+    out.write_text("\n".join(lines) + "\n")
+
+    with open(os.environ["GITHUB_ENV"], "a") as fh:
+        fh.write(f"UV_OVERRIDE={out}\n")
+
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/workflows/auto-label.yml b/.github/workflows/auto-label.yml
new file mode 100644
index 000000000..a5f67bcc7
--- /dev/null
+++ b/.github/workflows/auto-label.yml
@@ -0,0 +1,19 @@
+name: Auto Label PRs
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Label PR
+        uses: actions/labeler@v5
+        with:
+          configuration-path: '.github/labeler.yml'
+          sync-labels: true
diff --git a/.github/workflows/build-package.yml b/.github/workflows/build-package.yml
new file mode 100644
index 000000000..54cd05352
--- /dev/null
+++ b/.github/workflows/build-package.yml
@@ -0,0 +1,78 @@
+name: Build Package
+
+on:
+  workflow_call:
+    inputs:
+      package:
+        description: 'Package directory name (e.g. uipath-core)'
+        required: true
+        type: string
+      needs-relock:
+        description: 'Whether to re-lock against PyPI before building (for packages with internal dependencies)'
+        required: false
+        type: boolean
+        default: false
+    secrets:
+      APPLICATIONINSIGHTS_CONNECTION_STRING:
+        required: false
+
+permissions:
+  contents: read
+  actions: write
+
+jobs:
+  build:
+    name: Build ${{ inputs.package }}
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: packages/${{ inputs.package }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "packages/${{ inputs.package }}/.python-version"
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Update AGENTS.md
+        if: inputs.package == 'uipath'
+        run: uv run python scripts/update_agents_md.py
+
+      - name: Replace connection string placeholder
+        if: inputs.package == 'uipath'
+        run: |
+          originalfile="src/uipath/telemetry/_constants.py"
+          tmpfile=$(mktemp)
+          trap 'rm -f "$tmpfile"' EXIT
+          rsync -a --no-whole-file --ignore-existing "$originalfile" "$tmpfile"
+          envsubst '$CONNECTION_STRING' < "$originalfile" > "$tmpfile" && mv "$tmpfile" "$originalfile"
+        env:
+          CONNECTION_STRING: ${{ secrets.APPLICATIONINSIGHTS_CONNECTION_STRING }}
+
+      - name: Re-lock against PyPI
+        if: inputs.needs-relock
+        run: |
+          for i in 1 2 3; do
+            uv lock --no-sources --no-cache && break
+            echo "Attempt $i failed, retrying in 5s..."
+            sleep 5
+          done
+
+      - name: Build
+        run: uv build --no-sources --package ${{ inputs.package }}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists-${{ inputs.package }}
+          path: packages/${{ inputs.package }}/dist/
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
index cbe4c448c..82aa4ccb2 100644
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -6,82 +6,187 @@ on:
     branches:
       - main
     paths:
-      - pyproject.toml
+      - 'packages/*/pyproject.toml'
+      - '!packages/*/samples/**/pyproject.toml'
+      - '!packages/*/testcases/**/pyproject.toml'
 
-jobs:
-  lint:
-    uses: ./.github/workflows/lint.yml
-
-  test:
-    uses: ./.github/workflows/test.yml
+permissions:
+  contents: read
+  pull-requests: read
+  id-token: write
+  actions: write
 
-  build:
-    name: Build
+jobs:
+  detect-publishable-packages:
     runs-on: ubuntu-latest
+    outputs:
+      packages: ${{ steps.detect.outputs.packages }}
+      count: ${{ steps.detect.outputs.count }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-    needs:
-      - lint
-      - test
-
-    if: ${{ github.repository == 'UiPath/uipath-python' }}
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Detect publishable packages
+        id: detect
+        run: python .github/scripts/detect_publishable_packages.py
+
+  # --- Tier 0: uipath-core (no internal dependencies) ---
+  build-uipath-core:
+    needs: detect-publishable-packages
+    if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')
+    uses: ./.github/workflows/build-package.yml
+    with:
+      package: uipath-core
+      needs-relock: false
+
+  publish-uipath-core:
+    name: Publish uipath-core
+    needs: [detect-publishable-packages, build-uipath-core]
+    if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')
+    runs-on: ubuntu-latest
+    environment: pypi
     permissions:
       contents: read
-      actions: write
+      id-token: write
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists-uipath-core
+          path: dist/
 
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          skip-existing: true
+
+  wait-for-uipath-core:
+    name: Wait for uipath-core on PyPI
+    needs: [detect-publishable-packages, publish-uipath-core]
+    if: |
+      always() &&
+      (contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform') ||
+       contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath'))
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')
         uses: actions/checkout@v4
 
-      - name: Setup uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
       - name: Setup Python
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')
         uses: actions/setup-python@v5
         with:
-          python-version-file: ".python-version"
-
-      - name: Install dependencies
-        run: uv sync --all-extras
-
-      - name: Replace connection string placeholder
-        run: |
-          originalfile="src/uipath/telemetry/_constants.py"
-          tmpfile=$(mktemp)
-          trap 'rm -f "$tmpfile"' EXIT
-
-          rsync -a --no-whole-file --ignore-existing "$originalfile" "$tmpfile"
-          envsubst '$CONNECTION_STRING' < "$originalfile" > "$tmpfile" && mv "$tmpfile" "$originalfile"
-        env:
-          CONNECTION_STRING: ${{ secrets.APPINS_CONNECTION_STRING }}
-
-      - name: Build
-        run: uv build
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+          python-version: '3.11'
+
+      - name: Wait for uipath-core
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')
+        run: python .github/scripts/wait_for_pypi.py uipath-core
+
+      - name: Skip
+        if: "!contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-core')"
+        run: echo "uipath-core not being published — skipping wait"
+
+  # --- Tier 1: uipath-platform (depends on core) ---
+  build-uipath-platform:
+    needs: [detect-publishable-packages, wait-for-uipath-core]
+    if: |
+      always() &&
+      contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')
+    uses: ./.github/workflows/build-package.yml
+    with:
+      package: uipath-platform
+      needs-relock: true
+
+  publish-uipath-platform:
+    name: Publish uipath-platform
+    needs: [detect-publishable-packages, build-uipath-platform]
+    if: |
+      always() &&
+      contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
         with:
-          name: release-dists
+          name: release-dists-uipath-platform
           path: dist/
 
-  pypi-publish:
-    name: Upload release to PyPI
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          skip-existing: true
+
+  wait-for-uipath-platform:
+    name: Wait for uipath-platform on PyPI
+    needs: [detect-publishable-packages, publish-uipath-platform]
+    if: |
+      always() &&
+      contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath')
     runs-on: ubuntu-latest
-    environment: pypi
+    steps:
+      - name: Checkout
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')
+        uses: actions/checkout@v4
 
-    needs:
-      - build
+      - name: Setup Python
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Wait for uipath-platform
+        if: contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')
+        run: python .github/scripts/wait_for_pypi.py uipath-platform
+
+      - name: Skip
+        if: "!contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath-platform')"
+        run: echo "uipath-platform not being published — skipping wait"
+
+  # --- Tier 2: uipath (depends on core + platform) ---
+  build-uipath:
+    needs: [detect-publishable-packages, wait-for-uipath-platform]
+    if: |
+      always() &&
+      contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath')
+    uses: ./.github/workflows/build-package.yml
+    with:
+      package: uipath
+      needs-relock: true
+    secrets:
+      APPLICATIONINSIGHTS_CONNECTION_STRING: ${{ secrets.APPLICATIONINSIGHTS_CONNECTION_STRING }}
+
+  publish-uipath:
+    name: Publish uipath
+    needs: [detect-publishable-packages, build-uipath]
+    if: |
+      always() &&
+      contains(fromJson(needs.detect-publishable-packages.outputs.packages), 'uipath')
+    runs-on: ubuntu-latest
+    environment: pypi
     permissions:
       contents: read
       id-token: write
-
     steps:
       - name: Retrieve release distributions
         uses: actions/download-artifact@v4
         with:
-          name: release-dists
+          name: release-dists-uipath
           path: dist/
 
       - name: Publish package distributions to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          skip-existing: true
diff --git a/.github/workflows/check-dependency-bumps.yml b/.github/workflows/check-dependency-bumps.yml
new file mode 100644
index 000000000..acdff63a6
--- /dev/null
+++ b/.github/workflows/check-dependency-bumps.yml
@@ -0,0 +1,28 @@
+name: Check Dependency Version Bumps
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  check-dependency-bumps:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Enforce min-version bumps for co-changed internal packages
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/check_dependency_version_bumps.py
\ No newline at end of file
diff --git a/.github/workflows/check-version-availability.yml b/.github/workflows/check-version-availability.yml
new file mode 100644
index 000000000..02ace93c1
--- /dev/null
+++ b/.github/workflows/check-version-availability.yml
@@ -0,0 +1,28 @@
+name: Check Version Availability
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  check-version-availability:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Check changed package versions are not on PyPI
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/check_version_uniqueness.py
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 10192fb7f..1dd0471f0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,22 +1,33 @@
 name: CI
 
 on:
-  push:
+  pull_request:
     branches:
       - main
-    paths-ignore:
-      - pyproject.toml
-  pull_request:
+  push:
     branches:
       - main
 
+permissions:
+  contents: read
+
 jobs:
   commit-lint:
     if: ${{ github.event_name == 'pull_request' }}
     uses: ./.github/workflows/commitlint.yml
 
   lint:
-    uses: ./.github/workflows/lint.yml
+    uses: ./.github/workflows/lint-packages.yml
 
   test:
-    uses: ./.github/workflows/test.yml
+    uses: ./.github/workflows/test-packages.yml
+    secrets:
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+
+  check-versions:
+    if: github.event_name == 'pull_request'
+    uses: ./.github/workflows/check-version-availability.yml
+
+  check-dependency-bumps:
+    if: github.event_name == 'pull_request'
+    uses: ./.github/workflows/check-dependency-bumps.yml
diff --git a/.github/workflows/integration_tests.yml b/.github/workflows/integration_tests.yml
new file mode 100644
index 000000000..69311181f
--- /dev/null
+++ b/.github/workflows/integration_tests.yml
@@ -0,0 +1,146 @@
+name: uipath - Integration Tests
+
+on:
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+  pull-requests: write
+  actions: read
+
+jobs:
+  detect-changed-packages:
+    runs-on: ubuntu-latest
+    outputs:
+      packages: ${{ steps.detect.outputs.packages }}
+      count: ${{ steps.detect.outputs.count }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Detect changed packages
+        id: detect
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/detect_changed_packages.py
+
+  discover-testcases:
+    needs: [detect-changed-packages]
+    if: needs.detect-changed-packages.outputs.count > 0
+    runs-on: ubuntu-latest
+    outputs:
+      testcases: ${{ steps.discover.outputs.testcases }}
+      count: ${{ steps.discover.outputs.count }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Discover testcases
+      id: discover
+      env:
+        PACKAGES: ${{ needs.detect-changed-packages.outputs.packages }}
+      run: |
+        # Discover testcases from all affected packages
+        all_testcases="[]"
+
+        for package in $(echo "$PACKAGES" | jq -r '.[]'); do
+          testcases_dir="packages/$package/testcases"
+          if [ -d "$testcases_dir" ]; then
+            testcase_dirs=$(find "$testcases_dir" -maxdepth 1 -type d -name "*-*" | sed "s|$testcases_dir/||" | sort)
+            if [ -n "$testcase_dirs" ]; then
+              echo "Found testcases in $package:"
+              echo "$testcase_dirs"
+              # Add as package/testcase entries
+              package_testcases=$(echo "$testcase_dirs" | jq -R -c --arg pkg "$package" '{package: $pkg, testcase: .}')
+              all_testcases=$(echo "$all_testcases" | jq -c --argjson new "[$( echo "$package_testcases" | paste -sd, )]" '. + $new')
+            fi
+          fi
+        done
+
+        echo "All testcases: $all_testcases"
+        count=$(echo "$all_testcases" | jq 'length')
+        echo "testcases=$all_testcases" >> $GITHUB_OUTPUT
+        echo "count=$count" >> $GITHUB_OUTPUT
+
+  integration-tests:
+    needs: [discover-testcases]
+    if: needs.discover-testcases.outputs.count > 0
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/astral-sh/uv:python3.12-bookworm
+      env:
+        UIPATH_JOB_KEY: "3a03d5cb-fa21-4021-894d-a8e2eda0afe0"
+        UIPATH_TRACING_ENABLED: false
+    strategy:
+      fail-fast: false
+      matrix:
+        testcase: ${{ fromJson(needs.discover-testcases.outputs.testcases) }}
+        environment: [alpha, cloud, staging]
+
+    name: "${{ matrix.testcase.testcase }} / ${{ matrix.environment }}"
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Install dependencies
+      working-directory: packages/${{ matrix.testcase.package }}
+      run: uv sync
+
+    - name: Run testcase
+      env:
+        CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_ID || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_ID }}
+        CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_SECRET || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_SECRET }}
+        BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || matrix.environment == 'staging' && secrets.STAGING_BASE_URL || matrix.environment == 'cloud' && secrets.CLOUD_BASE_URL }}
+
+        USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}
+
+        # App Insights for telemetry testing
+        TELEMETRY_CONNECTION_STRING: ${{ secrets.APPLICATIONINSIGHTS_CONNECTION_STRING }}
+        APP_INSIGHTS_APP_ID: ${{ secrets.APP_INSIGHTS_APP_ID }}
+        APP_INSIGHTS_API_KEY: ${{ secrets.APP_INSIGHTS_API_KEY }}
+      working-directory: packages/${{ matrix.testcase.package }}/testcases/${{ matrix.testcase.testcase }}
+      run: |
+        # If any errors occur execution will stop with exit code
+        set -e
+
+        echo "Running testcase: ${{ matrix.testcase.testcase }}"
+        echo "Package: ${{ matrix.testcase.package }}"
+        echo "Environment: ${{ matrix.environment }}"
+        echo "Working directory: $(pwd)"
+
+        # Execute the testcase run script directly
+        bash run.sh
+        bash ../common/validate_output.sh
+
+  summarize-results:
+    needs: [detect-changed-packages, discover-testcases, integration-tests]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Check integration tests status
+        run: |
+          if [[ "${{ needs.detect-changed-packages.outputs.count }}" == "0" ]]; then
+            echo "No packages changed - skipping integration tests"
+            exit 0
+          fi
+          if [[ "${{ needs.discover-testcases.outputs.count }}" == "0" ]]; then
+            echo "No testcases found for changed packages - skipping"
+            exit 0
+          fi
+          if [[ "${{ needs.integration-tests.result }}" == "success" ]]; then
+            echo "All integration tests passed"
+          else
+            echo "Some integration tests failed"
+            exit 1
+          fi
diff --git a/.github/workflows/lint-packages.yml b/.github/workflows/lint-packages.yml
new file mode 100644
index 000000000..d530e25a9
--- /dev/null
+++ b/.github/workflows/lint-packages.yml
@@ -0,0 +1,215 @@
+name: Lint Packages
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  detect-changed-packages:
+    runs-on: ubuntu-latest
+    outputs:
+      packages: ${{ steps.detect.outputs.packages }}
+      count: ${{ steps.detect.outputs.count }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Detect changed packages
+        id: detect
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/detect_changed_packages.py
+
+  lint-uipath-core:
+    name: Lint uipath-core
+    needs: detect-changed-packages
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if package changed
+        id: check
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath-core")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        run: echo "Skipping - no changes to uipath-core"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "packages/uipath-core/.python-version"
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-core
+        run: uv sync --locked --all-extras
+
+      - name: Check static types
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-core
+        run: uv run mypy --config-file pyproject.toml .
+
+      - name: Check linting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-core
+        run: uv run ruff check .
+
+      - name: Check formatting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-core
+        run: uv run ruff format --check .
+
+  lint-uipath-platform:
+    name: Lint uipath-platform
+    needs: detect-changed-packages
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if package changed
+        id: check
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath-platform")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        run: echo "Skipping - no changes to uipath-platform"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "packages/uipath-platform/.python-version"
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv sync --locked --all-extras
+
+      - name: Check static types
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv run mypy --config-file pyproject.toml .
+
+      - name: Check linting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv run ruff check .
+
+      - name: Check formatting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv run ruff format --check .
+
+  lint-uipath:
+    name: Lint uipath
+    needs: detect-changed-packages
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if package changed
+        id: check
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        run: echo "Skipping - no changes to uipath"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "packages/uipath/.python-version"
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv sync --locked --all-extras
+
+      - name: Check static types
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv run mypy --config-file pyproject.toml .
+
+      - name: Check linting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv run ruff check .
+
+      - name: Check formatting
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv run ruff format --check .
+
+      - name: Check httpx.Client() usage
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv run python scripts/lint_httpx_client.py
+
+  lint-gate:
+    name: Lint
+    needs: [lint-uipath-core, lint-uipath-platform, lint-uipath]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Check lint results
+        run: |
+          if [[ "${{ needs.lint-uipath-core.result }}" == "failure" || \
+                "${{ needs.lint-uipath-platform.result }}" == "failure" || \
+                "${{ needs.lint-uipath.result }}" == "failure" ]]; then
+            echo "Lint failed"
+            exit 1
+          fi
+          echo "All lint checks passed"
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
deleted file mode 100644
index 80f2c94a6..000000000
--- a/.github/workflows/lint.yml
+++ /dev/null
@@ -1,41 +0,0 @@
-name: Lint
-
-on:
-  workflow_call
-
-jobs:
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version-file: ".python-version"
-
-      - name: Install dependencies
-        run: uv sync --all-extras
-
-      - name: Check static types
-        run: uv run mypy --config-file pyproject.toml .
-
-      - name: Check linting
-        run: uv run ruff check .
-
-      - name: Check formatting
-        run: uv run ruff format --check .
-      
-      - name: Check httpx.Client() usage
-        run: uv run python scripts/lint_httpx_client.py
-
diff --git a/.github/workflows/publish-dev.yml b/.github/workflows/publish-dev.yml
index bbc95dbda..d1b218f99 100644
--- a/.github/workflows/publish-dev.yml
+++ b/.github/workflows/publish-dev.yml
@@ -3,16 +3,53 @@ name: Publish Dev Build
 on:
   pull_request:
     types: [opened, synchronize, reopened, labeled]
+    paths:
+      - 'packages/**'
+      - '.github/workflows/publish-dev.yml'
+      - '.github/scripts/detect_changed_packages.py'
+
+permissions:
+  contents: read
+  pull-requests: write
 
 jobs:
-  publish-dev:
+  detect-changed-packages:
+    if: contains(github.event.pull_request.labels.*.name, 'build:dev')
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
+    outputs:
+      packages: ${{ steps.detect.outputs.packages }}
+      count: ${{ steps.detect.outputs.count }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
-    # Only run if PR has the build:dev label
-    if: contains(github.event.pull_request.labels.*.name, 'build:dev')
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Detect changed packages
+        id: detect
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/detect_changed_packages.py
+
+  publish-dev:
+    name: Publish Dev Build - ${{ matrix.package }}
+    needs: detect-changed-packages
+    if: contains(github.event.pull_request.labels.*.name, 'build:dev') && needs.detect-changed-packages.outputs.count > 0
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: packages/${{ matrix.package }}
+    strategy:
+      fail-fast: false
+      matrix:
+        package: ${{ fromJson(needs.detect-changed-packages.outputs.packages) }}
 
     steps:
       - name: Checkout
@@ -26,12 +63,13 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v5
         with:
-          python-version-file: ".python-version"
+          python-version-file: "packages/${{ matrix.package }}/.python-version"
 
       - name: Install dependencies
         run: uv sync --all-extras
 
       - name: Replace connection string placeholder
+        if: matrix.package == 'uipath'
         run: |
           originalfile="src/uipath/telemetry/_constants.py"
           tmpfile=$(mktemp)
@@ -40,19 +78,19 @@ jobs:
           rsync -a --no-whole-file --ignore-existing "$originalfile" "$tmpfile"
           envsubst '$CONNECTION_STRING' < "$originalfile" > "$tmpfile" && mv "$tmpfile" "$originalfile"
         env:
-          CONNECTION_STRING: ${{ secrets.APPINS_CONNECTION_STRING }}
+          CONNECTION_STRING: ${{ secrets.APPLICATIONINSIGHTS_CONNECTION_STRING }}
 
       - name: Set development version
         shell: pwsh
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          $pyprojcontent = Get-Content pyproject.toml -Raw
+          $pyprojPath = "pyproject.toml"
+          $pyprojcontent = Get-Content $pyprojPath -Raw
 
           $PROJECT_NAME    = ($pyprojcontent | Select-String -Pattern '(?m)^\[(project|tool\.poetry)\][^\[]*?name\s*=\s*"([^"]*)"' -AllMatches).Matches[0].Groups[2].Value
           $CURRENT_VERSION = ($pyprojcontent | Select-String -Pattern '(?m)^\[(project|tool\.poetry)\][^\[]*?version\s*=\s*"([^"]*)"' -AllMatches).Matches[0].Groups[2].Value
 
-
           # Get PR number and run number with proper padding
           $PR_NUM = [int]"${{ github.event.pull_request.number }}"
           $PADDED_PR  = "{0:D5}" -f [int]"${{ github.event.pull_request.number }}"
@@ -67,23 +105,57 @@ jobs:
           $DEV_VERSION = "$CURRENT_VERSION.dev1$PADDED_PR$PADDED_RUN"
 
           # Update version in pyproject.toml
-          (Get-Content pyproject.toml) -replace "version = `"$CURRENT_VERSION`"", "version = `"$DEV_VERSION`"" | Set-Content pyproject.toml
+          (Get-Content $pyprojPath) -replace "version = `"$CURRENT_VERSION`"", "version = `"$DEV_VERSION`"" | Set-Content $pyprojPath
 
-          Write-Output "Package version set to $DEV_VERSION"
+          Write-Output "Package $PROJECT_NAME version set to $DEV_VERSION"
 
-          $dependencyMessage = @"
-          ## Development Package
+          # Shared dev suffix for every package built in this run (same PR + run number)
+          $DEV_SUFFIX = "dev1$PADDED_PR$PADDED_RUN"
+
+          # Intra-repo dependencies per package. A dev build of these is < the package's
+          # base version (PEP 440 pre-release), so it falls outside the published ">=base"
+          # constraint and must be forced in via [tool.uv] override-dependencies.
+          $internalDepsMap = @{
+            "uipath"          = @("uipath-platform", "uipath-core")
+            "uipath-platform" = @("uipath-core")
+            "uipath-core"     = @()
+          }
+
+          # Packages also published in this run (their dev builds exist on testpypi)
+          $changedPackages = '${{ needs.detect-changed-packages.outputs.packages }}' | ConvertFrom-Json
+
+          $overrideDeps = @()
+          foreach ($dep in $internalDepsMap[$PROJECT_NAME]) {
+            if ($changedPackages -contains $dep) {
+              $depPyproj = Get-Content "../$dep/pyproject.toml" -Raw
+              $depBaseVersion = ($depPyproj | Select-String -Pattern '(?m)^\[(project|tool\.poetry)\][^\[]*?version\s*=\s*"([^"]*)"' -AllMatches).Matches[0].Groups[2].Value
+              $overrideDeps += [PSCustomObject]@{ Name = $dep; Version = "$depBaseVersion.$DEV_SUFFIX" }
+            }
+          }
+
+          # [tool.uv.sources]: the package itself plus every overridden dep point at testpypi
+          $sourcesLines = @("$PROJECT_NAME = { index = `"testpypi`" }")
+          foreach ($d in $overrideDeps) { $sourcesLines += "$($d.Name) = { index = `"testpypi`" }" }
+          $sourcesBlock = $sourcesLines -join "`n"
+
+          # Optional [tool.uv] override block (omitted when no intra-repo dep was published)
+          $overrideBlock = ""
+          if ($overrideDeps.Count -gt 0) {
+            $overrideItems = ($overrideDeps | ForEach-Object { "`"$($_.Name)==$($_.Version)`"" }) -join ", "
+            $overrideBlock = "`n[tool.uv]`noverride-dependencies = [$overrideItems]`n"
+          }
 
-          - Add this package as a dependency in your pyproject.toml:
+          $dependencyMessage = @"
+          ### $PROJECT_NAME
 
           ``````toml
           [project]
           dependencies = [
-            # Exact version:
+            # Exact version (copy-paste ready):
             "$PROJECT_NAME==$DEV_VERSION",
 
-            # Any version from PR
-            "$PROJECT_NAME>=$MIN_VERSION,<$MAX_VERSION"
+            # Any version from this PR (uncomment to use a range instead):
+            # "$PROJECT_NAME>=$MIN_VERSION,<$MAX_VERSION",
           ]
 
           [[tool.uv.index]]
@@ -93,8 +165,8 @@ jobs:
           explicit = true
 
           [tool.uv.sources]
-          $PROJECT_NAME = { index = "testpypi" }
-          ``````
+          $sourcesBlock
+          $overrideBlock``````
           "@
 
           # Get the owner and repo from the GitHub repository
@@ -112,29 +184,80 @@ jobs:
           $pr = Invoke-RestMethod -Uri $prUri -Method Get -Headers $headers
           $currentBody = $pr.body
 
-          # Check if there's already a development package section
-          if ($currentBody -match '## Development Package') {
-            # Replace the existing section with the new dependency message
-            $newBody = $currentBody -replace '## Development Package(\r?\n|.)*?(?=##|$)', $dependencyMessage
+          # Define regex patterns for matching package sections
+          $devPackagesHeader = "## Development Packages"
+          $packageHeaderPattern = "### $PROJECT_NAME\s*\n"
+
+          # Find if the package section exists using multiline regex
+          $packageSectionRegex = "(?ms)### $PROJECT_NAME\s*\n``````toml.*?``````"
+
+          if ($currentBody -match $devPackagesHeader) {
+            # Development Packages section exists
+            if ($currentBody -match $packageSectionRegex) {
+              # Replace existing package section
+              Write-Output "Updating existing $PROJECT_NAME section"
+              $newBody = $currentBody -replace $packageSectionRegex, $dependencyMessage.Trim()
+            } else {
+              # Append new package section after the Development Packages header
+              Write-Output "Adding new $PROJECT_NAME section"
+              $insertPoint = $currentBody.IndexOf($devPackagesHeader) + $devPackagesHeader.Length
+              $newBody = $currentBody.Insert($insertPoint, "`n`n$dependencyMessage")
+            }
           } else {
-            # Append the dependency message to the end of the description
-            $newBody = if ($currentBody) { "$currentBody`n`n$dependencyMessage" } else { $dependencyMessage }
-          }
-
-          # Update the PR description
-          $updateBody = @{
-            body = $newBody
-          } | ConvertTo-Json
+            # Create the Development Packages section
+            Write-Output "Creating Development Packages section with $PROJECT_NAME"
+            $packageSection = @"
+          ## Development Packages
 
-          Invoke-RestMethod -Uri $prUri -Method Patch -Headers $headers -Body $updateBody -ContentType "application/json"
+          $dependencyMessage
+          "@
+            $newBody = if ($currentBody) { "$currentBody`n`n$packageSection" } else { $packageSection }
+          }
 
-          Write-Output "Updated PR description with development package information"
+          # Update the PR description with retry logic
+          $maxRetries = 3
+          $retryCount = 0
+          $success = $false
+
+          while (-not $success -and $retryCount -lt $maxRetries) {
+            try {
+              $updateBody = @{
+                body = $newBody
+              } | ConvertTo-Json
+
+              Invoke-RestMethod -Uri $prUri -Method Patch -Headers $headers -Body $updateBody -ContentType "application/json" | Out-Null
+              $success = $true
+              Write-Output "Successfully updated PR description with $PROJECT_NAME information"
+            } catch {
+              $retryCount++
+              if ($retryCount -lt $maxRetries) {
+                Write-Output "Failed to update PR description, retrying ($retryCount/$maxRetries)..."
+                Start-Sleep -Seconds 2
+                # Re-fetch PR body in case another job updated it
+                $pr = Invoke-RestMethod -Uri $prUri -Method Get -Headers $headers
+                $currentBody = $pr.body
+
+                # Recompute newBody with fresh data
+                if ($currentBody -match $packageSectionRegex) {
+                  $newBody = $currentBody -replace $packageSectionRegex, $dependencyMessage.Trim()
+                } elseif ($currentBody -match $devPackagesHeader) {
+                  $insertPoint = $currentBody.IndexOf($devPackagesHeader) + $devPackagesHeader.Length
+                  $newBody = $currentBody.Insert($insertPoint, "`n`n$dependencyMessage")
+                } else {
+                  $packageSection = "$devPackagesHeader`n`n$dependencyMessage"
+                  $newBody = if ($currentBody) { "$currentBody`n`n$packageSection" } else { $packageSection }
+                }
+              } else {
+                Write-Output "Failed to update PR description after $maxRetries attempts"
+                throw
+              }
+            }
+          }
 
       - name: Build package
-        run: uv build
+        run: uv build --no-sources --package ${{ matrix.package }}
 
       - name: Publish
         run: uv publish --index testpypi
         env:
-          UV_PUBLISH_TOKEN: ${{ secrets.TESTPYPI_TOKEN }}
-
+          UV_PUBLISH_TOKEN: ${{ matrix.package == 'uipath' && secrets.TESTPYPI_TOKEN || matrix.package == 'uipath-platform' && secrets.TESTPYPI_TOKEN_PLATFORM || secrets.TESTPYPI_TOKEN_CORE }}
diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml
index ac8c384f9..417cd09c9 100644
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -6,9 +6,13 @@ on:
     branches:
       - main
     paths:
-      - "docs/**"
-      - "mkdocs.yml"
-      - "pyproject.toml"
+      - "packages/uipath/docs/**"
+      - "packages/uipath/mkdocs.yml"
+      - "packages/uipath/pyproject.toml"
+      - "packages/uipath-platform/src/**"
+      - "packages/uipath-platform/pyproject.toml"
+      - "packages/uipath-core/src/**"
+      - "packages/uipath-core/pyproject.toml"
   repository_dispatch:
     types: [publish-docs]
 
@@ -31,25 +35,30 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v5
         with:
-          python-version-file: ".python-version"
+          python-version-file: "packages/uipath/.python-version"
 
       - name: Install dependencies
+        working-directory: packages/uipath
         run: uv sync --all-extras
 
       - name: Clone plugins
         run: |
           git clone https://x-access-token:${{ secrets.REPO_ACCESS }}@github.com/UiPath/uipath-langchain-python plugins/uipath-langchain-python
-          git clone https://x-access-token:${{ secrets.REPO_ACCESS }}@github.com/UiPath/uipath-llamaindex-python plugins/uipath-llamaindex-python
+          git clone https://x-access-token:${{ secrets.REPO_ACCESS }}@github.com/UiPath/uipath-integrations-python plugins/uipath-integrations-python
           git clone https://x-access-token:${{ secrets.REPO_ACCESS }}@github.com/UiPath/uipath-mcp-python plugins/uipath-mcp-python
 
       - name: Symlink plugin docs
+        working-directory: packages/uipath
         run: |
-          ln -s ../plugins/uipath-langchain-python/docs docs/langchain
-          ln -s ../plugins/uipath-llamaindex-python/docs docs/llamaindex
-          ln -s ../plugins/uipath-mcp-python/docs docs/mcp
+          ln -s ../../../plugins/uipath-langchain-python/docs docs/langchain
+          ln -s ../../../plugins/uipath-integrations-python/packages/uipath-llamaindex/docs docs/llamaindex
+          ln -s ../../../plugins/uipath-integrations-python/packages/uipath-openai-agents/docs docs/openai-agents
+          ln -s ../../../plugins/uipath-mcp-python/docs docs/mcp
           ls -a docs/langchain
           ls -a docs/llamaindex
+          ls -a docs/openai-agents
           ls -a docs/mcp
 
       - name: Publish Docs
+        working-directory: packages/uipath
         run: uv run mkdocs gh-deploy --force
diff --git a/.github/workflows/slack.yml b/.github/workflows/slack.yml
deleted file mode 100644
index 493d43a28..000000000
--- a/.github/workflows/slack.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-name: GitHub Reviewer Slack Agent
-
-on:
-  pull_request:
-    types: [opened]
-
-jobs:
-  trigger-uipath-agent:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Python dependencies
-        run: pip install requests
-
-      - name: Trigger UiPath Agent
-        env:
-          PR_NUMBER: ${{ github.event.number }}
-          REPO_NAME: ${{ github.repository }}
-          OWNER_NAME: ${{ github.repository_owner }}
-        run: |
-          python -c "import requests; import json; import os; comment = {'messages': [{'role': 'user', 'content': f'You are reviewing PR #{os.environ['PR_NUMBER']}, repo: {os.environ['REPO_NAME']}, owner: {os.environ['OWNER_NAME']}'}]}; payload = json.dumps(comment); resp = requests.post('${{ secrets.UIPATH_SLACK_URL }}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs', headers={'Authorization': 'Bearer ${{ secrets.UIPATH_SLACK_PAT }}', 'Content-Type': 'application/json', 'X-UiPath-FolderPath': 'MCP Folder'}, json={'startInfo': {'releaseName': 'github-slack-agent', 'inputArguments': payload}}); print(f'Status code: {resp.status_code}'); print(f'Response: {resp.text}')"
diff --git a/.github/workflows/test-cd-scripts.yml b/.github/workflows/test-cd-scripts.yml
new file mode 100644
index 000000000..3c6655a9d
--- /dev/null
+++ b/.github/workflows/test-cd-scripts.yml
@@ -0,0 +1,38 @@
+name: Test CD Scripts
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - '.github/scripts/detect_publishable_packages.py'
+      - '.github/scripts/test_detect_publishable_packages.py'
+      - '.github/scripts/check_version_uniqueness.py'
+      - '.github/scripts/test_check_version_uniqueness.py'
+      - '.github/scripts/check_dependency_version_bumps.py'
+      - '.github/scripts/test_check_dependency_version_bumps.py'
+      - '.github/workflows/cd.yml'
+      - '.github/workflows/check-version-availability.yml'
+      - '.github/workflows/check-dependency-bumps.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  test-cd-scripts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install pytest
+        run: pip install pytest
+
+      - name: Run tests
+        working-directory: .github/scripts
+        run: python -m pytest test_detect_publishable_packages.py test_check_version_uniqueness.py test_check_dependency_version_bumps.py -v
diff --git a/.github/workflows/test-packages.yml b/.github/workflows/test-packages.yml
new file mode 100644
index 000000000..f35d77e8f
--- /dev/null
+++ b/.github/workflows/test-packages.yml
@@ -0,0 +1,363 @@
+name: Test Packages
+
+on:
+  workflow_call:
+    secrets:
+      SONAR_TOKEN:
+        required: false
+
+permissions:
+  contents: read
+
+jobs:
+  detect-changed-packages:
+    runs-on: ubuntu-latest
+    outputs:
+      packages: ${{ steps.detect.outputs.packages }}
+      count: ${{ steps.detect.outputs.count }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Detect changed packages
+        id: detect
+        env:
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python .github/scripts/detect_changed_packages.py
+
+  test-uipath-core:
+    name: Test (uipath-core, ${{ matrix.python-version }}, ${{ matrix.os }})
+    needs: detect-changed-packages
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - name: Check if package changed
+        id: check
+        shell: bash
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath-core")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        shell: bash
+        run: echo "Skipping - no changes to uipath-core"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-core
+        run: uv sync --all-extras --python ${{ matrix.python-version }}
+
+      - name: Run tests
+        if: steps.check.outputs.skip != 'true' && !(matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13')
+        working-directory: packages/uipath-core
+        run: uv run pytest
+
+      - name: Run tests with coverage
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
+        working-directory: packages/uipath-core
+        run: uv run pytest --cov-report=xml --cov-report=html --tb=short
+
+      - name: Upload coverage HTML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html-uipath-core
+          path: packages/uipath-core/htmlcov/
+          retention-days: 30
+
+      - name: Upload coverage XML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml-uipath-core
+          path: packages/uipath-core/coverage.xml
+          retention-days: 30
+
+  test-uipath-platform:
+    name: Test (uipath-platform, ${{ matrix.python-version }}, ${{ matrix.os }})
+    needs: detect-changed-packages
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - name: Check if package changed
+        id: check
+        shell: bash
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath-platform")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        shell: bash
+        run: echo "Skipping - no changes to uipath-platform"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv sync --all-extras --python ${{ matrix.python-version }}
+
+      - name: Run tests
+        if: steps.check.outputs.skip != 'true' && !(matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13')
+        working-directory: packages/uipath-platform
+        run: uv run pytest
+
+      - name: Run tests with coverage
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
+        working-directory: packages/uipath-platform
+        run: uv run pytest --cov-report=xml --cov-report=html --tb=short
+
+      - name: Upload coverage HTML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html-uipath-platform
+          path: packages/uipath-platform/htmlcov/
+          retention-days: 30
+
+      - name: Upload coverage XML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml-uipath-platform
+          path: packages/uipath-platform/coverage.xml
+          retention-days: 30
+
+  e2e-uipath-platform:
+    name: E2E (uipath-platform, memory)
+    needs: detect-changed-packages
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if package changed
+        id: check
+        shell: bash
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath-platform")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        shell: bash
+        run: echo "Skipping - no changes to uipath-platform"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        run: uv sync --all-extras --python 3.11
+
+      - name: Run E2E memory tests
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath-platform
+        env:
+          UIPATH_URL: ${{ secrets.ALPHA_BASE_URL }}
+          UIPATH_CLIENT_ID: ${{ secrets.ALPHA_TEST_CLIENT_ID }}
+          UIPATH_CLIENT_SECRET: ${{ secrets.ALPHA_TEST_CLIENT_SECRET }}
+          UIPATH_FOLDER_KEY: ${{ secrets.UIPATH_MEMORY_FOLDER }}
+        run: uv run pytest tests/services/test_memory_service_e2e.py -m e2e -v --no-cov
+
+  test-uipath:
+    name: Test (uipath, ${{ matrix.python-version }}, ${{ matrix.os }})
+    needs: detect-changed-packages
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - name: Check if package changed
+        id: check
+        shell: bash
+        run: |
+          if echo '${{ needs.detect-changed-packages.outputs.packages }}' | jq -e 'index("uipath")' > /dev/null; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+          else
+            echo "skip=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Skip
+        if: steps.check.outputs.skip == 'true'
+        shell: bash
+        run: echo "Skipping - no changes to uipath"
+
+      - name: Checkout
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        if: steps.check.outputs.skip != 'true'
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        if: steps.check.outputs.skip != 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/uipath
+        run: uv sync --all-extras --python ${{ matrix.python-version }}
+
+      - name: Run tests
+        if: steps.check.outputs.skip != 'true' && !(matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13')
+        working-directory: packages/uipath
+        run: uv run pytest
+
+      - name: Run tests with coverage
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
+        working-directory: packages/uipath
+        run: uv run pytest --cov-report=xml --cov-report=html --tb=short
+
+      - name: Upload coverage HTML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html-uipath
+          path: packages/uipath/htmlcov/
+          retention-days: 30
+
+      - name: Upload coverage XML report
+        if: steps.check.outputs.skip != 'true' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml-uipath
+          path: packages/uipath/coverage.xml
+          retention-days: 30
+
+    continue-on-error: true
+
+  sonarcloud:
+    name: SonarCloud
+    needs: [test-uipath-core, test-uipath-platform, test-uipath]
+    runs-on: ubuntu-latest
+    if: always() && needs.test-uipath-core.result != 'failure' && needs.test-uipath-platform.result != 'failure' && needs.test-uipath.result != 'failure'
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Download uipath-core coverage
+        uses: actions/download-artifact@v4
+        continue-on-error: true
+        with:
+          name: coverage-xml-uipath-core
+          path: packages/uipath-core
+
+      - name: Download uipath-platform coverage
+        uses: actions/download-artifact@v4
+        continue-on-error: true
+        with:
+          name: coverage-xml-uipath-platform
+          path: packages/uipath-platform
+
+      - name: Download uipath coverage
+        uses: actions/download-artifact@v4
+        continue-on-error: true
+        with:
+          name: coverage-xml-uipath
+          path: packages/uipath
+
+      - name: Rewrite coverage XML <source> to repo-relative paths
+        run: |
+          sed -i 's|<source>src</source>|<source>packages/uipath-core/src</source>|g' packages/uipath-core/coverage.xml || true
+          sed -i 's|<source>src</source>|<source>packages/uipath-platform/src</source>|g' packages/uipath-platform/coverage.xml || true
+          sed -i 's|<source>src</source>|<source>packages/uipath/src</source>|g' packages/uipath/coverage.xml || true
+
+      - name: SonarCloud Scan
+        uses: SonarSource/sonarqube-scan-action@2f77a1ec69fb1d595b06f35ab27e97605bdef703 # v5
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+
+  test-gate:
+    name: Test
+    needs: [test-uipath-core, test-uipath-platform, test-uipath, e2e-uipath-platform]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Check test results
+        run: |
+          if [[ "${{ needs.test-uipath-core.result }}" == "failure" || \
+                "${{ needs.test-uipath-platform.result }}" == "failure" || \
+                "${{ needs.test-uipath.result }}" == "failure" ]]; then
+            echo "Tests failed"
+            exit 1
+          fi
+          # E2E tests are informational — log but don't block
+          if [[ "${{ needs.e2e-uipath-platform.result }}" == "failure" ]]; then
+            echo "⚠️ E2E memory tests failed (non-blocking)"
+          fi
+          echo "All tests passed"
diff --git a/.github/workflows/test-uipath-integrations.yml b/.github/workflows/test-uipath-integrations.yml
new file mode 100644
index 000000000..95c621941
--- /dev/null
+++ b/.github/workflows/test-uipath-integrations.yml
@@ -0,0 +1,292 @@
+name: uipath - Test Integrations
+
+on:
+  pull_request:
+    types: [ opened, synchronize, reopened, labeled ]
+
+jobs:
+  build-wheels:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    if: contains(github.event.pull_request.labels.*.name, 'test:uipath-integrations')
+    steps:
+      - name: Checkout uipath-python
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build uipath-core package
+        working-directory: packages/uipath-core
+        run: uv build
+
+      - name: Build uipath-platform package
+        working-directory: packages/uipath-platform
+        run: uv build
+
+      - name: Build uipath package
+        working-directory: packages/uipath
+        run: uv build
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: uipath-wheels
+          path: packages/*/dist/*.whl
+
+  discover-packages:
+    needs: [build-wheels]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      packages: ${{ steps.discover.outputs.packages }}
+    steps:
+      - name: Checkout uipath-integrations-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-integrations-python'
+          path: 'uipath-integrations-python'
+
+      - name: Discover packages
+        id: discover
+        working-directory: uipath-integrations-python
+        run: |
+          # Find every package directory under packages/ that has a pyproject.toml
+          package_dirs=$(find packages -maxdepth 2 -name pyproject.toml -printf '%h\n' | sed 's|^packages/||' | sort)
+
+          echo "Found integration packages:"
+          echo "$package_dirs"
+
+          packages_json=$(echo "$package_dirs" | jq -R -s -c 'split("\n")[:-1]')
+          echo "packages=$packages_json" >> $GITHUB_OUTPUT
+
+  test-package:
+    needs: [build-wheels, discover-packages]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        package: ${{ fromJson(needs.discover-packages.outputs.packages) }}
+        python-version: [ "3.11", "3.12", "3.13" ]
+        os: [ ubuntu-latest, windows-latest ]
+
+    name: "${{ matrix.package }} / py${{ matrix.python-version }} / ${{ matrix.os }}"
+    permissions:
+      contents: read
+
+    steps:
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: uipath-wheels
+          path: wheels
+
+      - name: Checkout uipath-integrations-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-integrations-python'
+          path: 'uipath-integrations-python'
+
+      - name: Checkout uipath-python scripts
+        uses: actions/checkout@v4
+        with:
+          path: _scripts
+          sparse-checkout: .github/scripts
+
+      - name: Override uipath packages with local wheels
+        shell: bash
+        run: |
+          PYBIN=$(command -v python || command -v python3)
+          "$PYBIN" "$GITHUB_WORKSPACE/_scripts/.github/scripts/write_uv_overrides.py"
+
+      - name: Install dependencies and run tests
+        shell: bash
+        working-directory: uipath-integrations-python/packages/${{ matrix.package }}
+        run: |
+          uv sync
+          if [ -d tests ]; then
+            uv run pytest
+          else
+            echo "No tests directory found in ${{ matrix.package }}, skipping pytest"
+          fi
+
+  discover-testcases:
+    needs: [test-package, discover-packages]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      matrix: ${{ steps.discover.outputs.matrix }}
+      has_testcases: ${{ steps.discover.outputs.has_testcases }}
+    steps:
+      - name: Checkout uipath-integrations-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-integrations-python'
+          path: 'uipath-integrations-python'
+
+      - name: Discover testcases across packages
+        id: discover
+        working-directory: uipath-integrations-python
+        run: |
+          # For each package with a testcases/ directory, list its testcase folders
+          # and emit one matrix entry per (package, testcase) pair.
+          entries="[]"
+          for pkg_dir in packages/*/; do
+            pkg=$(basename "$pkg_dir")
+            tc_dir="$pkg_dir/testcases"
+            if [ ! -d "$tc_dir" ]; then
+              continue
+            fi
+            testcases=$(find "$tc_dir" -maxdepth 1 -type d -name "*-*" -printf '%f\n' | sort)
+            if [ -z "$testcases" ]; then
+              continue
+            fi
+            for tc in $testcases; do
+              entries=$(echo "$entries" | jq --arg p "$pkg" --arg t "$tc" '. + [{package: $p, testcase: $t}]')
+            done
+          done
+
+          echo "Discovered testcase matrix:"
+          echo "$entries" | jq .
+
+          count=$(echo "$entries" | jq 'length')
+          if [ "$count" -eq 0 ]; then
+            echo "has_testcases=false" >> $GITHUB_OUTPUT
+            echo "matrix=[]" >> $GITHUB_OUTPUT
+          else
+            echo "has_testcases=true" >> $GITHUB_OUTPUT
+            echo "matrix=$(echo "$entries" | jq -c .)" >> $GITHUB_OUTPUT
+          fi
+
+  run-integration-tests:
+    needs: [build-wheels, discover-testcases]
+    if: needs.discover-testcases.outputs.has_testcases == 'true'
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/astral-sh/uv:python3.12-bookworm
+      env:
+        UIPATH_JOB_KEY: "3a03d5cb-fa21-4021-894d-a8e2eda0afe0"
+        UIPATH_TRACING_ENABLED: false
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.discover-testcases.outputs.matrix) }}
+        environment: [alpha, staging] # temporary disable [cloud]
+
+    name: "${{ matrix.package }} / ${{ matrix.testcase }} / ${{ matrix.environment }}"
+
+    steps:
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: uipath-wheels
+          path: wheels
+
+      - name: Checkout uipath-integrations-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-integrations-python'
+          path: 'uipath-integrations-python'
+
+      - name: Checkout uipath-python scripts
+        uses: actions/checkout@v4
+        with:
+          path: _scripts
+          sparse-checkout: .github/scripts
+
+      - name: Override uipath packages with local wheels
+        shell: bash
+        run: |
+          PYBIN=$(command -v python || command -v python3)
+          "$PYBIN" "$GITHUB_WORKSPACE/_scripts/.github/scripts/write_uv_overrides.py"
+
+      - name: Install dependencies
+        working-directory: uipath-integrations-python/packages/${{ matrix.package }}
+        run: uv sync
+
+      - name: Run testcase
+        env:
+          CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_ID || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_ID }}
+          CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_SECRET || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_SECRET }}
+          BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || matrix.environment == 'staging' && secrets.STAGING_BASE_URL || matrix.environment == 'cloud' && secrets.CLOUD_BASE_URL }}
+          UV_PYTHON: "3.12"
+        working-directory: uipath-integrations-python/packages/${{ matrix.package }}/testcases/${{ matrix.testcase }}
+        run: |
+          echo "Package: ${{ matrix.package }}"
+          echo "Testcase: ${{ matrix.testcase }}"
+          echo "Environment: ${{ matrix.environment }}"
+
+          bash run.sh
+          bash ../common/validate_output.sh
+
+  notify-on-failure:
+    needs: [test-package, run-integration-tests]
+    if: always() && contains(github.event.pull_request.labels.*.name, 'test:uipath-integrations') && (needs.test-package.result == 'failure' || needs.run-integration-tests.result == 'failure')
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Comment on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const marker = '<!-- cross-test-failure:uipath-integrations -->';
+            const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
+            const body = [
+              marker,
+              '## :rotating_light: **Heads up: `uipath-integrations` cross-tests are FAILING** :rotating_light:',
+              '',
+              'Your changes may break one or more integrations in **[`uipath-integrations-python`](https://github.com/UiPath/uipath-integrations-python)**:',
+              '',
+              '- `uipath-openai-agents`',
+              '- `uipath-google-adk`',
+              '- `uipath-agent-framework`',
+              '- `uipath-llamaindex`',
+              '- `uipath-pydantic-ai`',
+              '',
+              '> :warning: **These checks are NOT enforced by branch protection rules.** Please review the failures before merging.',
+              '',
+              `**:mag: [Inspect the failed run →](${runUrl})**`,
+            ].join('\n');
+
+            // Delete any prior failure comments for this workflow so the new
+            // one always lands at the bottom of the PR conversation.
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+            for (const c of comments) {
+              if (c.body && c.body.includes(marker)) {
+                await github.rest.issues.deleteComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  comment_id: c.id,
+                });
+              }
+            }
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body,
+            });
diff --git a/.github/workflows/test-uipath-langchain.yml b/.github/workflows/test-uipath-langchain.yml
new file mode 100644
index 000000000..25b027633
--- /dev/null
+++ b/.github/workflows/test-uipath-langchain.yml
@@ -0,0 +1,233 @@
+name: uipath - Test Langchain
+
+on:
+  pull_request:
+    types: [ opened, synchronize, reopened, labeled ]
+
+jobs:
+  build-wheels:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    if: contains(github.event.pull_request.labels.*.name, 'test:uipath-langchain')
+    steps:
+      - name: Checkout uipath-python
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build uipath-core package
+        working-directory: packages/uipath-core
+        run: uv build
+
+      - name: Build uipath-platform package
+        working-directory: packages/uipath-platform
+        run: uv build
+
+      - name: Build uipath package
+        working-directory: packages/uipath
+        run: uv build
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: uipath-wheels
+          path: packages/*/dist/*.whl
+
+  test-uipath-langchain:
+    needs: [build-wheels]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        python-version: [ "3.11", "3.12", "3.13" ]
+        os: [ ubuntu-latest, windows-latest ]
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: uipath-wheels
+          path: wheels
+
+      - name: Checkout uipath-langchain-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-langchain-python'
+          path: 'uipath-langchain-python'
+
+      - name: Checkout uipath-python scripts
+        uses: actions/checkout@v4
+        with:
+          path: _scripts
+          sparse-checkout: .github/scripts
+
+      - name: Override uipath packages with local wheels
+        shell: bash
+        run: |
+          PYBIN=$(command -v python || command -v python3)
+          "$PYBIN" "$GITHUB_WORKSPACE/_scripts/.github/scripts/write_uv_overrides.py"
+
+      - name: Run uipath-langchain tests
+        working-directory: uipath-langchain-python
+        run: |
+          uv sync --all-extras
+          uv run pytest
+
+  discover-testcases:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    needs: [test-uipath-langchain]
+    outputs:
+      testcases: ${{ steps.discover.outputs.testcases }}
+    steps:
+      - name: Checkout uipath-langchain-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-langchain-python'
+          path: 'uipath-langchain-python'
+
+      - name: Discover testcases
+        id: discover
+        working-directory: uipath-langchain-python
+        run: |
+          # Find all testcase folders (excluding common folders like README, etc.)
+          testcase_dirs=$(find testcases -maxdepth 1 -type d -name "*-*" | sed 's|testcases/||' | sort)
+
+          echo "Found testcase directories:"
+          echo "$testcase_dirs"
+
+          # Convert to JSON array for matrix
+          testcases_json=$(echo "$testcase_dirs" | jq -R -s -c 'split("\n")[:-1]')
+          echo "testcases=$testcases_json" >> $GITHUB_OUTPUT
+
+  run-uipath-langchain-integration-tests:
+    runs-on: ubuntu-latest
+    needs: [build-wheels, discover-testcases]
+    container:
+      image: ghcr.io/astral-sh/uv:python3.12-bookworm
+      env:
+        UIPATH_JOB_KEY: "3a03d5cb-fa21-4021-894d-a8e2eda0afe0"
+        UIPATH_TRACING_ENABLED: false
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        testcase: ${{ fromJson(needs.discover-testcases.outputs.testcases) }}
+        environment: [alpha, staging] # temporary disable [cloud]
+        use_azure_chat: [true, false]
+
+    name: "${{ matrix.testcase }} / ${{ matrix.environment }} / ${{ matrix.use_azure_chat && 'UiPathAzureChatOpenAI' || 'UiPathChat' }}"
+
+    steps:
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: uipath-wheels
+          path: wheels
+
+      - name: Checkout uipath-langchain-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-langchain-python'
+          path: 'uipath-langchain-python'
+
+      - name: Checkout uipath-python scripts
+        uses: actions/checkout@v4
+        with:
+          path: _scripts
+          sparse-checkout: .github/scripts
+
+      - name: Override uipath packages with local wheels
+        shell: bash
+        run: |
+          PYBIN=$(command -v python || command -v python3)
+          "$PYBIN" "$GITHUB_WORKSPACE/_scripts/.github/scripts/write_uv_overrides.py"
+
+      - name: Install dependencies
+        working-directory: uipath-langchain-python
+        run: uv sync
+
+      - name: Run testcase
+        env:
+          CLIENT_ID:      ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_ID || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_ID || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_ID }}
+          CLIENT_SECRET:  ${{ matrix.environment == 'alpha' && secrets.ALPHA_TEST_CLIENT_SECRET || matrix.environment == 'staging' && secrets.STAGING_TEST_CLIENT_SECRET || matrix.environment == 'cloud' && secrets.CLOUD_TEST_CLIENT_SECRET }}
+          BASE_URL:       ${{ matrix.environment == 'alpha' && secrets.ALPHA_BASE_URL || matrix.environment == 'staging' && secrets.STAGING_BASE_URL || matrix.environment == 'cloud' && secrets.CLOUD_BASE_URL }}
+          USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}
+          UV_PYTHON: "3.12"
+        working-directory: uipath-langchain-python/testcases/${{ matrix.testcase }}
+        run: |
+          echo "Running testcase: ${{ matrix.testcase }}"
+          echo "Environment: ${{ matrix.environment }}"
+          echo "LLM: ${{ matrix.use_azure_chat && 'UiPathAzureChatOpenAI' || 'UiPathChat' }}"
+          echo "USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}"
+
+          # Execute the testcase run script directly
+          bash run.sh
+          bash ../common/validate_output.sh
+
+  notify-on-failure:
+    needs: [test-uipath-langchain, run-uipath-langchain-integration-tests]
+    if: always() && contains(github.event.pull_request.labels.*.name, 'test:uipath-langchain') && (needs.test-uipath-langchain.result == 'failure' || needs.run-uipath-langchain-integration-tests.result == 'failure')
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Comment on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const marker = '<!-- cross-test-failure:uipath-langchain -->';
+            const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
+            const body = [
+              marker,
+              '## :rotating_light: **Heads up: `uipath-langchain` cross-tests are FAILING** :rotating_light:',
+              '',
+              'Your changes may break the **[`uipath-langchain-python`](https://github.com/UiPath/uipath-langchain-python)** integration.',
+              '',
+              '> :warning: **These checks are NOT enforced by branch protection rules.** Please review the failures before merging.',
+              '',
+              `**:mag: [Inspect the failed run →](${runUrl})**`,
+            ].join('\n');
+
+            // Delete any prior failure comments for this workflow so the new
+            // one always lands at the bottom of the PR conversation.
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+            for (const c of comments) {
+              if (c.body && c.body.includes(marker)) {
+                await github.rest.issues.deleteComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  comment_id: c.id,
+                });
+              }
+            }
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              body,
+            });
diff --git a/.github/workflows/test-uipath-runtime.yml b/.github/workflows/test-uipath-runtime.yml
new file mode 100644
index 000000000..200a1b8ca
--- /dev/null
+++ b/.github/workflows/test-uipath-runtime.yml
@@ -0,0 +1,83 @@
+name: uipath-core - Test Runtime
+
+on:
+  pull_request:
+    types: [ opened, synchronize, reopened, labeled ]
+
+jobs:
+  build-wheels:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    if: contains(github.event.pull_request.labels.*.name, 'test:uipath-runtime')
+    steps:
+      - name: Checkout uipath-python
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build uipath-core package
+        working-directory: packages/uipath-core
+        run: uv build
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: uipath-core-wheel
+          path: packages/uipath-core/dist/*.whl
+
+  test-uipath-runtime:
+    needs: [build-wheels]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        python-version: [ "3.11", "3.12", "3.13" ]
+        os: [ ubuntu-latest, windows-latest ]
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Download wheels
+        uses: actions/download-artifact@v4
+        with:
+          name: uipath-core-wheel
+          path: wheels
+
+      - name: Checkout uipath-runtime-python
+        uses: actions/checkout@v4
+        with:
+          repository: 'UiPath/uipath-runtime-python'
+          path: 'uipath-runtime-python'
+
+      - name: Checkout uipath-python scripts
+        uses: actions/checkout@v4
+        with:
+          path: _scripts
+          sparse-checkout: .github/scripts
+
+      - name: Override uipath packages with local wheels
+        shell: bash
+        run: |
+          PYBIN=$(command -v python || command -v python3)
+          "$PYBIN" "$GITHUB_WORKSPACE/_scripts/.github/scripts/write_uv_overrides.py"
+
+      - name: Run uipath-runtime tests
+        working-directory: uipath-runtime-python
+        run: |
+          uv sync --all-extras
+          uv run pytest
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
deleted file mode 100644
index 5c2881e08..000000000
--- a/.github/workflows/test.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-name: Test
-
-on:
-  workflow_call
-
-jobs:
-  test:
-    name: Test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
-        os: [ubuntu-latest, windows-latest]
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup uv
-        uses: astral-sh/setup-uv@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version-file: ".python-version"
-
-      - name: Install dependencies
-        run: uv sync --all-extras
-
-      - name: Run tests
-        run: uv run pytest
-
-    continue-on-error: true
-
diff --git a/.gitignore b/.gitignore
index 4862eb6e5..6b24bbd06 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,7 +16,6 @@ wheels/
 **/uipath.db
 **/.uipath
 **/**.nupkg
-**/uipath.json
 **/__uipath/
 
 **/playground.py
@@ -28,4 +27,19 @@ wheels/
 **/docs/llamaindex/*
 
 .cache/*
-.cache
\ No newline at end of file
+.cache
+site
+
+
+.claude/*
+firebase-debug.log
+
+samples/**/AGENTS.md
+samples/**/CLAUDE.md
+samples/**/.claude/
+samples/**/.agent/
+samples/**/.vscode/
+samples/**/entry-points.json
+samples/**/uv.lock
+
+testcases/**/uv.lock
diff --git a/.pipelines/security-scans.yml b/.pipelines/security-scans.yml
new file mode 100644
index 000000000..9d80a7493
--- /dev/null
+++ b/.pipelines/security-scans.yml
@@ -0,0 +1,53 @@
+trigger: none
+pr: none
+
+schedules:
+  - cron: "0 11 * * 1"
+    displayName: "Every Monday at 1:00 PM"
+    branches:
+      include:
+        - main
+    always: true
+
+resources:
+  repositories:
+    - repository: codeql
+      type: github
+      name: UiPath/AzurePipelinesTemplates
+      ref: refs/tags/uipath.security.codeql.1.9.5
+      endpoint: UiPath
+    - repository: fossa
+      type: github
+      name: UiPath/AzurePipelinesTemplates
+      ref: refs/tags/uipath.security.fossa.3.0.17
+      endpoint: UiPath
+
+variables:
+  - template: ./variables.yml
+
+stages:
+  - stage: FOSSA
+    dependsOn: []
+    jobs:
+      - job: FOSSA
+        steps:
+          - template: Security/fossa.steps.yml@fossa
+            parameters:
+              OS: linux
+              azureSubscription: $(azureInternalProductionEaConnectionName)
+              FOSSAFlags: '--project "UiPath Python SDK" --branch "$(Build.SourceBranch)" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              FOSSATestFlags: '--project "UiPath Python SDK" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              ${{ if contains(variables['Build.SourceBranch'], 'main') }}:
+                publishSecurityReports: true
+
+
+  - stage: CODEQL
+    dependsOn: []
+    jobs:
+      - job: CODEQL
+        steps:
+          - template: Security/codeql.interpreted.steps.yml@codeql
+            parameters:
+              os: 'linux64'
+              language: 'python'
+              azureSubscription: $(azureInternalProductionEaConnectionName)
diff --git a/.pipelines/variables.yml b/.pipelines/variables.yml
new file mode 100644
index 000000000..203be10e1
--- /dev/null
+++ b/.pipelines/variables.yml
@@ -0,0 +1,2 @@
+variables:
+  azureInternalProductionEaConnectionName: Internal-Production-EA
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 7043ff86a..d584e5017 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.9.6
+  rev: v0.15.0
   hooks:
     - id: ruff
       args: [ --fix ]
diff --git a/.python-version b/.python-version
deleted file mode 100644
index c8cfe3959..000000000
--- a/.python-version
+++ /dev/null
@@ -1 +0,0 @@
-3.10
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 24a9e3428..3f92b0d4f 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -24,5 +24,6 @@
     "tests"
   ],
   "python.testing.unittestEnabled": false,
-  "python.testing.pytestEnabled": true
+  "python.testing.pytestEnabled": true,
+  "python-envs.pythonProjects": []
 }
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..365bc7d39
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository Overview
+
+This is the **UiPath Python SDK** monorepo — a Python SDK and CLI for programmatic interaction with the UiPath Cloud Platform. It publishes three packages to PyPI: `uipath`, `uipath-core`, and `uipath-platform`.
+
+## Monorepo Structure
+
+The repo contains three packages under `packages/`, each with its own `pyproject.toml`, `src/`, and `tests/`:
+
+- **`packages/uipath`** — The main SDK package. Contains the CLI (`uipath` command), agent framework, evaluation framework, tracing/telemetry, and function utilities. This is what users `uv pip install uipath`. Entry point: `src/uipath/_cli:cli`.
+- **`packages/uipath-core`** — Core abstractions shared across packages: tracing, serialization, events, feature flags, error types, chat models, guardrails. Depends on OpenTelemetry and Pydantic.
+- **`packages/uipath-platform`** — HTTP client layer for UiPath Platform APIs. Contains service classes for orchestrator resources (assets, buckets, jobs, processes, queues), action center, context grounding, documents, connections, chat, and guardrails. Depends on `uipath-core`, httpx, and tenacity.
+
+Dependency chain: `uipath` → `uipath-platform` → `uipath-core`. Local editable links are configured via `[tool.uv.sources]`.
+
+## Build & Development Commands
+
+All packages use **uv** for dependency management and **hatch** as the build backend.
+
+```bash
+# Install dependencies (run from each package directory)
+cd packages/uipath && uv sync --all-extras
+
+# The main package has a justfile (run from packages/uipath/):
+just lint        # ruff check + custom httpx linter
+just format      # ruff format --check
+just validate    # lint + format
+just build       # validate + update-agents-md + uv build
+just install     # uv sync --all-extras
+```
+
+### Linting & Formatting
+
+```bash
+# From any package directory:
+ruff check .          # Lint (rules: E, F, B, I, D; Google-style docstrings)
+ruff format --check . # Format check
+ruff check --fix .    # Auto-fix lint issues
+ruff format .         # Auto-format
+
+# Custom linter (packages/uipath only):
+python scripts/lint_httpx_client.py
+```
+
+Ruff config: line-length 88, double quotes, space indent. Docstring rules (D) are disabled for tests. Line length (E501) is ignored globally.
+
+### Type Checking
+
+```bash
+# From any package directory:
+mypy src tests
+```
+
+Uses pydantic mypy plugin. Configured in each package's `pyproject.toml`.
+
+### Running Tests
+
+```bash
+# From any package directory:
+pytest                           # Run all tests
+pytest tests/cli/                # Run a test subdirectory
+pytest tests/cli/test_pack.py    # Run a specific file
+pytest tests/cli/test_pack.py::test_name  # Run a single test
+pytest -x                        # Stop on first failure
+```
+
+All packages use pytest with pytest-asyncio (auto mode), pytest-httpx for HTTP mocking, pytest-cov for coverage. Tests are in `tests/` within each package.
+
+### Pre-commit
+
+The repo has a `.pre-commit-config.yaml` with ruff hooks (check + format).
+
+## Key Architecture Details
+
+### Platform Services Pattern (uipath-platform)
+
+Each orchestrator resource follows a two-file pattern in `packages/uipath-platform/src/uipath/platform/orchestrator/`:
+- `_<resource>_service.py` — Internal service class with HTTP client logic (httpx calls, URL construction, error handling)
+- `<resource>.py` — Public-facing wrapper that delegates to the service class
+
+Service method naming convention:
+- `retrieve` — get a single resource by key
+- `retrieve_by_[field]` — get a resource by an alternate field
+- `list` — get multiple resources
+
+### CLI Architecture (packages/uipath)
+
+The CLI uses **click** and is organized as `cli_<command>.py` files in `src/uipath/_cli/`. Heavy imports are deferred (lazy-loaded) to keep startup fast — do not add top-level imports to `_cli/__init__.py`.
+
+### Agent Framework
+
+`src/uipath/agent/` contains the agent runtime. Agents use Pydantic models for Input/Output schemas.
+
+### Evaluation Framework
+
+`src/uipath/eval/` provides evaluators (ExactMatch, Contains, JsonSimilarity, LLMJudge, Trajectory, ToolCall, Classification) for testing agent quality.
+
+## Code Conventions
+
+- Python 3.11+ required
+- Always add type annotations to functions and classes
+- Use Google-style docstrings for public APIs
+- Use `httpx` for HTTP requests (never `requests`)
+- Use `pydantic` for data models
+- Tests use pytest only (no unittest module); pytest-asyncio auto mode means async tests don't need `@pytest.mark.asyncio`
diff --git a/README.md b/README.md
index 51e9702b3..d90c937fc 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ A Python SDK that enables programmatic interaction with UiPath Cloud Platform se
 
 Use the [UiPath LangChain SDK](https://github.com/UiPath/uipath-langchain-python) to pack and publish LangGraph Agents.
 
-Use the [UiPath LlamaIndex SDK](https://github.com/UiPath/uipath-llamaindex-python) to pack and publish LlamaIndex Agents.
+Check out other [UiPath Integrations](https://github.com/UiPath/uipath-integrations-python) to pack and publish agents built with LlamaIndex, OpenAI Agents, Google ADK, and more.
 
 This [quickstart guide](https://uipath.github.io/uipath-python/) walks you through deploying your first agent to UiPath Cloud Platform.
 
@@ -58,7 +58,7 @@ UIPATH_ACCESS_TOKEN=YOUR_TOKEN_HERE
 ## Basic Usage
 
 ```python
-from uipath import UiPath
+from uipath.platform import UiPath
 # Initialize the SDK
 sdk = UiPath()
 # Execute a process
@@ -88,7 +88,7 @@ The SDK provides access to various UiPath services:
 
 -   `sdk.queues` - Work with transaction queues
 
--   `sdk.actions` - Work with Action Center
+-   `sdk.tasks` - Work with Action Center
 
 -   `sdk.api_client` - Direct access to the API client for custom requests
 
@@ -131,10 +131,21 @@ This command opens a browser for authentication and creates/updates your `.env`
 ### Initialize a Project
 
 ```bash
-uipath init [ENTRYPOINT]
+uipath init
 ```
 
-Creates a `uipath.json` configuration file for your project. If the entrypoint is not provided, it will try to find a single Python file in the current directory.
+The `uipath.json` file should include your entry points in the `functions` section:
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+Running `uipath init` will process these function definitions and create the corresponding `entry-points.json` file needed for deployment.
+
+For more details on the configuration format, see the [UiPath configuration specifications](specs/README.md).
 
 ### Debug a Project
 
@@ -177,11 +188,19 @@ Publishes the most recently created package to your UiPath Orchestrator.
 To properly use the CLI for packaging and publishing, your project should include:
 
 -   A `pyproject.toml` file with project metadata
--   A `uipath.json` file (generated by `uipath init`)
+-   A `uipath.json` file with your function definitions (e.g., `"functions": {"main": "main.py:main"}`)
+-   A `entry-points.json` file (generated by `uipath init`)
+-   A `bindings.json` file (generated by `uipath init`) to configure resource overrides
 -   Any Python files needed for your automation
 
+
 ## Development
 
-### Setting Up a Development Environment
+### Tools
+
+Check out [uipath-dev](https://github.com/uipath/uipath-dev-python) - an interactive application for building, testing, and debugging UiPath Python runtimes, agents, and automation scripts.
+
+### Contributions
+
+Please read our [contribution guidelines](https://github.com/UiPath/uipath-integrations-python/blob/main/CONTRIBUTING.md) before submitting a pull request.
 
-Please read [CONTRIBUTING.md](https://github.com/UiPath/uipath-python/blob/main/CONTRIBUTING.md) before submitting a pull request.
diff --git a/SETUP.MD b/SETUP.MD
new file mode 100644
index 000000000..4e728471b
--- /dev/null
+++ b/SETUP.MD
@@ -0,0 +1,133 @@
+# SETUP.MD
+
+This file documents how to provision a clean development environment for the three packages in this repo (`uipath-core`, `uipath-platform`, `uipath`), run the build, execute the tests, and validate a sample code change end-to-end. It is intended both as a quick reference for human contributors and as a structured guide for automated environment-setup tooling.
+
+## Prerequisites
+
+- Python 3.11+
+- [uv](https://docs.astral.sh/uv/) 0.5+
+
+### Supported platforms
+
+`uv` is shell- and OS-agnostic, so the commands below run unchanged on every supported platform:
+
+- [x] Linux
+- [x] Windows
+- [x] macOS
+
+## Environment Variables
+
+None required for environment setup, build, or unit tests. The suites under the `Test` section run fully offline and require no external authentication.
+
+> **All commands below must be run from the repository root.** The `uv --directory packages/<name>` invocations resolve each subpackage relative to the current working directory. The first line of `## Setup` enforces this by `cd`-ing to the git root.
+
+## Setup
+
+```bash
+cd "$(git rev-parse --show-toplevel)"
+python3 -m pip install --upgrade uv
+
+# Sync all three packages (dependency order: core → platform → main)
+uv --directory packages/uipath-core sync --all-extras
+uv --directory packages/uipath-platform sync --all-extras
+uv --directory packages/uipath sync --all-extras
+```
+
+## Verify Setup
+
+```bash
+uv --version
+uv --directory packages/uipath-core run python --version
+uv --directory packages/uipath-core run python -c "import uipath.core; print('uipath-core ok')"
+uv --directory packages/uipath-platform run python -c "import uipath.platform; print('uipath-platform ok')"
+uv --directory packages/uipath run python -c "import uipath; print('uipath ok')"
+```
+
+## Build
+
+N/A
+
+## Test
+
+```bash
+uv --directory packages/uipath-core run pytest
+uv --directory packages/uipath-platform run pytest
+uv --directory packages/uipath run pytest
+```
+
+> Note: `uipath-platform`'s `pyproject.toml` already excludes its E2E tests via `addopts = "... -m 'not e2e'"`. `uipath-core` and `uipath` do not register an `e2e` marker.
+
+## Sample Code Change
+
+### The change
+
+Add a new `size` property to `SpanRegistry` in `packages/uipath-core/src/uipath/core/tracing/span_utils.py`, immediately after the `clear` method and before the `# Global span registry instance` comment:
+
+```python
+@property
+def size(self) -> int:
+    """Return the number of currently registered spans."""
+    return len(self._spans)
+```
+
+Then create `packages/uipath-core/tests/tracing/test_span_registry_size.py` with two pytest tests:
+
+```python
+from unittest.mock import MagicMock
+
+from uipath.core.tracing.span_utils import SpanRegistry
+
+
+def _make_span(span_id: int) -> MagicMock:
+    span = MagicMock()
+    span.get_span_context.return_value.span_id = span_id
+    span.parent = None  # registered as a root span (no parent)
+    return span
+
+
+def test_size_empty_registry() -> None:
+    registry = SpanRegistry()
+    assert registry.size == 0
+
+
+def test_size_after_registrations() -> None:
+    registry = SpanRegistry()
+    registry.register_span(_make_span(1))
+    registry.register_span(_make_span(2))
+    assert registry.size == 2
+```
+
+### Verification
+
+```bash
+uv --directory packages/uipath-core run pytest tests/tracing/test_span_registry_size.py -v
+```
+
+## Test with a real UiPath Coded Agent
+
+> This section is for human contributors who want to validate changes end-to-end against the real cloud platform. It is **not executed by the Agentic Inner Loop validation pipeline** — that pipeline only runs the sections above (Setup → Verify → Build → Test → Sample Code Change).
+
+The unit tests above are necessary but not sufficient — they don't exercise the package end-to-end through a real agent. The flow below validates changes against a live runtime:
+
+1. Apply the code changes locally.
+2. Run the unit tests (see the `Sample Code Change` section above).
+3. Scaffold a coded UiPath agent that exercises the changed code path.
+4. In the downstream project's `pyproject.toml`, add this local library as an editable dependency (substitute `uipath`, `uipath-platform`, or `uipath-core` depending on which package you changed):
+
+   ```toml
+   [tool.uv.sources]
+   uipath = { path = "../path/to/uipath-python/packages/uipath", editable = true }
+   ```
+
+5. Exercise the new behavior end-to-end:
+
+   ```bash
+   uv run uipath run <agent-name> --input '{...}'
+   ```
+
+6. (Optional) Open a PR and apply the `build:dev` label — this publishes the development version to Test PyPI.
+7. The PR description is updated automatically with instructions for pointing the downstream agent at the Test PyPI dev version.
+8. Validate the new behavior against the real platform — use either or both of the deploy targets below (Studio Web and Orchestrator are not mutually exclusive):
+   - **Studio Web**: export the `UIPATH_PROJECT_ID` environment variable pointing to an existing Coded Agent project in your solution, then run [`uipath push`](https://uipath.github.io/uipath-python/cli/#push) to push the dev version to that project. Open it in Studio Web and exercise the changed code path.
+   - **Orchestrator**: run [`uipath deploy`](https://uipath.github.io/uipath-python/cli/#deploy) to deploy the dev version as a package, then start a job in Orchestrator and exercise the changed code path.
+9. Once validation is done, close the dev PR — these PRs are not meant to be merged; their only purpose was to publish a Test PyPI build for end-to-end validation.
diff --git a/docs/assets/favicon.png b/docs/assets/favicon.png
deleted file mode 100644
index 99f7129b1..000000000
Binary files a/docs/assets/favicon.png and /dev/null differ
diff --git a/docs/cli/index.md b/docs/cli/index.md
deleted file mode 100644
index 04b4e8d3d..000000000
--- a/docs/cli/index.md
+++ /dev/null
@@ -1,223 +0,0 @@
-# CLI Reference
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: auth
-    :depth: 1
-    :style: table
-
-<!-- termynal -->
-
-```shell
-> uipath auth
-⠋ Authenticating with UiPath ...
-🔗 If a browser window did not open, please open the following URL in your browser: [LINK]
-👇 Select tenant:
-  0: Tenant1
-  1: Tenant2
-Select tenant number: 0
-Selected tenant: Tenant1
-✓  Authentication successful.
-```
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: init
-    :depth: 1
-    :style: table
-
-Package requirements (bindings) are dependencies that are required by the automation package for successful execution.
-
-For more information about package requirements, see  [the official documentation](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/managing-package-requirements)
-
-/// warning
-
-The `uipath init` command executes your `main.py` file to analyze its structure and collect information about inputs and outputs.
-///
-
-<!-- termynal -->
-```shell
-> uipath init
-⠋ Initializing UiPath project ...
-✓  Created 'uipath.json' file.
-```
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: run
-    :depth: 1
-    :style: table
-
-/// tip
-For step-by-step debugging with breakpoints and variable inspection (supported from `2.0.66` onward):
-```console
-# Install debugpy package
-[uv] pip install debugpy
-# Run agent with debugging enabled
-uipath run [ENTRYPOINT] [INPUT] --debug
-```
-For vscode:
-1. add the [debug configuration](https://github.com/UiPath/uipath-python/blob/main/.vscode/launch.json) in your `.vscode/launch.json` file.
-2. Place breakpoints in your code where needed.
-3. Use the shortcut `F5`, or navigate to Run -> Start Debugging -> Python Debugger: Attach.
-
-Upon starting the debugging process, one should see the following logs in terminal:
-```console
-🐛 Debug server started on port 5678
-📌 Waiting for debugger to attach...
-  - VS Code: Run -> Start Debugging -> Python Debugger: Attach
-✓  Debugger attached successfully!
-```
-///
-
-/// warning
-Depending on the shell you are using, it may be necessary to escape the input json:
-
-/// tab | Bash/ZSH
-```console
-uipath run agent '{"topic": "UiPath"}'
-```
-///
-
-/// tab | Windows CMD
-```console
-uipath run agent "{""topic"": ""UiPath""}"
-```
-///
-
-/// tab | Windows PowerShell
-```console
-uipath run agent '{\"topic\":\"uipath\"}'
-```
-///
-
-///
-
-<!-- termynal -->
-
-```shell
-> uipath run main.py '{"message": "test"}'
-[2025-04-11 10:13:58,857][INFO] {'message': 'test'}
-```
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: pack
-    :depth: 1
-    :style: table
-
-Packages your project into a `.nupkg` file that can be deployed to UiPath.
-
-/// info
-### Default Files Included in `.nupkg`
-
-By default, the following file types are included in the `.nupkg` file:
-
-- `.py`
-- `.mermaid`
-- `.json`
-- `.yaml`
-- `.yml`
-
----
-
-### Including Extra Files
-
-To include additional files, update the `uipath.json` file by adding a `settings` section. Use the following configuration format:
-
-```json
-{
-    "settings": {
-        "filesIncluded": [
-            "<file here>"
-        ],
-        "fileExtensionsIncluded": [
-            "<new file extension to include (e.g., 'go')>"
-        ]
-    }
-}
-```
-
-///
-
-/// warning
-Your `pyproject.toml` must include:
-
--   A description field (avoid characters: &, <, >, ", ', ;)
--   Author information
-
-Example:
-
-```toml
-description = "Your package description"
-authors = [{name = "Your Name", email = "your.email@example.com"}]
-```
-///
-
-<!-- termynal -->
-```shell
-> uipath pack
-⠋ Packaging project ...
-Name       : test
-Version    : 0.1.0
-Description: Add your description here
-Authors    : Your Name
-✓  Project successfully packaged.
-```
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: publish
-    :depth: 1
-    :style: table
-
-/// warning
-To properly use the CLI for packaging and publishing, your project should include:
-
--   A `pyproject.toml` file with project metadata
--   A `uipath.json` file (generated by `uipath init`)
--   Any Python files needed for your automation
-///
-
-<!-- termynal -->
-
-```shell
-> uipath publish
-⠋ Fetching available package feeds...
-👇 Select package feed:
-  0: Orchestrator Tenant Processes Feed
-  1: Orchestrator Personal Workspace Feed
-Select feed number: 0
-Selected feed: Orchestrator Tenant Processes Feed
-⠸ Publishing most recent package: test.0.1.0.nupkg ...
-✓  Package published successfully!
-```
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: deploy
-    :depth: 1
-    :style: table
-
----
-
-::: mkdocs-click
-    :module: uipath._cli
-    :command: invoke
-    :depth: 1
-    :style: table
-
-<!-- termynal -->
-
-```shell
-> uipath invoke agent '{"topic": "UiPath"}'
-⠴ Loading configuration ...
-⠴ Starting job ...
-✨ Job started successfully!
-🔗 Monitor your job here: [LINK]
-```
diff --git a/docs/core/actions.md b/docs/core/actions.md
deleted file mode 100644
index 71cb20fba..000000000
--- a/docs/core/actions.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.actions_service
\ No newline at end of file
diff --git a/docs/core/assets.md b/docs/core/assets.md
deleted file mode 100644
index d7a1bd10e..000000000
--- a/docs/core/assets.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.assets_service
\ No newline at end of file
diff --git a/docs/core/attachments.md b/docs/core/attachments.md
deleted file mode 100644
index 2c2b92036..000000000
--- a/docs/core/attachments.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.attachments_service
\ No newline at end of file
diff --git a/docs/core/buckets.md b/docs/core/buckets.md
deleted file mode 100644
index ab1fe0515..000000000
--- a/docs/core/buckets.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.buckets_service
\ No newline at end of file
diff --git a/docs/core/connections.md b/docs/core/connections.md
deleted file mode 100644
index 6324d6f28..000000000
--- a/docs/core/connections.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.connections_service
\ No newline at end of file
diff --git a/docs/core/context_grounding.md b/docs/core/context_grounding.md
deleted file mode 100644
index 1dba318d0..000000000
--- a/docs/core/context_grounding.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.context_grounding_service
\ No newline at end of file
diff --git a/docs/core/jobs.md b/docs/core/jobs.md
deleted file mode 100644
index e537aa163..000000000
--- a/docs/core/jobs.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.jobs_service
\ No newline at end of file
diff --git a/docs/core/llm_gateway.md b/docs/core/llm_gateway.md
deleted file mode 100644
index 91f273b37..000000000
--- a/docs/core/llm_gateway.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.llm_gateway_service
diff --git a/docs/core/processes.md b/docs/core/processes.md
deleted file mode 100644
index 54287b02f..000000000
--- a/docs/core/processes.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.processes_service
\ No newline at end of file
diff --git a/docs/core/queues.md b/docs/core/queues.md
deleted file mode 100644
index 3d669eea9..000000000
--- a/docs/core/queues.md
+++ /dev/null
@@ -1 +0,0 @@
-::: uipath._services.queues_service
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
deleted file mode 100644
index 558afb9d9..000000000
--- a/docs/index.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Getting Started
----
-
-<div class="grid cards" markdown>
--   __UiPath SDK__
-
-    ---
-
-    Code with full UiPath context to build custom automations and agents from the ground up.
-
-    [Start Building](./core/getting_started.md)
-
-</div>
-
-<div class="grid cards" markdown>
--   __UiPath MCP SDK__
-
-    ---
-
-    Build and host Coded MCP Servers within UiPath.
-
-    [Start Building](./mcp/quick_start.md)
-
-</div>
-
-<h2> Extensions </h2>
-<div class="grid cards" markdown>
--   __UiPath Langchain SDK__
-
-    ---
-
-    Build enterprise-grade UiPath agents using the LangChain framework, with seamless integration from build to run.
-
-    [Get Started](./langchain/quick_start.md)
-
--   __UiPath LlamaIndex SDK__
-
-    ---
-
-    Build enterprise-grade UiPath agents using the LlamaIndex framework, with seamless integration from build to run.
-
-    [Get Started](./llamaindex/quick_start.md)
-
-</div>
diff --git a/packages/uipath-core/.python-version b/packages/uipath-core/.python-version
new file mode 100644
index 000000000..2c0733315
--- /dev/null
+++ b/packages/uipath-core/.python-version
@@ -0,0 +1 @@
+3.11
diff --git a/packages/uipath-core/CLAUDE.md b/packages/uipath-core/CLAUDE.md
new file mode 100644
index 000000000..5b683f275
--- /dev/null
+++ b/packages/uipath-core/CLAUDE.md
@@ -0,0 +1,60 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the `uipath-core` package.
+
+## Package Purpose
+
+Core abstractions shared across the UiPath Python SDK. This is the lowest-level package — it has no dependency on `uipath` or `uipath-platform`. Depends on OpenTelemetry and Pydantic.
+
+## Development Commands
+
+```bash
+cd packages/uipath-core
+
+uv sync --all-extras          # Install dependencies
+pytest                        # Run all tests
+pytest tests/tracing/         # Run a test subdirectory
+pytest tests/tracing/test_traced.py::test_name  # Single test
+ruff check .                  # Lint
+ruff format --check .         # Format check
+mypy src tests                # Type check
+```
+
+No justfile exists for this package — run commands directly.
+
+## Modules
+
+### `chat/` — Conversation Protocol Models
+Pydantic models for a hierarchical conversation event protocol (sessions, exchanges, messages, tool calls, citations, interrupts, content parts, async streams). ~45 exported classes. This defines the wire format between UI clients and agents/LLMs.
+
+### `tracing/` — OpenTelemetry Instrumentation
+- `@traced` decorator — instruments sync/async functions with OpenTelemetry spans. Supports `recording=False` for non-recording spans, custom `input_processor`/`output_processor`, and span context propagation.
+- `UiPathTraceManager` — central management of tracer providers, span processors, and exporters.
+- `UiPathSpanUtils` — span registry and utilities.
+- `UiPathTraceSettings` — settings with optional `span_filter` callable.
+
+### `guardrails/` — Deterministic Validation Rules
+Rule engine for validating input/output data with `WordRule`, `NumberRule`, `BooleanRule`, `UniversalRule`. `DeterministicGuardrailsService` evaluates rules pre- and post-execution (skipping output-dependent rules during pre-execution).
+
+### `serialization/` — JSON Serialization
+`serialize_json()`, `serialize_object()`, `serialize_defaults()` — handles Pydantic v1/v2, dataclasses, enums, datetime, namedtuples, sets.
+
+### `events/` — Event Bus
+`EventBus` — simple async pub/sub with `subscribe()`, `unsubscribe()`, `publish()`.
+
+### `feature_flags/` — Feature Flag Registry
+`FeatureFlags` singleton. Sources: programmatic config (takes precedence) + `UIPATH_FEATURE_*` env vars. Supports structured types via JSON parsing.
+
+### `errors/` — Exception Types
+`UiPathFaultedTriggerError`, `UiPathPendingTriggerError`, `ErrorCategory` enum (DEPLOYMENT, SYSTEM, UNKNOWN, USER).
+
+### `triggers/` — Resume Trigger Models
+`UiPathResumeTrigger`, `UiPathApiTrigger`, and trigger type/name enums. Pydantic models with camelCase aliases.
+
+## Test Structure
+
+Tests mirror the module structure under `tests/`. The `tracing/` subdirectory has the most tests (8 files covering decorator behavior, span nesting, registry, filtering, serialization, external integration).
+
+### Key Test Fixture
+
+`conftest.py` provides a session-scoped `span_capture` fixture using `InMemorySpanExporter`. An autouse fixture `clear_spans_between_tests` resets it before each test. Use `span_capture.get_spans()` to assert on traced function behavior.
diff --git a/packages/uipath-core/CONTRIBUTING.md b/packages/uipath-core/CONTRIBUTING.md
new file mode 100644
index 000000000..ea263320d
--- /dev/null
+++ b/packages/uipath-core/CONTRIBUTING.md
@@ -0,0 +1,68 @@
+# Contributing to UiPath Runtime SDK
+
+## Local Development Setup
+
+### Prerequisites
+
+1. **Install Python ≥ 3.11**:
+    - Download and install Python 3.11 from the official [Python website](https://www.python.org/downloads/)
+    - Verify the installation by running:
+        ```sh
+        python3.11 --version
+        ```
+
+    Alternative: [mise](https://mise.jdx.dev/lang/python.html)
+
+2. **Install [uv](https://docs.astral.sh/uv/)**:
+    Follow the official installation instructions for your operating system.
+
+3. **Create a virtual environment in the current working directory**:
+    ```sh
+    uv venv
+    ```
+
+4. **Activate the virtual environment**:
+    - Linux/Mac
+    ```sh
+    source .venv/bin/activate
+    ```
+    - Windows Powershell
+    ```sh
+    .venv\Scripts\Activate.ps1
+    ```
+    - Windows Bash
+    ```sh
+    source .venv/Scripts/activate
+    ```
+
+5. **Install dependencies**:
+    ```sh
+    uv sync --all-extras --no-cache
+    ```
+
+For additional commands related to linting, formatting, and building, run `just --list`.
+
+### Using the SDK Locally
+
+1. Create a project directory:
+    ```sh
+    mkdir project
+    cd project
+    ```
+
+2. Initialize the Python project:
+    ```sh
+    uv init . --python 3.11
+    ```
+
+3. Set the SDK path:
+    ```sh
+    PATH_TO_SDK=/Users/YOUR_USERNAME/uipath-core-python
+    ```
+
+4. Install the SDK in editable mode:
+    ```sh
+    uv add --editable ${PATH_TO_SDK}
+    ```
+
+> **Note:** Instead of cloning the project into `.venv/lib/python3.11/site-packages/uipath-core`, this mode creates a file named `_uipath-core.pth` inside `.venv/lib/python3.11/site-packages`. This file contains the value of `PATH_TO_SDK`, which is added to `sys.path`—the list of directories where Python searches for packages. To view the entries, run `python -c 'import sys; print(sys.path)'`.
diff --git a/packages/uipath-core/README.md b/packages/uipath-core/README.md
new file mode 100644
index 000000000..69d9d952e
--- /dev/null
+++ b/packages/uipath-core/README.md
@@ -0,0 +1,103 @@
+# UiPath Core
+
+[![PyPI - Version](https://img.shields.io/pypi/v/uipath-core)](https://pypi.org/project/uipath-core/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/uipath-core.svg)](https://pypi.org/project/uipath-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/uipath-core.svg)](https://pypi.org/project/uipath-core/)
+
+Core abstractions and contracts for the UiPath Python SDK.
+
+## Installation
+
+```bash
+pip install uipath-core
+```
+
+## Modules
+
+### Errors
+
+Exception hierarchy for UiPath trigger errors with category-based classification.
+
+- **`ErrorCategory`**: Enum: `DEPLOYMENT`, `SYSTEM`, `UNKNOWN`, `USER`
+- **`UiPathFaultedTriggerError`**: Base trigger error with category and detail
+- **`UiPathPendingTriggerError`**: Pending trigger variant
+
+```python
+from uipath.core.errors import ErrorCategory, UiPathFaultedTriggerError
+```
+
+### Serialization
+
+JSON serialization utilities for complex Python types. Handles Pydantic models (v1 & v2), dataclasses, enums, datetime/timezone objects, sets, tuples, and named tuples.
+
+- **`serialize_json(obj)`**: Serialize any object to a JSON string
+- **`serialize_defaults(obj)`**: Custom `default` handler for `json.dumps()`
+
+```python
+from uipath.core.serialization import serialize_json
+```
+
+### Tracing
+
+OpenTelemetry integration with UiPath execution tracking. Provides function instrumentation, span lifecycle management, custom exporters, and batch/simple span processors with automatic `execution.id` propagation.
+
+- **`@traced`**: Decorator for sync/async function instrumentation. Supports custom span names, run types, input/output processors, and non-recording spans
+- **`UiPathTraceManager`**: Manages `TracerProvider`, span exporters, and processors. Provides `start_execution_span()` context manager and span retrieval by execution ID
+- **`UiPathSpanUtils`**: Span registry and parent context management
+- **`UiPathTraceSettings`**: Configuration model with optional span filtering
+
+```python
+from uipath.core.tracing import traced, UiPathTraceManager
+
+@traced(name="my_operation", run_type="tool")
+def do_work(input: str) -> str:
+    return process(input)
+```
+
+### Guardrails
+
+Deterministic rule-based validation for inputs and outputs. Rules are evaluated pre-execution (input-only) and post-execution (all rules), with flexible field selection using dot-notation paths and array access (`[*]`).
+
+**Rule types:**
+- **`WordRule`**: String pattern matching
+- **`NumberRule`**: Numeric constraint validation
+- **`BooleanRule`**: Boolean assertions
+- **`UniversalRule`**: Always-apply constraints
+
+**Field selection:**
+- **`AllFieldsSelector`**: Apply to all fields of a given source (input/output)
+- **`SpecificFieldsSelector`**: Target specific fields by path
+
+**Service:**
+- **`DeterministicGuardrailsService`**: Evaluates guardrail rules against inputs/outputs, returning `GuardrailValidationResult` with pass/fail status and reason
+
+```python
+from uipath.core.guardrails import DeterministicGuardrailsService, GuardrailValidationResultType
+```
+
+### Chat
+
+Pydantic models for the UiPath conversation event protocol. Defines the streaming event schema between clients and LLM/agent backends.
+
+**Hierarchy:**
+```
+Conversation → Exchange → Message → Content Parts (with Citations)
+                                  → Tool Calls (with Results)
+                                  → Interrupts (human-in-the-loop)
+```
+
+Supports session capabilities negotiation, async input streams (audio/video), tool call confirmation interrupts, URL and media citations, and inline/external value references.
+
+```python
+from uipath.core.chat import UiPathConversationEvent, UiPathSessionStartEvent
+```
+
+## Dependencies
+
+| Package | Version |
+|---|---|
+| `pydantic` | `>=2.12.5, <3` |
+| `opentelemetry-sdk` | `>=1.39.0, <2` |
+| `opentelemetry-instrumentation` | `>=0.60b0, <1` |
+
+
diff --git a/packages/uipath-core/pyproject.toml b/packages/uipath-core/pyproject.toml
new file mode 100644
index 000000000..473d485a3
--- /dev/null
+++ b/packages/uipath-core/pyproject.toml
@@ -0,0 +1,130 @@
+[project]
+name = "uipath-core"
+version = "0.5.22"
+description = "UiPath Core abstractions"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.11"
+dependencies = [
+  "opentelemetry-sdk>=1.39.0, <2.0.0",
+  "opentelemetry-instrumentation>=0.60b0, <1.0.0",
+  "pydantic>=2.12.5, <3.0.0",
+]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Build Tools",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+
+]
+maintainers = [
+  { name = "Marius Cosareanu", email = "marius.cosareanu@uipath.com" },
+  { name = "Cristian Pufu", email = "cristian.pufu@uipath.com" },
+]
+
+[project.urls]
+Homepage = "https://uipath.com"
+Repository = "https://github.com/UiPath/uipath-python"
+Documentation = "https://uipath.github.io/uipath-python/"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+  "bandit>=1.8.2",
+  "mypy>=1.14.1",
+  "ruff>=0.9.4",
+  "rust-just>=1.39.0",
+  "pytest>=7.4.0",
+  "pytest-asyncio>=1.0.0",
+  "pytest-httpx>=0.35.0",
+  "pytest-trio>=0.8.0",
+  "pytest-cov>=4.1.0",
+  "pytest-mock>=3.11.1",
+  "pre-commit>=4.1.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/uipath"]
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+exclude = ["samples/**", "testcases/**"]
+
+[tool.ruff.lint]
+select = ["E", "F", "B", "I", "D"]
+ignore = ["D417"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+ignore-decorators = []
+
+[tool.ruff.lint.per-file-ignores]
+"*" = ["E501"]
+"tests/**" = ["D"]
+"*_test.py" = ["D"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+mypy_path = "src"
+explicit_package_bases = true
+namespace_packages = true
+follow_imports = "silent"
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+check_untyped_defs = true
+no_implicit_reexport = true
+
+disallow_untyped_defs = false
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+addopts = "-ra -q --cov=src --cov-report=term-missing"
+asyncio_default_fixture_loop_scope = "function"
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["src"]
+relative_files = true
+omit = [
+  "*/tests/*",
+  "*/__pycache__/*",
+  "*/site-packages/*",
+  "*/conftest.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+precision = 2
+exclude_lines = [
+  "pragma: no cover",
+  "def __repr__",
+  "raise NotImplementedError",
+  "if TYPE_CHECKING:",
+  "@(abc\\.)?abstractmethod",
+]
+
+[tool.uv]
+exclude-newer = "2 days"
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
diff --git a/packages/uipath-core/src/uipath/core/__init__.py b/packages/uipath-core/src/uipath/core/__init__.py
new file mode 100644
index 000000000..fd87f2efc
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/__init__.py
@@ -0,0 +1,11 @@
+"""UiPath Core Package."""
+
+from uipath.core.tracing.decorators import traced
+from uipath.core.tracing.span_utils import UiPathSpanUtils
+from uipath.core.tracing.trace_manager import UiPathTraceManager
+
+__all__ = [
+    "traced",
+    "UiPathSpanUtils",
+    "UiPathTraceManager",
+]
diff --git a/packages/uipath-core/src/uipath/core/adapters/__init__.py b/packages/uipath-core/src/uipath/core/adapters/__init__.py
new file mode 100644
index 000000000..5906b1b39
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/adapters/__init__.py
@@ -0,0 +1,35 @@
+"""Generic adapter contracts for framework integrations.
+
+This package holds only the abstract contracts — concrete adapter
+implementations live in framework-specific plugin packages (e.g.
+``uipath-langchain``, ``uipath-openai``) that target the framework they
+integrate with. Plugin packages register their concrete adapters with
+the global :class:`AdapterRegistry` via the
+``uipath.governance.adapters`` entry-point group.
+
+Public surface:
+
+- :class:`BaseAdapter` – abstract base every adapter inherits from.
+- :class:`GovernedAgentBase` – proxy base for governed agent wrappers.
+- :class:`EvaluatorProtocol` – structural protocol the adapter expects
+  from any policy evaluator.
+- :class:`AdapterRegistry` – ordered list of adapters that resolves
+  the first match for a given agent.
+"""
+
+from .base import BaseAdapter, GovernedAgentBase
+from .evaluator import EvaluatorProtocol
+from .registry import (
+    AdapterRegistry,
+    get_adapter_registry,
+    reset_adapter_registry,
+)
+
+__all__ = [
+    "BaseAdapter",
+    "GovernedAgentBase",
+    "EvaluatorProtocol",
+    "AdapterRegistry",
+    "get_adapter_registry",
+    "reset_adapter_registry",
+]
diff --git a/packages/uipath-core/src/uipath/core/adapters/base.py b/packages/uipath-core/src/uipath/core/adapters/base.py
new file mode 100644
index 000000000..3afaad6a7
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/adapters/base.py
@@ -0,0 +1,116 @@
+"""Base adapter contracts for framework-specific integrations.
+
+An adapter's job:
+
+1. Detect whether it can handle a given agent object.
+2. Attach hooks to that agent (framework-specific).
+3. Publish events to a policy evaluator when those hooks fire.
+
+The evaluator subscribes to events and runs policy checks; it never
+knows or cares which adapter fired the event.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+from uuid import uuid4
+
+from .evaluator import EvaluatorProtocol
+
+
+class BaseAdapter(ABC):
+    """Base class for framework-specific governance adapters."""
+
+    #: Higher value = more specific = inserted earlier in the registry.
+    #: Plugin authors should set this above ``0`` on adapters that target
+    #: a narrower agent type than another already-registered adapter, so
+    #: the specific one wins ``can_handle`` resolution regardless of the
+    #: order in which plugins happen to be imported. Among adapters with
+    #: the same priority, registration order is preserved (stable).
+    priority: int = 0
+
+    #: Set to True on a catch-all adapter that should always sort last in
+    #: the registry. The registry uses this flag (not the class name or
+    #: :attr:`priority`) to keep the fallback in last position when new
+    #: adapters register.
+    is_fallback: bool = False
+
+    @property
+    def name(self) -> str:
+        """Return adapter name for logging."""
+        return self.__class__.__name__
+
+    @abstractmethod
+    def can_handle(self, agent: Any) -> bool:
+        """Return True if this adapter knows how to hook into this agent type."""
+
+    @abstractmethod
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        """Attach governance hooks to the agent.
+
+        Args:
+            agent: The agent to govern.
+            agent_id: Unique identifier for the agent.
+            session_id: Session identifier for tracing.
+            evaluator: Policy evaluator implementing
+                :class:`EvaluatorProtocol`.
+
+        Returns:
+            A governed proxy (or the original agent with hooks installed).
+        """
+
+    def detach(self, governed: Any) -> Any:
+        """Detach governance and return the original agent.
+
+        Default implementation uses the public :attr:`GovernedAgentBase.unwrapped`
+        contract; non-proxy adapters that return the original agent from
+        :meth:`attach` get back ``governed`` unchanged.
+        """
+        return getattr(governed, "unwrapped", governed)
+
+    def _generate_trace_id(self) -> str:
+        """Generate a trace ID for governance events."""
+        return str(uuid4())
+
+
+class GovernedAgentBase:
+    """Base class for governed agent proxies.
+
+    Provides common functionality for all governed agents:
+
+    - Stores reference to original agent
+    - Forwards unknown attributes to original agent
+    - Tracks governance metadata
+    """
+
+    def __init__(
+        self,
+        agent: Any,
+        adapter: BaseAdapter,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> None:
+        """Initialize with the wrapped agent and governance metadata."""
+        self._agent = agent
+        self._adapter = adapter
+        self._agent_id = agent_id
+        self._session_id = session_id
+        self._evaluator = evaluator
+        self._trace_id = adapter._generate_trace_id()
+
+    @property
+    def unwrapped(self) -> Any:
+        """Get the original unwrapped agent."""
+        return self._agent
+
+    def __getattr__(self, name: str) -> Any:
+        """Forward attribute access to the original agent."""
+        return getattr(self._agent, name)
diff --git a/packages/uipath-core/src/uipath/core/adapters/evaluator.py b/packages/uipath-core/src/uipath/core/adapters/evaluator.py
new file mode 100644
index 000000000..ee5b92dad
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/adapters/evaluator.py
@@ -0,0 +1,99 @@
+"""Structural contract for the policy evaluator an adapter talks to.
+
+Framework adapters call into a policy evaluator at each lifecycle hook.
+Concrete evaluator implementations (the native runtime evaluator, a
+Microsoft AGT bridge, a composite, …) live in packages outside
+``uipath-core`` — adapters depend only on this structural protocol so
+they can be swapped against any of them without code change.
+
+``EvaluatorProtocol`` is a :class:`typing.Protocol` so any class whose
+methods match the signatures below satisfies the contract without
+inheritance.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class EvaluatorProtocol(Protocol):
+    """Structural protocol an adapter expects from a policy evaluator.
+
+    Return types are intentionally :class:`typing.Any`: the concrete
+    audit record shape lives in the plugin package that owns the
+    evaluator and the policy model. Adapters in that package cast the
+    return value back to the concrete type they know.
+    """
+
+    def evaluate_before_agent(
+        self,
+        agent_input: str,
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        model_name: str = "",
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate BEFORE_AGENT rules."""
+        ...
+
+    def evaluate_after_agent(
+        self,
+        agent_output: str,
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate AFTER_AGENT rules."""
+        ...
+
+    def evaluate_before_model(
+        self,
+        model_input: str,
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        messages: list[dict[str, Any]] | None = None,
+        model_name: str = "",
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate BEFORE_MODEL rules."""
+        ...
+
+    def evaluate_after_model(
+        self,
+        model_output: str,
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate AFTER_MODEL rules."""
+        ...
+
+    def evaluate_tool_call(
+        self,
+        tool_name: str,
+        tool_args: dict[str, Any],
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        session_state: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate TOOL_CALL rules."""
+        ...
+
+    def evaluate_after_tool(
+        self,
+        tool_name: str,
+        tool_result: str,
+        agent_name: str,
+        runtime_id: str,
+        trace_id: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluate AFTER_TOOL rules."""
+        ...
diff --git a/packages/uipath-core/src/uipath/core/adapters/registry.py b/packages/uipath-core/src/uipath/core/adapters/registry.py
new file mode 100644
index 000000000..adebe780a
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/adapters/registry.py
@@ -0,0 +1,176 @@
+"""Ordered registry of framework adapters.
+
+The registry is a pure, implementation-agnostic container — it does
+**not** know about any concrete adapter. Plugin packages (e.g.
+``uipath-langchain``) populate it by either:
+
+1. Declaring a ``uipath.governance.adapters`` entry point whose value
+   is a zero-arg callable that calls :meth:`AdapterRegistry.register`.
+   These are auto-discovered on first call to
+   :func:`get_adapter_registry`.
+2. Calling :meth:`AdapterRegistry.register` directly at import time
+   (e.g. side-effect on importing the plugin's governance submodule).
+
+Adapters are checked in priority order (highest first): more specific
+adapters get a higher :attr:`BaseAdapter.priority` so they win
+``can_handle`` resolution over generic ones, regardless of the order in
+which plugin packages happen to be imported. Among adapters with the
+same priority, registration order is preserved. Adapters with
+``is_fallback=True`` sort last when registered without an explicit
+``position`` — passing ``position`` to :meth:`AdapterRegistry.register`
+is an escape hatch that bypasses both priority and fallback ordering,
+so callers using it own the resulting list order.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base import BaseAdapter
+
+logger = logging.getLogger(__name__)
+
+ENTRY_POINT_GROUP = "uipath.governance.adapters"
+
+
+class AdapterRegistry:
+    """Ordered list of adapters; resolves the first match for an agent."""
+
+    def __init__(self) -> None:
+        """Initialize an empty registry."""
+        self._adapters: list[BaseAdapter] = []
+
+    def register(self, adapter: BaseAdapter, position: int | None = None) -> None:
+        """Register an adapter.
+
+        Args:
+            adapter: The adapter to register.
+            position: Explicit insertion index (``0`` = highest priority)
+                that bypasses both priority-based ordering AND fallback
+                semantics — the adapter is inserted blindly at the given
+                index, so callers using ``position`` are responsible for
+                not placing a fallback before a specific adapter (or a
+                specific adapter after an existing fallback). When
+                ``None`` the adapter is inserted by
+                :attr:`BaseAdapter.priority` (higher first, stable on
+                ties) and before any adapter marked
+                :attr:`BaseAdapter.is_fallback`; adapters whose own
+                ``is_fallback`` is set are appended last.
+        """
+        if position is not None:
+            self._adapters.insert(position, adapter)
+        elif adapter.is_fallback:
+            self._adapters.append(adapter)
+        else:
+            insert_at = len(self._adapters)
+            for i, existing in enumerate(self._adapters):
+                if existing.is_fallback or existing.priority < adapter.priority:
+                    insert_at = i
+                    break
+            self._adapters.insert(insert_at, adapter)
+        logger.debug("Registered adapter: %s", adapter.name)
+
+    def resolve(self, agent: Any) -> BaseAdapter | None:
+        """Return the first adapter that can handle ``agent`` (or ``None``)."""
+        for adapter in self._adapters:
+            try:
+                if adapter.can_handle(agent):
+                    logger.debug(
+                        "AdapterRegistry: %s -> %s",
+                        type(agent).__name__,
+                        adapter.name,
+                    )
+                    return adapter
+            except Exception as exc:
+                logger.warning(
+                    "Adapter %s.can_handle() failed: %s",
+                    adapter.name,
+                    exc,
+                )
+                continue
+        return None
+
+    def get_all(self) -> list[BaseAdapter]:
+        """Return a copy of the registered adapters in priority order."""
+        return self._adapters.copy()
+
+    def clear(self) -> None:
+        """Remove all registered adapters."""
+        self._adapters.clear()
+
+
+_registry: AdapterRegistry | None = None
+
+
+def _discover_entry_point_adapters() -> None:
+    """Load every adapter advertised under the ``uipath.governance.adapters`` group.
+
+    Each entry-point value must be a zero-arg callable (typically a
+    ``register_*`` function in the plugin package) that calls
+    :meth:`AdapterRegistry.register`. A failure to load or invoke any
+    one entry point is logged and skipped — a single broken plugin
+    must never block governance startup.
+    """
+    try:
+        from importlib.metadata import entry_points
+    except ImportError:  # pragma: no cover - importlib.metadata is stdlib in py3.11+
+        return
+
+    try:
+        eps = entry_points(group=ENTRY_POINT_GROUP)
+    except Exception as exc:  # noqa: BLE001 - discovery failures must never raise
+        logger.debug("Adapter entry-point discovery failed: %s", exc, exc_info=True)
+        return
+
+    for ep in eps:
+        try:
+            registrar = ep.load()
+        except Exception as exc:  # noqa: BLE001 - one broken plugin must not block others
+            logger.debug(
+                "Failed to load governance adapter entry point '%s' (%s): %s",
+                ep.name,
+                ep.value,
+                exc,
+                exc_info=True,
+            )
+            continue
+        if not callable(registrar):
+            logger.warning(
+                "Governance adapter entry point '%s' is not callable: %r",
+                ep.name,
+                registrar,
+            )
+            continue
+        try:
+            registrar()
+        except Exception as exc:  # noqa: BLE001 - one broken plugin must not block others
+            logger.debug(
+                "Governance adapter '%s' register call failed: %s",
+                ep.name,
+                exc,
+                exc_info=True,
+            )
+
+
+def get_adapter_registry() -> AdapterRegistry:
+    """Return the process-wide adapter registry singleton.
+
+    On first call, discovers and registers every adapter declared under
+    the ``uipath.governance.adapters`` entry-point group, so framework
+    SDKs (``uipath-langchain``, ``uipath-openai``, …) just need to be
+    installed — no explicit import is required.
+    """
+    global _registry
+    if _registry is None:
+        _registry = AdapterRegistry()
+        _discover_entry_point_adapters()
+    return _registry
+
+
+def reset_adapter_registry() -> None:
+    """Drop the singleton registry (intended for tests)."""
+    global _registry
+    if _registry is not None:
+        _registry.clear()
+    _registry = None
diff --git a/packages/uipath-core/src/uipath/core/chat/__init__.py b/packages/uipath-core/src/uipath/core/chat/__init__.py
new file mode 100644
index 000000000..ee4a4c674
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/__init__.py
@@ -0,0 +1,211 @@
+"""UiPath Conversation Models.
+
+This module provides Pydantic models that represent the JSON event schema for conversations between a client (UI) and an LLM/agent.
+
+The event objects define a hierarchical conversation structure:
+
+* Conversation
+    * Exchange
+        * Message
+            * Content Parts
+                * Citations
+            * Tool Calls
+                * Tool Results
+
+ A conversation may contain multiple exchanges, and an exchange may contain multiple messages. A message may contain
+ multiple content parts, each of which can be text or binary, including media input and output streams; and each
+ content part can include multiple citations. A message may also contain multiple tool calls, which may contain a tool
+ result.
+
+ The protocol also supports a top level, "async", input media streams (audio and video), which can span multiple
+ exchanges. These are used for Gemini's automatic turn detection mode, where the LLM determines when the user has
+ stopped talking and starts producing output. The output forms one or more messages in an exchange with no explicit
+ input message. However, the LLM may produce an input transcript which can be used to construct the implicit input
+ message that started the exchange.
+
+ In addition, the protocol also supports "async" tool calls that span multiple exchanges. This can be used with
+ Gemini's asynchronous function calling protocol, which allows function calls to produce results that interrupt the
+ conversation when ready, even after multiple exchanges. They also support generating multiple results from a single
+ tool call. By contrast most tool calls are scoped to a single message, which contains both the call and the single
+ result produced by that call.
+
+ Not all features supported by the protocol will be supported by all clients and LLMs. The optional top level
+ `capabilities` property can be used to communicate information about supported features. This property should be set
+ on the first event written to a new websocket connection. This initial event may or may not contain additional
+ sub-events.
+"""
+
+from .async_stream import (
+    UiPathConversationAsyncInputStreamEndEvent,
+    UiPathConversationAsyncInputStreamEvent,
+    UiPathConversationAsyncInputStreamStartEvent,
+    UiPathConversationInputStreamChunkEvent,
+)
+from .citation import (
+    UiPathConversationCitation,
+    UiPathConversationCitationData,
+    UiPathConversationCitationEndEvent,
+    UiPathConversationCitationEvent,
+    UiPathConversationCitationSource,
+    UiPathConversationCitationSourceBase,
+    UiPathConversationCitationSourceMedia,
+    UiPathConversationCitationSourceUrl,
+    UiPathConversationCitationStartEvent,
+)
+from .content import (
+    InlineOrExternal,
+    UiPathContentPartInterrupted,
+    UiPathConversationContentPart,
+    UiPathConversationContentPartChunkEvent,
+    UiPathConversationContentPartData,
+    UiPathConversationContentPartEndEvent,
+    UiPathConversationContentPartEvent,
+    UiPathConversationContentPartStartEvent,
+    UiPathExternalValue,
+    UiPathInlineValue,
+)
+from .error import (
+    UiPathConversationErrorEndEvent,
+    UiPathConversationErrorEvent,
+    UiPathConversationErrorStartEvent,
+)
+from .event import UiPathConversationEvent, UiPathConversationLabelUpdatedEvent
+from .exchange import (
+    UiPathClientSideToolDeclaration,
+    UiPathConversationExchange,
+    UiPathConversationExchangeData,
+    UiPathConversationExchangeEndEvent,
+    UiPathConversationExchangeEvent,
+    UiPathConversationExchangeStartEvent,
+)
+from .interrupt import (
+    InterruptTypeEnum,
+    UiPathConversationGenericInterruptEndEvent,
+    UiPathConversationGenericInterruptStartEvent,
+    UiPathConversationInterrupt,
+    UiPathConversationInterruptData,
+    UiPathConversationInterruptEndEvent,
+    UiPathConversationInterruptEvent,
+    UiPathConversationInterruptStartEvent,
+    UiPathConversationToolCallConfirmationEndValue,
+    UiPathConversationToolCallConfirmationInterruptEndEvent,
+    UiPathConversationToolCallConfirmationInterruptStartEvent,
+    UiPathConversationToolCallConfirmationValue,
+)
+from .message import (
+    UiPathConversationMessage,
+    UiPathConversationMessageData,
+    UiPathConversationMessageEndEvent,
+    UiPathConversationMessageEvent,
+    UiPathConversationMessageStartEvent,
+)
+from .meta import UiPathConversationMetaEvent
+from .session import (
+    UiPathSessionCapabilities,
+    UiPathSessionEndEvent,
+    UiPathSessionEndingEvent,
+    UiPathSessionStartedEvent,
+    UiPathSessionStartEvent,
+)
+from .tool import (
+    UiPathConversationExecutingToolCallEvent,
+    UiPathConversationToolCall,
+    UiPathConversationToolCallConfirmation,
+    UiPathConversationToolCallConfirmationData,
+    UiPathConversationToolCallConfirmationEvent,
+    UiPathConversationToolCallData,
+    UiPathConversationToolCallEndEvent,
+    UiPathConversationToolCallEvent,
+    UiPathConversationToolCallResult,
+    UiPathConversationToolCallStartEvent,
+)
+from .voice import (
+    UiPathVoiceToolCallMessage,
+    UiPathVoiceToolCallRequest,
+    UiPathVoiceToolCallResult,
+)
+
+__all__ = [
+    # Root
+    "UiPathConversationEvent",
+    "UiPathConversationLabelUpdatedEvent",
+    # Error
+    "UiPathConversationErrorStartEvent",
+    "UiPathConversationErrorEndEvent",
+    "UiPathConversationErrorEvent",
+    # Session
+    "UiPathSessionCapabilities",
+    "UiPathSessionStartEvent",
+    "UiPathSessionStartedEvent",
+    "UiPathSessionEndingEvent",
+    "UiPathSessionEndEvent",
+    # Exchange
+    "UiPathClientSideToolDeclaration",
+    "UiPathConversationExchangeStartEvent",
+    "UiPathConversationExchangeEndEvent",
+    "UiPathConversationExchangeEvent",
+    "UiPathConversationExchangeData",
+    "UiPathConversationExchange",
+    # Message
+    "UiPathConversationMessageStartEvent",
+    "UiPathConversationMessageEndEvent",
+    "UiPathConversationMessageEvent",
+    "UiPathConversationMessageData",
+    "UiPathConversationMessage",
+    # Content
+    "UiPathConversationContentPartChunkEvent",
+    "UiPathConversationContentPartStartEvent",
+    "UiPathContentPartInterrupted",
+    "UiPathConversationContentPartEndEvent",
+    "UiPathConversationContentPartEvent",
+    "UiPathConversationContentPartData",
+    "UiPathConversationContentPart",
+    "UiPathInlineValue",
+    "UiPathExternalValue",
+    "InlineOrExternal",
+    # Citation
+    "UiPathConversationCitationStartEvent",
+    "UiPathConversationCitationEndEvent",
+    "UiPathConversationCitationEvent",
+    "UiPathConversationCitationSourceBase",
+    "UiPathConversationCitationSourceUrl",
+    "UiPathConversationCitationSourceMedia",
+    "UiPathConversationCitationSource",
+    "UiPathConversationCitationData",
+    "UiPathConversationCitation",
+    # Tool
+    "UiPathConversationExecutingToolCallEvent",
+    "UiPathConversationToolCallStartEvent",
+    "UiPathConversationToolCallEndEvent",
+    "UiPathConversationToolCallConfirmation",
+    "UiPathConversationToolCallConfirmationData",
+    "UiPathConversationToolCallConfirmationEvent",
+    "UiPathConversationToolCallEvent",
+    "UiPathConversationToolCallResult",
+    "UiPathConversationToolCallData",
+    "UiPathConversationToolCall",
+    # Async Stream
+    "UiPathConversationInputStreamChunkEvent",
+    "UiPathConversationAsyncInputStreamStartEvent",
+    "UiPathConversationAsyncInputStreamEndEvent",
+    "UiPathConversationAsyncInputStreamEvent",
+    # Meta
+    "UiPathConversationMetaEvent",
+    # Voice
+    "UiPathVoiceToolCallRequest",
+    "UiPathVoiceToolCallMessage",
+    "UiPathVoiceToolCallResult",
+    # Interrupt (compat shims — deprecated, see interrupt.py)
+    "InterruptTypeEnum",
+    "UiPathConversationInterruptStartEvent",
+    "UiPathConversationInterruptEndEvent",
+    "UiPathConversationInterruptEvent",
+    "UiPathConversationInterruptData",
+    "UiPathConversationInterrupt",
+    "UiPathConversationGenericInterruptStartEvent",
+    "UiPathConversationGenericInterruptEndEvent",
+    "UiPathConversationToolCallConfirmationValue",
+    "UiPathConversationToolCallConfirmationEndValue",
+    "UiPathConversationToolCallConfirmationInterruptStartEvent",
+    "UiPathConversationToolCallConfirmationInterruptEndEvent",
+]
diff --git a/packages/uipath-core/src/uipath/core/chat/async_stream.py b/packages/uipath-core/src/uipath/core/chat/async_stream.py
new file mode 100644
index 000000000..64bea1e01
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/async_stream.py
@@ -0,0 +1,60 @@
+"""Async input stream events."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .error import UiPathConversationErrorEvent
+
+
+class UiPathConversationInputStreamChunkEvent(BaseModel):
+    """Represents a single chunk of input stream data."""
+
+    data: str
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationAsyncInputStreamStartEvent(BaseModel):
+    """Signals the start of an asynchronous input stream."""
+
+    mime_type: str = Field(..., alias="mimeType")
+    start_of_speech_sensitivity: str | None = Field(
+        None, alias="startOfSpeechSensitivity"
+    )
+    end_of_speech_sensitivity: str | None = Field(None, alias="endOfSpeechSensitivity")
+    prefix_padding_ms: int | None = Field(None, alias="prefixPaddingMs")
+    silence_duration_ms: int | None = Field(None, alias="silenceDurationMs")
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationAsyncInputStreamEndEvent(BaseModel):
+    """Signals the end of an asynchronous input stream."""
+
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    last_chunk_content_part_sequence: int | None = Field(
+        None, alias="lastChunkContentPartSequence"
+    )
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationAsyncInputStreamEvent(BaseModel):
+    """Encapsulates sub-events related to an asynchronous input stream."""
+
+    stream_id: str = Field(..., alias="streamId")
+    start: UiPathConversationAsyncInputStreamStartEvent | None = Field(
+        None, alias="startAsyncInputStream"
+    )
+    end: UiPathConversationAsyncInputStreamEndEvent | None = Field(
+        None, alias="endAsyncInputStream"
+    )
+    chunk: UiPathConversationInputStreamChunkEvent | None = None
+    meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(
+        None, alias="asyncInputStreamError"
+    )
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/citation.py b/packages/uipath-core/src/uipath/core/chat/citation.py
new file mode 100644
index 000000000..cd0d09140
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/citation.py
@@ -0,0 +1,86 @@
+"""Citation events for message content."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .error import UiPathConversationErrorEvent
+
+
+class UiPathConversationCitationStartEvent(BaseModel):
+    """Indicates the start of a citation target in a content part."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitationEndEvent(BaseModel):
+    """Indicates the end of a citation target in a content part."""
+
+    sources: list[UiPathConversationCitationSource]
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitationEvent(BaseModel):
+    """Encapsulates sub-events related to citations."""
+
+    citation_id: str = Field(..., alias="citationId")
+    start: UiPathConversationCitationStartEvent | None = Field(
+        None, alias="startCitation"
+    )
+    end: UiPathConversationCitationEndEvent | None = Field(None, alias="endCitation")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="citationError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitationSourceBase(BaseModel):
+    """Represents a citation source with common base fields."""
+
+    title: str
+    number: int
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitationSourceUrl(UiPathConversationCitationSourceBase):
+    """Represents a citation source that can be rendered as a link (URL)."""
+
+    url: str
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitationSourceMedia(UiPathConversationCitationSourceBase):
+    """Represents a citation source that references media, such as a PDF document."""
+
+    mime_type: str | None = Field(None, alias="mimeType")
+    download_url: str | None = Field(None, alias="downloadUrl")
+    page_number: str | None = Field(None, alias="pageNumber")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+UiPathConversationCitationSource = (
+    UiPathConversationCitationSourceUrl | UiPathConversationCitationSourceMedia
+)
+
+
+class UiPathConversationCitationData(BaseModel):
+    """Represents the core data of a citation or reference inside a content part."""
+
+    offset: int
+    length: int
+    sources: list[UiPathConversationCitationSource]
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationCitation(UiPathConversationCitationData):
+    """Represents a citation or reference inside a content part."""
+
+    citation_id: str = Field(..., alias="citationId")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/content.py b/packages/uipath-core/src/uipath/core/chat/content.py
new file mode 100644
index 000000000..4ae8b169c
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/content.py
@@ -0,0 +1,119 @@
+"""Message content part events."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, Sequence
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .citation import (
+    UiPathConversationCitation,
+    UiPathConversationCitationData,
+    UiPathConversationCitationEvent,
+)
+from .error import UiPathConversationErrorEvent
+
+
+class UiPathConversationContentPartChunkEvent(BaseModel):
+    """Contains a chunk of a message content part."""
+
+    data: str | None = None
+    citation: UiPathConversationCitationEvent | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationContentPartStartEvent(BaseModel):
+    """Signals the start of a message content part."""
+
+    mime_type: str = Field(..., alias="mimeType")
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    external_value: UiPathExternalValue | None = Field(None, alias="externalValue")
+    name: str | None = None
+    timestamp: str | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathContentPartInterrupted(BaseModel):
+    """Indicates the interrupt of a content stream."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationContentPartEndEvent(BaseModel):
+    """Signals the end of a message content part."""
+
+    last_chunk_content_part_sequence: int | None = Field(
+        None, alias="lastChunkContentPartSequence"
+    )
+    interrupted: UiPathContentPartInterrupted | None = None
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationContentPartEvent(BaseModel):
+    """Encapsulates events related to message content parts."""
+
+    content_part_id: str = Field(..., alias="contentPartId")
+    start: UiPathConversationContentPartStartEvent | None = Field(
+        None, alias="startContentPart"
+    )
+    end: UiPathConversationContentPartEndEvent | None = Field(
+        None, alias="endContentPart"
+    )
+    chunk: UiPathConversationContentPartChunkEvent | None = None
+    meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="contentPartError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathInlineValue(BaseModel):
+    """Used when a value is small enough to be returned inline."""
+
+    inline: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathExternalValue(BaseModel):
+    """Used when a value is too large to be returned inline."""
+
+    uri: str
+    byte_count: int | None = Field(None, alias="byteCount")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+InlineOrExternal = UiPathInlineValue | UiPathExternalValue
+
+
+class UiPathConversationContentPartData(BaseModel):
+    """Represents the core data of a single part of message content."""
+
+    mime_type: str = Field(..., alias="mimeType")
+    data: InlineOrExternal
+    citations: Sequence[UiPathConversationCitationData] = Field(default_factory=list)
+    is_transcript: bool | None = Field(None, alias="isTranscript")
+    is_incomplete: bool | None = Field(None, alias="isIncomplete")
+    name: str | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationContentPart(UiPathConversationContentPartData):
+    """Represents a single part of message content."""
+
+    content_part_id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()), alias="contentPartId"
+    )
+    created_at: str | None = Field(None, alias="createdAt")
+    updated_at: str | None = Field(None, alias="updatedAt")
+
+    # Override to use full type
+    citations: Sequence[UiPathConversationCitation] = Field(default_factory=list)
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/error.py b/packages/uipath-core/src/uipath/core/chat/error.py
new file mode 100644
index 000000000..7fd691fe0
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/error.py
@@ -0,0 +1,34 @@
+"""Common error event models used across all conversation event types."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiPathConversationErrorStartEvent(BaseModel):
+    """Represents the start of an error condition."""
+
+    message: str
+    details: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationErrorEndEvent(BaseModel):
+    """Represents the end of an error condition."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationErrorEvent(BaseModel):
+    """Encapsulates sub-events that represent the start and end of an error condition.
+
+    This is a common error event model used across all event types (conversation, exchange,
+    message, content part, citation, tool call, async input stream).
+    """
+
+    error_id: str = Field(..., alias="errorId")
+    start: UiPathConversationErrorStartEvent | None = Field(None, alias="startError")
+    end: UiPathConversationErrorEndEvent | None = Field(None, alias="endError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/event.py b/packages/uipath-core/src/uipath/core/chat/event.py
new file mode 100644
index 000000000..492d45f19
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/event.py
@@ -0,0 +1,93 @@
+"""The top-level event type representing an event in a conversation.
+
+This is the root container for all other event subtypes (conversation start,
+exchanges, messages, content, citations, tool calls, and async streams).
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .async_stream import UiPathConversationAsyncInputStreamEvent
+from .error import UiPathConversationErrorEvent
+from .exchange import UiPathConversationExchangeEvent
+from .meta import UiPathConversationMetaEvent
+from .session import (
+    UiPathSessionEndEvent,
+    UiPathSessionEndingEvent,
+    UiPathSessionStartedEvent,
+    UiPathSessionStartEvent,
+)
+from .tool import UiPathConversationToolCallEvent
+
+
+class UiPathConversationLabelUpdatedEvent(BaseModel):
+    """Indicates the update of the conversation label."""
+
+    label: str
+    autogenerated: bool
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationEvent(BaseModel):
+    """The top-level event type representing an event in a conversation.
+
+    This is the root container for all other event subtypes (conversation start,
+    exchanges, messages, content, citations, tool calls, and async streams).
+    """
+
+    conversation_id: str = Field(
+        ...,
+        alias="conversationId",
+        description="A globally unique identifier for conversation to which the other sub-event and data properties apply.",
+    )
+    start: UiPathSessionStartEvent | None = Field(
+        None,
+        alias="startSession",
+        description="Signals the start of session for a conversation.",
+    )
+    started: UiPathSessionStartedEvent | None = Field(
+        None,
+        alias="sessionStarted",
+        description="Sent in response to a SessionStartEvent to signal the acceptance of the session.",
+    )
+    ending: UiPathSessionEndingEvent | None = Field(
+        None,
+        alias="sessionEnding",
+        description="Sent by the service when the client needs to end the current session.",
+    )
+    end: UiPathSessionEndEvent | None = Field(
+        None,
+        alias="endSession",
+        description="Signals the end of a session for a conversation.",
+    )
+    exchange: UiPathConversationExchangeEvent | None = Field(
+        None,
+        description="Encapsulates sub-events related to an exchange within a conversation.",
+    )
+    async_input_stream: UiPathConversationAsyncInputStreamEvent | None = Field(
+        None,
+        alias="asyncInputStream",
+        description="Encapsulates sub-events related to an asynchronous input stream.",
+    )
+    async_tool_call: UiPathConversationToolCallEvent | None = Field(
+        None,
+        alias="asyncToolCall",
+        description="Optional async tool call sub-event. This feature is not supported by all LLMs. Most tool calls are scoped to a message, and use the toolCall and toolResult properties defined by the ConversationMessage type.",
+    )
+    label_updated: "UiPathConversationLabelUpdatedEvent | None" = Field(
+        None,
+        alias="labelUpdated",
+        description="Indicates that the conversation's label has been updated. Useful for UIs to update the display name of live conversations.",
+    )
+    meta_event: UiPathConversationMetaEvent | None = Field(
+        None,
+        alias="metaEvent",
+        description="Allows additional events to be sent in the context of the enclosing event stream.",
+    )
+    error: UiPathConversationErrorEvent | None = Field(
+        None,
+        alias="conversationError",
+        description="Sent by the service to indicate the start and end of an error condition impacting a conversation. The client should not send any events for this conversation while the error condition is present.",
+    )
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/exchange.py b/packages/uipath-core/src/uipath/core/chat/exchange.py
new file mode 100644
index 000000000..835489dfb
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/exchange.py
@@ -0,0 +1,96 @@
+"""Exchange-level events.
+
+Characteristics of an Exchange:
+It groups together messages that belong to the same turn of conversation.
+
+Example:
+    User says something → one message inside the exchange.
+    LLM responds → one or more messages in the same exchange.
+
+Each exchange has:
+    A start event (signals the beginning of the turn).
+    An end event (signals the end of the turn).
+    Messages that happened in between.
+
+An exchange can include multiple messages (e.g. LLM streaming several outputs, or user message + assistant + tool outputs).
+Exchanges are ordered within a conversation via conversation_sequence.
+"""
+
+from typing import Any, Sequence
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .error import UiPathConversationErrorEvent
+from .message import (
+    UiPathConversationMessage,
+    UiPathConversationMessageData,
+    UiPathConversationMessageEvent,
+)
+
+
+class UiPathClientSideToolDeclaration(BaseModel):
+    """A client-side tool declaration from the SDK client."""
+
+    name: str
+    input_schema: dict[str, Any] | None = Field(None, alias="inputSchema")
+    output_schema: dict[str, Any] | None = Field(None, alias="outputSchema")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExchangeStartEvent(BaseModel):
+    """Signals the start of an exchange of messages within a conversation."""
+
+    conversation_sequence: int | None = Field(None, alias="conversationSequence")
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    client_side_tools: list[UiPathClientSideToolDeclaration] | None = Field(
+        None, alias="clientSideTools"
+    )
+    timestamp: str | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExchangeEndEvent(BaseModel):
+    """Signals the end of an exchange of messages within a conversation."""
+
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExchangeEvent(BaseModel):
+    """Encapsulates a single exchange in the conversation."""
+
+    exchange_id: str = Field(..., alias="exchangeId")
+    start: UiPathConversationExchangeStartEvent | None = Field(
+        None, alias="startExchange"
+    )
+    end: UiPathConversationExchangeEndEvent | None = Field(None, alias="endExchange")
+    message: UiPathConversationMessageEvent | None = None
+    meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="exchangeError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExchangeData(BaseModel):
+    """Represents the core data of a group of related messages (one turn of conversation)."""
+
+    messages: Sequence[UiPathConversationMessageData]
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExchange(UiPathConversationExchangeData):
+    """Represents a group of related messages (one turn of conversation)."""
+
+    exchange_id: str = Field(..., alias="exchangeId")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+    span_id: str | None = Field(None, alias="spanId")
+
+    # Override to use full type
+    messages: Sequence[UiPathConversationMessage]
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/interrupt.py b/packages/uipath-core/src/uipath/core/chat/interrupt.py
new file mode 100644
index 000000000..9094d1597
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/interrupt.py
@@ -0,0 +1,122 @@
+"""Compatibility shims for legacy interrupt event types.
+
+The interrupt-based tool-call confirmation flow was replaced by `confirmToolCall`
+on the tool call event itself (see PR #1558). The original `interrupt.py` was
+removed in `uipath-core` 0.5.13, but published `uipath-runtime` versions still
+import these names at module load time, breaking installs that pull the new
+`uipath-core` alongside an older runtime.
+
+These shims keep those imports working. They are not used by current code paths
+and should be removed in the next minor bump of `uipath-core`.
+"""
+
+from enum import Enum
+from typing import Any, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class InterruptTypeEnum(str, Enum):
+    """Enum of known interrupt types."""
+
+    TOOL_CALL_CONFIRMATION = "uipath_cas_tool_call_confirmation"
+
+
+class UiPathConversationToolCallConfirmationValue(BaseModel):
+    """Schema for tool call confirmation interrupt value."""
+
+    tool_call_id: str = Field(..., alias="toolCallId")
+    tool_name: str = Field(..., alias="toolName")
+    input_schema: Any = Field(..., alias="inputSchema")
+    input_value: Any | None = Field(None, alias="inputValue")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationInterruptStartEvent(BaseModel):
+    """Tool call confirmation interrupt start event with strong typing."""
+
+    type: Literal["uipath_cas_tool_call_confirmation"]
+    value: UiPathConversationToolCallConfirmationValue
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationGenericInterruptStartEvent(BaseModel):
+    """Generic interrupt start event for custom interrupt types."""
+
+    type: str
+    value: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+UiPathConversationInterruptStartEvent = Union[
+    UiPathConversationToolCallConfirmationInterruptStartEvent,
+    UiPathConversationGenericInterruptStartEvent,
+]
+
+
+class UiPathConversationToolCallConfirmationEndValue(BaseModel):
+    """Schema for tool call confirmation end value."""
+
+    approved: bool
+    input: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationInterruptEndEvent(BaseModel):
+    """Tool call confirmation interrupt end event with strong typing."""
+
+    type: Literal["uipath_cas_tool_call_confirmation"]
+    value: UiPathConversationToolCallConfirmationEndValue
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationGenericInterruptEndEvent(BaseModel):
+    """Generic interrupt end event for custom interrupt types."""
+
+    type: str
+    value: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+UiPathConversationInterruptEndEvent = Union[
+    UiPathConversationToolCallConfirmationInterruptEndEvent,
+    UiPathConversationGenericInterruptEndEvent,
+]
+
+
+class UiPathConversationInterruptEvent(BaseModel):
+    """Encapsulates interrupt-related events within a message."""
+
+    interrupt_id: str = Field(..., alias="interruptId")
+    start: UiPathConversationInterruptStartEvent | None = Field(
+        None, alias="startInterrupt"
+    )
+    end: UiPathConversationInterruptEndEvent | None = Field(None, alias="endInterrupt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationInterruptData(BaseModel):
+    """Core data of an interrupt within a message."""
+
+    type: str
+    interrupt_value: Any = Field(..., alias="interruptValue")
+    end_value: Any | None = Field(None, alias="endValue")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationInterrupt(UiPathConversationInterruptData):
+    """An interrupt within a message — a pause point where the agent needs external input."""
+
+    interrupt_id: str = Field(..., alias="interruptId")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/message.py b/packages/uipath-core/src/uipath/core/chat/message.py
new file mode 100644
index 000000000..37aa2bd76
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/message.py
@@ -0,0 +1,90 @@
+"""Message-level events."""
+
+import uuid
+from typing import Any, Sequence
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .content import (
+    UiPathConversationContentPart,
+    UiPathConversationContentPartData,
+    UiPathConversationContentPartEvent,
+)
+from .error import UiPathConversationErrorEvent
+from .tool import (
+    UiPathConversationToolCall,
+    UiPathConversationToolCallData,
+    UiPathConversationToolCallEvent,
+)
+
+
+class UiPathConversationMessageStartEvent(BaseModel):
+    """Signals the start of a message within an exchange."""
+
+    exchange_sequence: int | None = Field(None, alias="exchangeSequence")
+    timestamp: str | None = None
+    role: str
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationMessageEndEvent(BaseModel):
+    """Signals the end of a message."""
+
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationMessageEvent(BaseModel):
+    """Encapsulates sub-events related to a message."""
+
+    message_id: str = Field(..., alias="messageId")
+    start: UiPathConversationMessageStartEvent | None = Field(
+        None, alias="startMessage"
+    )
+    end: UiPathConversationMessageEndEvent | None = Field(None, alias="endMessage")
+    content_part: UiPathConversationContentPartEvent | None = Field(
+        None, alias="contentPart"
+    )
+    tool_call: UiPathConversationToolCallEvent | None = Field(None, alias="toolCall")
+    meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="messageError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationMessageData(BaseModel):
+    """Represents the core data of a single message within an exchange."""
+
+    role: str
+    content_parts: Sequence[UiPathConversationContentPartData] = Field(
+        ..., alias="contentParts"
+    )
+    tool_calls: Sequence[UiPathConversationToolCallData] = Field(
+        default_factory=list, alias="toolCalls"
+    )
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationMessage(UiPathConversationMessageData):
+    """Represents a single message within an exchange."""
+
+    message_id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()), alias="messageId"
+    )
+    created_at: str | None = Field(None, alias="createdAt")
+    updated_at: str | None = Field(None, alias="updatedAt")
+    span_id: str | None = Field(None, alias="spanId")
+
+    # Overrides to use full types
+    content_parts: Sequence[UiPathConversationContentPart] = Field(
+        ..., alias="contentParts"
+    )
+    tool_calls: Sequence[UiPathConversationToolCall] = Field(
+        default_factory=list, alias="toolCalls"
+    )
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/meta.py b/packages/uipath-core/src/uipath/core/chat/meta.py
new file mode 100644
index 000000000..574737ef4
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/meta.py
@@ -0,0 +1,11 @@
+"""Meta events allow additional extensible data."""
+
+from pydantic import BaseModel, ConfigDict
+
+
+class UiPathConversationMetaEvent(BaseModel):
+    """Arbitrary metadata events in the conversation schema."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
diff --git a/packages/uipath-core/src/uipath/core/chat/session.py b/packages/uipath-core/src/uipath/core/chat/session.py
new file mode 100644
index 000000000..d0156b196
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/session.py
@@ -0,0 +1,57 @@
+"""Conversation-level events and capabilities."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiPathSessionCapabilities(BaseModel):
+    """Describes the capabilities of a conversation participant."""
+
+    async_input_stream_emitter: bool | None = Field(
+        None, alias="asyncInputStreamEmitter"
+    )
+    async_input_stream_handler: bool | None = Field(
+        None, alias="asyncInputStreamHandler"
+    )
+    async_tool_call_emitter: bool | None = Field(None, alias="asyncToolCallEmitter")
+    async_tool_call_handler: bool | None = Field(None, alias="asyncToolCallHandler")
+    mime_types_emitted: list[str] | None = Field(None, alias="mimeTypesEmitted")
+    mime_types_handled: list[str] | None = Field(None, alias="mimeTypesHandled")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class UiPathSessionStartEvent(BaseModel):
+    """Signals the start of session for a conversation."""
+
+    capabilities: UiPathSessionCapabilities | None = None
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathSessionStartedEvent(BaseModel):
+    """Sent in response to a SessionStartEvent to signal the acceptance of the session."""
+
+    capabilities: UiPathSessionCapabilities | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathSessionEndingEvent(BaseModel):
+    """Sent by the service when the client needs to end the current session."""
+
+    time_to_live_ms: int = Field(..., alias="timeToLiveMS")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathSessionEndEvent(BaseModel):
+    """Signals the end of a session for a conversation."""
+
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/tool.py b/packages/uipath-core/src/uipath/core/chat/tool.py
new file mode 100644
index 000000000..514e42908
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/tool.py
@@ -0,0 +1,131 @@
+"""Tool call events."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .error import UiPathConversationErrorEvent
+
+
+class UiPathConversationToolCallResult(BaseModel):
+    """Represents the result of a tool call execution."""
+
+    timestamp: str | None = None
+    output: Any | None = None
+    is_error: bool | None = Field(None, alias="isError")
+    cancelled: bool | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallStartEvent(BaseModel):
+    """Signals the start of a tool call."""
+
+    tool_name: str = Field(..., alias="toolName")
+    timestamp: str | None = None
+    input: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    require_confirmation: bool | None = Field(None, alias="requireConfirmation")
+    input_schema: Any | None = Field(None, alias="inputSchema")
+    is_client_side_tool: bool | None = Field(None, alias="isClientSideTool")
+    output_schema: Any | None = Field(None, alias="outputSchema")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallEndEvent(BaseModel):
+    """Signals the end of a tool call."""
+
+    timestamp: str | None = None
+    output: Any = None
+    is_error: bool | None = Field(None, alias="isError")
+    cancelled: bool | None = None
+    metadata: dict[str, Any] | None = Field(None, alias="metaData")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationExecutingToolCallEvent(BaseModel):
+    """Signals the client that the tool is about to be executed.
+
+    Emitted in all scenarios. For client-side tools, the client should begin
+    executing its handler upon receiving this event.
+    """
+
+    timestamp: str | None = None
+    input: dict[str, Any] | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationEvent(BaseModel):
+    """Signals a tool call confirmation (approve/reject) from the client."""
+
+    approved: bool
+    input: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationData(BaseModel):
+    """Represents the core data of a tool call confirmation."""
+
+    approved: bool
+    input: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmation(
+    UiPathConversationToolCallConfirmationData
+):
+    """Represents the stored confirmation state on a tool call."""
+
+    confirmed_at: str | None = Field(None, alias="confirmedAt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallEvent(BaseModel):
+    """Encapsulates the data related to a tool call event."""
+
+    tool_call_id: str = Field(..., alias="toolCallId")
+    start: UiPathConversationToolCallStartEvent | None = Field(
+        None, alias="startToolCall"
+    )
+    end: UiPathConversationToolCallEndEvent | None = Field(None, alias="endToolCall")
+    confirm: UiPathConversationToolCallConfirmationEvent | None = Field(
+        None, alias="confirmToolCall"
+    )
+    executing: UiPathConversationExecutingToolCallEvent | None = Field(
+        None, alias="executingToolCall"
+    )
+    meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="toolCallError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallData(BaseModel):
+    """Represents the core data of a call to an external tool or function within a message."""
+
+    name: str
+    input: dict[str, Any] | None = None
+    result: UiPathConversationToolCallResult | None = None
+    require_confirmation: bool | None = Field(None, alias="requireConfirmation")
+    input_schema: Any | None = Field(None, alias="inputSchema")
+    confirmation: UiPathConversationToolCallConfirmationData | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCall(UiPathConversationToolCallData):
+    """Represents a call to an external tool or function within a message."""
+
+    tool_call_id: str = Field(..., alias="toolCallId")
+    timestamp: str | None = None
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+    confirmation: UiPathConversationToolCallConfirmation | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
diff --git a/packages/uipath-core/src/uipath/core/chat/voice.py b/packages/uipath-core/src/uipath/core/chat/voice.py
new file mode 100644
index 000000000..7b1adf7e8
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/chat/voice.py
@@ -0,0 +1,30 @@
+"""Voice tool-call wire models (CAS socket.io)."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class _VoiceWire(BaseModel):
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathVoiceToolCallRequest(_VoiceWire):
+    """Single tool call in a batch."""
+
+    call_id: str = Field(..., alias="callId")
+    tool_name: str = Field(..., alias="toolName")
+    args: dict[str, Any]
+
+
+class UiPathVoiceToolCallMessage(_VoiceWire):
+    """Batch of tool calls from CAS."""
+
+    calls: list[UiPathVoiceToolCallRequest] = Field(..., min_length=1)
+
+
+class UiPathVoiceToolCallResult(_VoiceWire):
+    """Result of a single tool call."""
+
+    result: str
+    is_error: bool = Field(..., alias="isError")
diff --git a/packages/uipath-core/src/uipath/core/errors/__init__.py b/packages/uipath-core/src/uipath/core/errors/__init__.py
new file mode 100644
index 000000000..25f83f949
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/errors/__init__.py
@@ -0,0 +1,12 @@
+"""UiPath core exceptions module.
+
+This module exposes common UiPath exceptions.
+"""
+
+from .errors import (
+    ErrorCategory,
+    UiPathFaultedTriggerError,
+    UiPathPendingTriggerError,
+)
+
+__all__ = ["UiPathFaultedTriggerError", "UiPathPendingTriggerError", "ErrorCategory"]
diff --git a/packages/uipath-core/src/uipath/core/errors/errors.py b/packages/uipath-core/src/uipath/core/errors/errors.py
new file mode 100644
index 000000000..8df841c2d
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/errors/errors.py
@@ -0,0 +1,33 @@
+"""UiPath common exceptions."""
+
+from enum import Enum
+
+
+class ErrorCategory(str, Enum):
+    """Categories of UiPath errors."""
+
+    DEPLOYMENT = "Deployment"
+    SYSTEM = "System"
+    UNKNOWN = "Unknown"
+    USER = "User"
+
+
+class UiPathFaultedTriggerError(Exception):
+    """UiPath resume trigger error."""
+
+    category: ErrorCategory
+    message: str
+    detail: str
+
+    def __init__(self, category: ErrorCategory, message: str, detail: str = ""):
+        """Initialize the UiPathFaultedTriggerError."""
+        self.category = category
+        self.message = message
+        self.detail = detail
+        super().__init__(f"{message}: {detail}" if detail else message)
+
+
+class UiPathPendingTriggerError(UiPathFaultedTriggerError):
+    """Custom resume trigger error for pending triggers."""
+
+    pass
diff --git a/packages/uipath-core/src/uipath/core/events/__init__.py b/packages/uipath-core/src/uipath/core/events/__init__.py
new file mode 100644
index 000000000..5c387ffaa
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/events/__init__.py
@@ -0,0 +1,5 @@
+"""This module contains the event bus implementation."""
+
+from uipath.core.events._event_bus import EventBus
+
+__all__ = ["EventBus"]
diff --git a/packages/uipath-core/src/uipath/core/events/_event_bus.py b/packages/uipath-core/src/uipath/core/events/_event_bus.py
new file mode 100644
index 000000000..e99d6ffa8
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/events/_event_bus.py
@@ -0,0 +1,157 @@
+"""Event bus implementation for runtime events."""
+
+import asyncio
+import logging
+from typing import Any, Callable, TypeVar
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class EventBus:
+    """Event bus for publishing and subscribing to events."""
+
+    def __init__(self) -> None:
+        """Initialize a new EventBus instance."""
+        self._subscribers: dict[str, list[Callable[[Any], Any]]] = {}
+        self._running_tasks: set[asyncio.Task[Any]] = set()
+
+    def subscribe(self, topic: str, handler: Callable[[Any], Any]) -> None:
+        """Subscribe a handler method/function to a topic.
+
+        Args:
+            topic: The topic name to subscribe to.
+            handler: The async handler method/function that will handle events for this topic.
+        """
+        if topic not in self._subscribers:
+            self._subscribers[topic] = []
+        self._subscribers[topic].append(handler)
+        logger.debug(f"Handler registered for topic: {topic}")
+
+    def unsubscribe(self, topic: str, handler: Callable[[Any], Any]) -> None:
+        """Unsubscribe a handler from a topic.
+
+        Args:
+            topic: The topic name to unsubscribe from.
+            handler: The handler to remove.
+        """
+        if topic in self._subscribers:
+            try:
+                self._subscribers[topic].remove(handler)
+                if not self._subscribers[topic]:
+                    del self._subscribers[topic]
+                logger.debug(f"Handler unregistered from topic: {topic}")
+            except ValueError:
+                logger.warning(f"Handler not found for topic: {topic}")
+
+    def _cleanup_completed_tasks(self) -> None:
+        completed_tasks = {task for task in self._running_tasks if task.done()}
+        self._running_tasks -= completed_tasks
+
+    async def publish(
+        self, topic: str, payload: T, wait_for_completion: bool = True
+    ) -> None:
+        """Publish an event to all handlers of a topic.
+
+        Args:
+            topic: The topic name to publish to.
+            payload: The event payload to publish.
+            wait_for_completion: Whether to wait for the event to be processed.
+        """
+        if topic not in self._subscribers:
+            logger.debug(f"No handlers for topic: {topic}")
+            return
+
+        self._cleanup_completed_tasks()
+
+        tasks = []
+        for subscriber in self._subscribers[topic]:
+            try:
+                task = asyncio.create_task(subscriber(payload))
+                tasks.append(task)
+                self._running_tasks.add(task)
+            except Exception as e:
+                logger.error(f"Error creating task for subscriber {subscriber}: {e}")
+
+        if tasks and wait_for_completion:
+            try:
+                await asyncio.gather(*tasks, return_exceptions=True)
+            except Exception as e:
+                logger.error(f"Error during event processing for topic {topic}: {e}")
+            finally:
+                # Clean up the tasks we just waited for
+                for task in tasks:
+                    self._running_tasks.discard(task)
+
+    def get_running_tasks_count(self) -> int:
+        """Get the number of currently running subscriber tasks.
+
+        Returns:
+            Number of running tasks.
+        """
+        self._cleanup_completed_tasks()
+        return len(self._running_tasks)
+
+    async def wait_for_all(self, timeout: float | None = None) -> None:
+        """Wait for all currently running subscriber tasks to complete.
+
+        Args:
+            timeout: Maximum time to wait in seconds. If None, waits indefinitely.
+        """
+        self._cleanup_completed_tasks()
+
+        if not self._running_tasks:
+            logger.debug("No running tasks to wait for")
+            return
+
+        logger.debug(
+            f"Waiting for {len(self._running_tasks)} EventBus tasks to complete..."
+        )
+
+        try:
+            tasks_to_wait = list(self._running_tasks)
+
+            if timeout:
+                await asyncio.wait_for(
+                    asyncio.gather(*tasks_to_wait, return_exceptions=True),
+                    timeout=timeout,
+                )
+            else:
+                await asyncio.gather(*tasks_to_wait, return_exceptions=True)
+
+            logger.debug("All EventBus tasks completed")
+
+        except asyncio.TimeoutError:
+            logger.warning(f"Timeout waiting for EventBus tasks after {timeout}s")
+            for task in tasks_to_wait:
+                if not task.done():
+                    task.cancel()
+        except Exception as e:
+            logger.error(f"Error waiting for EventBus tasks: {e}")
+        finally:
+            self._cleanup_completed_tasks()
+
+    def get_subscribers_count(self, topic: str) -> int:
+        """Get the number of subscribers for a topic.
+
+        Args:
+            topic: The topic name.
+
+        Returns:
+            Number of handlers for the topic.
+        """
+        return len(self._subscribers.get(topic, []))
+
+    def clear_subscribers(self, topic: str | None = None) -> None:
+        """Clear subscribers for a topic or all topics.
+
+        Args:
+            topic: The topic to clear. If None, clears all topics.
+        """
+        if topic is None:
+            self._subscribers.clear()
+            logger.debug("All handlers cleared")
+        elif topic in self._subscribers:
+            del self._subscribers[topic]
+            logger.debug(f"Handlers cleared for topic: {topic}")
diff --git a/packages/uipath-core/src/uipath/core/feature_flags/__init__.py b/packages/uipath-core/src/uipath/core/feature_flags/__init__.py
new file mode 100644
index 000000000..c112d4f3b
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/feature_flags/__init__.py
@@ -0,0 +1,11 @@
+"""UiPath Feature Flags.
+
+Local-only feature flag registry for the UiPath SDK.
+"""
+
+from .feature_flags import FeatureFlags, FeatureFlagsManager
+
+__all__ = [
+    "FeatureFlags",
+    "FeatureFlagsManager",
+]
diff --git a/packages/uipath-core/src/uipath/core/feature_flags/feature_flags.py b/packages/uipath-core/src/uipath/core/feature_flags/feature_flags.py
new file mode 100644
index 000000000..53469d7cf
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/feature_flags/feature_flags.py
@@ -0,0 +1,118 @@
+"""Feature flags configuration for UiPath SDK.
+
+A simple, local-only feature flag registry. Flags can be set
+programmatically via :meth:`FeatureFlagsManager.configure_flags` or
+supplied via environment variables named ``UIPATH_FEATURE_<FlagName>``
+when nothing has been configured programmatically.
+
+Programmatic values always take precedence over environment variables.
+
+Example usage::
+
+    from uipath.core.feature_flags import FeatureFlags
+
+    # Programmatic configuration (e.g. from an upstream layer)
+    FeatureFlags.configure_flags({"NewSerialization": True, "ModelOverride": "gpt-4"})
+
+    # Check a boolean flag
+    if FeatureFlags.is_flag_enabled("NewSerialization"):
+        ...
+
+    # Get an arbitrary value
+    model = FeatureFlags.get_flag("ModelOverride", default="default-model")
+
+    # Local override via environment variable
+    # $ export UIPATH_FEATURE_NewSerialization=false
+"""
+
+import json
+import os
+from typing import Any
+
+
+def _parse_env_value(raw: str) -> Any:
+    """Convert an environment variable string to a Python value.
+
+    Booleans are matched first (case-insensitive). For all other values
+    JSON decoding is attempted so that dicts, lists and numbers survive
+    the env-var round-trip.  Plain strings that are not valid JSON are
+    returned as-is.
+    """
+    lower = raw.lower()
+    if lower == "true":
+        return True
+    if lower == "false":
+        return False
+    try:
+        parsed = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return raw
+    # Only promote structured types (dict/list); scalars stay as strings.
+    if isinstance(parsed, (dict, list)):
+        return parsed
+    return raw
+
+
+class FeatureFlagsManager:
+    """Singleton registry for UiPath feature flags.
+
+    Use the module-level :data:`FeatureFlags` instance rather than
+    instantiating this class directly.
+    """
+
+    _instance: "FeatureFlagsManager | None" = None
+    _flags: dict[str, Any]
+
+    def __new__(cls) -> "FeatureFlagsManager":
+        """Return the singleton instance, creating it on first call."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._flags = {}
+        return cls._instance
+
+    def configure_flags(self, flags: dict[str, Any]) -> None:
+        """Merge feature flag values into the registry.
+
+        Args:
+            flags: Mapping of flag names to their values. Existing flags
+                with the same name are overwritten.
+        """
+        self._flags.update(flags)
+
+    def reset_flags(self) -> None:
+        """Clear all configured flags."""
+        self._flags.clear()
+
+    def get_flag(self, name: str, *, default: Any = None) -> Any:
+        """Return a flag value.
+
+        Resolution order:
+
+        1. Value set via :meth:`configure_flags` (highest priority)
+        2. ``UIPATH_FEATURE_<name>`` environment variable (fallback when nothing configured)
+        3. *default*
+
+        Args:
+            name: The feature flag name.
+            default: Fallback when the flag is not set anywhere.
+        """
+        if name in self._flags:
+            return self._flags[name]
+        env_val = os.environ.get(f"UIPATH_FEATURE_{name}")
+        if env_val is not None:
+            return _parse_env_value(env_val)
+        return default
+
+    def is_flag_enabled(self, name: str, *, default: bool = False) -> bool:
+        """Check whether a boolean flag is enabled.
+
+        Uses the same resolution order as :meth:`get_flag`.
+
+        Args:
+            name: The feature flag name.
+            default: Fallback when the flag is not set anywhere.
+        """
+        return bool(self.get_flag(name, default=default))
+
+
+FeatureFlags = FeatureFlagsManager()
diff --git a/packages/uipath-core/src/uipath/core/governance/__init__.py b/packages/uipath-core/src/uipath/core/governance/__init__.py
new file mode 100644
index 000000000..e3dcab741
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/governance/__init__.py
@@ -0,0 +1,53 @@
+"""UiPath governance shared contracts.
+
+Evaluator-agnostic types every governance consumer references —
+adapter packages (``uipath-langchain``, ``uipath-openai``, …), the
+runtime layer (``uipath.runtime.governance``), and customer code that
+catches :class:`GovernanceBlockException`. The full runtime / audit /
+native-evaluator implementation lives in ``uipath.runtime.governance``;
+this core surface is just the contracts.
+"""
+
+from .config import (
+    GOVERNANCE_FEATURE_FLAG,
+    is_governance_enabled,
+)
+from .exceptions import (
+    GovernanceBlockException,
+    GovernanceConfigError,
+    GovernanceViolation,
+    Severity,
+)
+from .models import Action, AuditRecord, EnforcementMode, LifecycleHook, RuleEvaluation
+from .providers import (
+    FiredRule,
+    GovernanceCompensationProvider,
+    GovernancePolicyProvider,
+    GovernRequest,
+    PolicyContext,
+    PolicyResponse,
+)
+
+__all__ = [
+    # Output models (cross adapter boundary)
+    "Action",
+    "AuditRecord",
+    "EnforcementMode",
+    "LifecycleHook",
+    "RuleEvaluation",
+    # Config
+    "GOVERNANCE_FEATURE_FLAG",
+    "is_governance_enabled",
+    # Exceptions
+    "GovernanceBlockException",
+    "GovernanceConfigError",
+    "GovernanceViolation",
+    "Severity",
+    # Provider protocols + wire models
+    "FiredRule",
+    "GovernanceCompensationProvider",
+    "GovernancePolicyProvider",
+    "GovernRequest",
+    "PolicyContext",
+    "PolicyResponse",
+]
diff --git a/packages/uipath-core/src/uipath/core/governance/config.py b/packages/uipath-core/src/uipath/core/governance/config.py
new file mode 100644
index 000000000..7fec33848
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/governance/config.py
@@ -0,0 +1,37 @@
+"""Governance configuration.
+
+Process-level feature-flag gate that decides whether the Python
+governance checker runs at all. The
+:class:`uipath.core.governance.EnforcementMode` value type is defined
+in :mod:`uipath.core.governance.models`; the per-policy runtime state
+that selects a mode (backend-supplied via the ``/runtime/policy``
+client) lives in the ``uipath-runtime`` package.
+"""
+
+from __future__ import annotations
+
+from uipath.core.feature_flags import FeatureFlags
+
+# Feature flag name controlling whether governance runs.
+# Mirrors the gate in ``uipath-runtime`` so the platform-injection path
+# and direct callers (agents constructing an evaluator themselves)
+# honour the same toggle.
+GOVERNANCE_FEATURE_FLAG = "EnablePythonGovernanceChecker"
+
+
+def is_governance_enabled() -> bool:
+    """Return whether the ``EnablePythonGovernanceChecker`` flag is enabled.
+
+    Governance is **off by default** — the flag must be explicitly set
+    to ``true`` (programmatically via the ``FeatureFlags`` registry, or
+    via the ``UIPATH_FEATURE_EnablePythonGovernanceChecker`` env var)
+    for this function to return ``True``.
+
+    Resolution order:
+
+    1. :meth:`uipath.core.feature_flags.FeatureFlagsManager.is_flag_enabled` -
+       the in-process programmatic registry (typically populated from
+       gitops) and its own ``UIPATH_FEATURE_<name>`` env-var fallback.
+    2. Default ``False`` (governance disabled).
+    """
+    return FeatureFlags.is_flag_enabled(GOVERNANCE_FEATURE_FLAG, default=False)
diff --git a/packages/uipath-core/src/uipath/core/governance/exceptions.py b/packages/uipath-core/src/uipath/core/governance/exceptions.py
new file mode 100644
index 000000000..48f4b178a
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/governance/exceptions.py
@@ -0,0 +1,114 @@
+"""Governance exception types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from uipath.core.governance.models import AuditRecord
+
+_DEFAULT_RULE_ID = "POLICY"
+_DEFAULT_RULE_NAME = "Governance Policy"
+_MSG_PREFIX = "[Governance Policy Violation]"
+
+
+class Severity(str, Enum):
+    """Severity classification for a governance violation."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+@dataclass
+class GovernanceViolation:
+    """Details of a governance rule violation."""
+
+    rule_id: str
+    rule_name: str
+    detail: str
+    severity: Severity = Severity.HIGH
+
+
+def _format_violation_message(rule_id: str, rule_name: str, detail: str) -> str:
+    return f"{_MSG_PREFIX} {rule_name} ({rule_id}): {detail}"
+
+
+class GovernanceBlockException(Exception):
+    """Raised when a governance policy blocks an operation.
+
+    This exception indicates that the AI agent's operation was blocked by
+    a configured governance policy, not an unexpected system error.
+
+    Prefer the classmethod constructors (:meth:`from_violation`,
+    :meth:`from_audit_record`) when you have structured context — the
+    default constructor is for raw-message use only.
+    """
+
+    # Error code for Orchestrator categorization
+    error_code: str = "GOVERNANCE_POLICY_VIOLATION"
+
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        violation: GovernanceViolation | None = None,
+        audit_record: AuditRecord | None = None,
+        rule_id: str = _DEFAULT_RULE_ID,
+        rule_name: str = _DEFAULT_RULE_NAME,
+    ) -> None:
+        """Construct from a pre-formatted message and optional structured context.
+
+        Most callers should use :meth:`from_violation` or
+        :meth:`from_audit_record` instead of passing structured context
+        directly.
+        """
+        self.violation = violation
+        self.audit_record = audit_record
+        self.rule_id = rule_id
+        self.rule_name = rule_name
+        super().__init__(
+            message or f"{_MSG_PREFIX} Operation blocked by governance policy."
+        )
+
+    @classmethod
+    def from_violation(
+        cls, violation: GovernanceViolation
+    ) -> "GovernanceBlockException":
+        """Build from a structured :class:`GovernanceViolation`."""
+        return cls(
+            message=_format_violation_message(
+                violation.rule_id, violation.rule_name, violation.detail
+            ),
+            violation=violation,
+            rule_id=violation.rule_id,
+            rule_name=violation.rule_name,
+        )
+
+    @classmethod
+    def from_audit_record(cls, audit_record: AuditRecord) -> "GovernanceBlockException":
+        """Build from an :class:`AuditRecord` — first matched rule wins."""
+        matched_rules = [e for e in audit_record.evaluations if e.matched]
+        if matched_rules:
+            rule = matched_rules[0]
+            message = _format_violation_message(
+                rule.rule_id, rule.rule_name, rule.detail or "Policy violation detected"
+            )
+            return cls(
+                message=message,
+                audit_record=audit_record,
+                rule_id=rule.rule_id,
+                rule_name=rule.rule_name,
+            )
+        return cls(
+            message=(
+                f"{_MSG_PREFIX} Operation blocked. "
+                f"Rules evaluated: {len(audit_record.evaluations)}"
+            ),
+            audit_record=audit_record,
+        )
+
+
+class GovernanceConfigError(RuntimeError):
+    """Raised when governance is misconfigured."""
diff --git a/packages/uipath-core/src/uipath/core/governance/models.py b/packages/uipath-core/src/uipath/core/governance/models.py
new file mode 100644
index 000000000..9fc5e2084
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/governance/models.py
@@ -0,0 +1,83 @@
+"""Shared governance contracts.
+
+Two groups of types live here, both kept free of policy-input concepts
+(``Rule``/``Check``/``Condition``) so adapter packages don't inherit
+the native policy model:
+
+- **Output types** (:class:`Action`, :class:`LifecycleHook`,
+  :class:`RuleEvaluation`, :class:`AuditRecord`) — cross the adapter
+  boundary at evaluation time: every evaluator implementation (native,
+  AGT, composite, …) produces them, and every adapter consumes them.
+- **Configuration value types** (:class:`EnforcementMode`) — describe
+  governance configuration shared by core, runtime, and consumers. The
+  runtime state that selects an enforcement mode lives in
+  ``uipath-runtime``; only the value type lives here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+
+class Action(str, Enum):
+    """Actions that can be taken when a rule matches."""
+
+    ALLOW = "allow"
+    DENY = "deny"
+    AUDIT = "audit"
+    ESCALATE = "escalate"
+
+
+class LifecycleHook(str, Enum):
+    """Agent lifecycle hooks where rules can be evaluated."""
+
+    BEFORE_AGENT = "before_agent"
+    AFTER_AGENT = "after_agent"
+    BEFORE_MODEL = "before_model"
+    AFTER_MODEL = "after_model"
+    TOOL_CALL = "tool_call"
+    AFTER_TOOL = "after_tool"
+
+
+class EnforcementMode(str, Enum):
+    """Governance enforcement modes."""
+
+    AUDIT = "audit"  # Evaluate and log; never block.
+    ENFORCE = "enforce"  # Block on DENY rules.
+    DISABLED = "disabled"  # Skip evaluation entirely.
+
+
+@dataclass
+class RuleEvaluation:
+    """Result of evaluating a single rule."""
+
+    rule_id: str
+    rule_name: str
+    matched: bool
+    detail: str = ""
+    pack_name: str = ""
+    action: Action = Action.ALLOW
+    description: str = ""
+    check_results: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class AuditRecord:
+    """Complete audit record for a governance evaluation."""
+
+    timestamp: datetime
+    agent_name: str
+    runtime_id: str
+    trace_id: str
+    hook: LifecycleHook
+    evaluations: list[RuleEvaluation]
+    final_action: Action
+    metadata: dict[str, Any] = field(default_factory=dict)
+    rules_matched: int = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Derive rules_matched from the evaluations list."""
+        self.rules_matched = sum(1 for e in self.evaluations if e.matched)
diff --git a/packages/uipath-core/src/uipath/core/governance/providers.py b/packages/uipath-core/src/uipath/core/governance/providers.py
new file mode 100644
index 000000000..29f435edb
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/governance/providers.py
@@ -0,0 +1,153 @@
+"""Provider protocols for governance backend interactions.
+
+The runtime needs two backend interactions to function:
+
+- Fetching the policy pack at startup.
+- Firing the compensating ``/runtime/govern`` POST when a
+  ``guardrail_fallback`` rule matches so the server can run the disabled
+  centralised guardrail and write the per-rule LLMOps audit records.
+
+Both have wire formats owned by the ``agenticgovernance_`` ingress.
+Defining the contracts here — alongside :class:`EvaluatorProtocol` —
+lets runtime consumers depend on stable protocols and receive a
+concrete provider via constructor injection. Concrete providers live
+outside this package; ``uipath-core`` does not import them.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from .models import EnforcementMode
+
+# ----------------------------------------------------------------------
+# Wire-format models
+# ----------------------------------------------------------------------
+
+
+class PolicyContext(BaseModel):
+    """Caller-supplied selectors for the policy fetch.
+
+    Wrapping the selectors in a model keeps the protocol surface stable
+    when the server grows new selector dimensions — adding a field here
+    doesn't change :meth:`GovernancePolicyProvider.get_policy`.
+
+    Today carries only :attr:`is_conversational`; future selectors land
+    here.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    is_conversational: bool | None = None
+
+
+class PolicyResponse(BaseModel):
+    """Parsed governance backend response.
+
+    Wire envelope::
+
+        {
+            "mode": "audit" | "enforce" | "disabled",
+            "policies": "<YAML string>"
+        }
+
+    Attributes:
+        mode: Platform-controlled enforcement mode for the tenant. May
+            be ``None`` when the backend omits it. A wire value the SDK
+            doesn't know about parses as ``None`` rather than raising,
+            so a server-side mode addition can't break agent startup.
+        policies: Policy pack YAML the caller compiles into its policy
+            index. May be an empty string when no rules are configured.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    mode: EnforcementMode | None = Field(default=None)
+    policies: str = Field(default="")
+
+    @field_validator("mode", mode="before")
+    @classmethod
+    def _coerce_mode(cls, value: object) -> EnforcementMode | None:
+        if value is None or isinstance(value, EnforcementMode):
+            return value
+        try:
+            return EnforcementMode(value)
+        except ValueError:
+            return None
+
+
+class FiredRule(BaseModel):
+    """Per-rule metadata carried in the ``/runtime/govern`` payload.
+
+    One entry per matching ``guardrail_fallback`` condition. The server
+    writes one LLMOps trace record per entry, so callers must include
+    every fired rule even when multiple share the same ``validator``.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    rule_id: str = Field(alias="ruleId")
+    rule_name: str = Field(alias="ruleName")
+    pack_name: str = Field(alias="packName")
+    validator: str
+
+
+class GovernRequest(BaseModel):
+    """Request body for the ``/runtime/govern`` compensating governance POST.
+
+    Field aliases match the on-the-wire JSON keys. ``src_timestamp`` is
+    snake_case on the wire (intentional — preserved verbatim); every
+    other key is camelCase.
+
+    Job-context fields (``folder_key`` / ``job_key`` / ``process_key`` /
+    ``reference_id`` / ``agent_version``) are optional; callers omit
+    them by leaving them ``None``. How unset fields are resolved (e.g.
+    auto-filled from environment) is the concrete provider's concern,
+    not part of this wire contract.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    validators: list[str] = Field(alias="type")
+    rules: list[FiredRule]
+    data: dict[str, Any]
+    hook: str
+    trace_id: str = Field(alias="traceId")
+    src_timestamp: str  # wire key is intentionally snake_case
+    agent_name: str = Field(alias="agentName")
+    runtime_id: str = Field(alias="runtimeId")
+
+    folder_key: str | None = Field(default=None, alias="folderKey")
+    job_key: str | None = Field(default=None, alias="jobKey")
+    process_key: str | None = Field(default=None, alias="processKey")
+    reference_id: str | None = Field(default=None, alias="referenceId")
+    agent_version: str | None = Field(default=None, alias="agentVersion")
+
+
+# ----------------------------------------------------------------------
+# Provider protocols
+# ----------------------------------------------------------------------
+
+
+@runtime_checkable
+class GovernancePolicyProvider(Protocol):
+    """Contract for fetching the governance policy pack.
+
+    Any object exposing a ``get_policy(context) -> PolicyResponse``
+    method satisfies this protocol.
+    """
+
+    def get_policy(self, context: PolicyContext) -> PolicyResponse:
+        """Fetch the policy pack for the active org/tenant."""
+        ...
+
+
+@runtime_checkable
+class GovernanceCompensationProvider(Protocol):
+    """Contract for firing the compensating ``/runtime/govern`` POST."""
+
+    def compensate(self, request: GovernRequest) -> None:
+        """Fire the compensating governance POST. Fire-and-forget."""
+        ...
diff --git a/packages/uipath-core/src/uipath/core/guardrails/__init__.py b/packages/uipath-core/src/uipath/core/guardrails/__init__.py
new file mode 100644
index 000000000..4ade20740
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/guardrails/__init__.py
@@ -0,0 +1,48 @@
+"""UiPath Guardrails Models.
+
+This module contains models related to UiPath Guardrails.
+"""
+
+from ._deterministic_guardrails_service import DeterministicGuardrailsService
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BaseGuardrail,
+    BooleanRule,
+    DeterministicGuardrail,
+    FieldReference,
+    FieldSelector,
+    FieldSource,
+    GuardrailScope,
+    GuardrailSelector,
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+    NumberRule,
+    Rule,
+    SelectorType,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+__all__ = [
+    "DeterministicGuardrailsService",
+    "FieldSource",
+    "ApplyTo",
+    "FieldReference",
+    "SelectorType",
+    "AllFieldsSelector",
+    "SpecificFieldsSelector",
+    "FieldSelector",
+    "BaseGuardrail",
+    "DeterministicGuardrail",
+    "WordRule",
+    "NumberRule",
+    "BooleanRule",
+    "UniversalRule",
+    "Rule",
+    "GuardrailScope",
+    "GuardrailSelector",
+    "GuardrailValidationResult",
+    "GuardrailValidationResultType",
+]
diff --git a/packages/uipath-core/src/uipath/core/guardrails/_deterministic_guardrails_service.py b/packages/uipath-core/src/uipath/core/guardrails/_deterministic_guardrails_service.py
new file mode 100644
index 000000000..27be4996b
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/guardrails/_deterministic_guardrails_service.py
@@ -0,0 +1,161 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from ..tracing.decorators import traced
+from ._evaluators import (
+    evaluate_boolean_rule,
+    evaluate_number_rule,
+    evaluate_universal_rule,
+    evaluate_word_rule,
+)
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    DeterministicGuardrail,
+    FieldSource,
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+class DeterministicGuardrailsService(BaseModel):
+    @traced("evaluate_pre_deterministic_guardrail", run_type="uipath")
+    def evaluate_pre_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input data (pre-execution)."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(guardrail, [ApplyTo.OUTPUT])
+
+        # If guardrail has output-dependent rules, skip evaluation in pre-execution
+        # Output rules will be evaluated during post-execution
+        if has_output_rule:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.PASSED,
+                reason="No rules to apply for input data.",
+            )
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data={},
+            guardrail=guardrail,
+        )
+
+    @traced("evaluate_post_deterministic_guardrails", run_type="uipath")
+    def evaluate_post_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(
+            guardrail, [ApplyTo.OUTPUT, ApplyTo.INPUT_AND_OUTPUT]
+        )
+
+        # If guardrail has no output-dependent rules, skip post-execution evaluation
+        # Only input rules exist and they should have been evaluated during pre-execution
+        if not has_output_rule:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.PASSED,
+                reason="No rules to apply for output data.",
+            )
+
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+    @staticmethod
+    def _has_output_dependent_rule(
+        guardrail: DeterministicGuardrail,
+        universal_rules_apply_to_values: list[ApplyTo],
+    ) -> bool:
+        """Check if at least one rule EXCLUSIVELY requires output data.
+
+        Args:
+            guardrail: The guardrail to check
+            universal_rules_apply_to_values: List of ApplyTo values to consider as output-dependent for UniversalRules.
+
+        Returns:
+            True if at least one rule exclusively depends on output data, False otherwise.
+        """
+        for rule in guardrail.rules:
+            # UniversalRule: only return True if it applies to values in universal_rules_apply_to_values
+            if isinstance(rule, UniversalRule):
+                if rule.apply_to in universal_rules_apply_to_values:
+                    return True
+            # Rules with field_selector
+            elif isinstance(rule, (WordRule, NumberRule, BooleanRule)):
+                field_selector = rule.field_selector
+                # AllFieldsSelector applies to both input and output, not exclusively output
+                # SpecificFieldsSelector: only return True if at least one field has OUTPUT source
+                if isinstance(field_selector, SpecificFieldsSelector):
+                    if field_selector.fields and any(
+                        field.source == FieldSource.OUTPUT
+                        for field in field_selector.fields
+                    ):
+                        return True
+                elif isinstance(field_selector, AllFieldsSelector):
+                    if FieldSource.OUTPUT in field_selector.sources:
+                        return True
+
+        return False
+
+    @staticmethod
+    def _evaluate_deterministic_guardrail(
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data.
+
+        Validation fails only if ALL guardrail rules are violated.
+        """
+        validated_conditions: list[str] = []
+
+        for rule in guardrail.rules:
+            if isinstance(rule, WordRule):
+                passed, reason = evaluate_word_rule(rule, input_data, output_data)
+            elif isinstance(rule, NumberRule):
+                passed, reason = evaluate_number_rule(rule, input_data, output_data)
+            elif isinstance(rule, BooleanRule):
+                passed, reason = evaluate_boolean_rule(rule, input_data, output_data)
+            elif isinstance(rule, UniversalRule):
+                passed, reason = evaluate_universal_rule(rule, output_data)
+            else:
+                return GuardrailValidationResult(
+                    result=GuardrailValidationResultType.VALIDATION_FAILED,
+                    reason=f"Unknown rule type: {type(rule)}",
+                )
+            validated_conditions.append(reason)
+            if passed:
+                return GuardrailValidationResult(
+                    result=GuardrailValidationResultType.PASSED,
+                    reason=reason,
+                )
+
+        has_always_rule = any(
+            condition == "Always rule enforced" for condition in validated_conditions
+        )
+
+        validated_conditions_str = ", ".join(validated_conditions)
+        final_reason = (
+            "Always rule enforced"
+            if has_always_rule
+            else f"Data matched all guardrail conditions: [{validated_conditions_str}]"
+        )
+
+        return GuardrailValidationResult(
+            result=GuardrailValidationResultType.VALIDATION_FAILED,
+            reason=final_reason,
+        )
diff --git a/packages/uipath-core/src/uipath/core/guardrails/_evaluators.py b/packages/uipath-core/src/uipath/core/guardrails/_evaluators.py
new file mode 100644
index 000000000..51c90413c
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/guardrails/_evaluators.py
@@ -0,0 +1,453 @@
+"""Guardrail rule evaluators.
+
+This module provides functions for evaluating different types of guardrail rules
+against input and output data.
+"""
+
+import inspect
+from enum import IntEnum
+from typing import Any, Callable
+
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    FieldReference,
+    FieldSource,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+class ArrayDepth(IntEnum):
+    """Array depth enumeration for path parsing."""
+
+    NONE = 0  # Not an array
+    SINGLE = 1  # Single array [*]
+    MATRIX = 2  # Matrix [*][*]
+
+
+def extract_field_value(path: str, data: dict[str, Any]) -> list[Any]:
+    """Extract field values from data using dot-notation path.
+
+    Supports array notation with [*] and [*][*] for arrays and matrices.
+    If an array is encountered at any point in the path, all elements are checked.
+    """
+    if not isinstance(data, dict):
+        return []
+
+    results: list[Any] = []
+
+    def _parse_path_segment(segment: str) -> tuple[str, ArrayDepth]:
+        """Parse a path segment to extract field name and array depth."""
+        if "[*][*]" in segment:
+            field_name = segment.replace("[*][*]", "")
+            return field_name, ArrayDepth.MATRIX
+        elif "[*]" in segment:
+            field_name = segment.replace("[*]", "")
+            return field_name, ArrayDepth.SINGLE
+        else:
+            return segment, ArrayDepth.NONE
+
+    def _traverse(current: Any, remaining_parts: list[str]) -> None:
+        """Recursively traverse the path, handling arrays and matrices."""
+        if not remaining_parts:
+            # End of path, add current value
+            if current is not None:
+                if isinstance(current, list):
+                    # If current is a list, add all elements
+                    results.extend(current)
+                else:
+                    results.append(current)
+            return
+
+        part = remaining_parts[0]
+        next_parts = remaining_parts[1:]
+        field_name, array_depth = _parse_path_segment(part)
+
+        if isinstance(current, dict):
+            if not field_name and array_depth != ArrayDepth.NONE:
+                # Path segment is purely array notation (e.g. [*]) with no
+                # field name.  This happens when the root data is a
+                # dict-wrapped array (e.g. {"output": [...]}) and the
+                # original path starts with [*].  Iterate over all list
+                # values in the dict so the array elements are reached.
+                for value in current.values():
+                    if isinstance(value, list):
+                        if array_depth == ArrayDepth.MATRIX:
+                            for row in value:
+                                if isinstance(row, list):
+                                    for item in row:
+                                        _traverse(item, next_parts)
+                                else:
+                                    _traverse(row, next_parts)
+                        else:  # SINGLE
+                            for item in value:
+                                _traverse(item, next_parts)
+                return
+
+            if field_name not in current:
+                return
+            next_value = current.get(field_name)
+
+            if array_depth == ArrayDepth.MATRIX:
+                # Matrix [*][*] - expect 2D array
+                if isinstance(next_value, list):
+                    for row in next_value:
+                        if isinstance(row, list):
+                            for item in row:
+                                _traverse(item, next_parts)
+                        else:
+                            # Not a 2D array, treat as 1D
+                            _traverse(row, next_parts)
+            elif array_depth == ArrayDepth.SINGLE:
+                # Array [*] - expect 1D array
+                if isinstance(next_value, list):
+                    for item in next_value:
+                        _traverse(item, next_parts)
+                else:
+                    # Not an array, but path expects one - continue traversal
+                    _traverse(next_value, next_parts)
+            else:
+                # No array notation, continue traversal
+                if isinstance(next_value, list):
+                    # Array encountered without notation - check all elements
+                    for item in next_value:
+                        _traverse(item, next_parts)
+                else:
+                    _traverse(next_value, next_parts)
+        elif isinstance(current, list):
+            # Current is an array - check all elements
+            for item in current:
+                _traverse(item, remaining_parts)
+        else:
+            # Cannot traverse further
+            return
+
+    path_parts = path.split(".")
+    _traverse(data, path_parts)
+    return results
+
+
+def get_fields_from_selector(
+    field_selector: AllFieldsSelector | SpecificFieldsSelector,
+    input_data: dict[str, Any],
+    output_data: dict[str, Any],
+) -> list[tuple[Any, FieldReference]]:
+    """Get field values and their references based on the field selector."""
+    fields: list[tuple[Any, FieldReference]] = []
+
+    if isinstance(field_selector, AllFieldsSelector):
+        # For "all" selector, we need to collect all fields from the specified sources
+        # This is a simplified implementation - in practice, you might want to
+        # recursively collect all nested fields
+        if FieldSource.INPUT in field_selector.sources:
+            for key, value in input_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.INPUT),
+                    )
+                )
+        if FieldSource.OUTPUT in field_selector.sources:
+            for key, value in output_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.OUTPUT),
+                    )
+                )
+    elif isinstance(field_selector, SpecificFieldsSelector):
+        # For specific fields, extract values based on field references
+        for field_ref in field_selector.fields:
+            # Use FieldSource to determine whether to use input_data or output_data
+            if field_ref.source == FieldSource.INPUT:
+                data = input_data
+            elif field_ref.source == FieldSource.OUTPUT:
+                data = output_data
+            else:
+                # Unknown source, skip this field
+                continue
+            # Extract values (may return multiple if arrays are in the path)
+            values = extract_field_value(field_ref.path, data)
+            # Add each value as a separate field reference
+            for value in values:
+                fields.append((value, field_ref))
+
+    return fields
+
+
+def format_guardrail_passed_validation_result_message(
+    field_ref: FieldReference,
+    operator: str | None,
+    rule_description: str | None,
+) -> str:
+    """Format a guardrail validation result message following the standard pattern."""
+    source = "Input" if field_ref.source == FieldSource.INPUT else "Output"
+
+    if rule_description:
+        return (
+            f"{source} data didn't match the guardrail condition for field "
+            f"[{field_ref.path}]: {rule_description}"
+        )
+
+    return (
+        f"{source} data didn't match the guardrail condition: "
+        f"[{field_ref.path}] comparing function [{operator}]"
+    )
+
+
+def get_validated_conditions_description(
+    field_path: str,
+    operator: str | None,
+    rule_description: str | None,
+) -> str:
+    if rule_description:
+        return rule_description
+
+    return f"[{field_path}] comparing function [{operator}]"
+
+
+def evaluate_word_rule(
+    rule: WordRule, input_data: dict[str, Any], output_data: dict[str, Any]
+) -> tuple[bool, str]:
+    """Evaluate a word rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
+    operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
+    field_paths = ", ".join({field_ref.path for _, field_ref in fields})
+
+    for field_value, field_ref in fields:
+        if field_value is None:
+            continue
+
+        # Word rules should only be applied to string values
+        # Skip non-string values (numbers, booleans, objects, arrays, etc.)
+        if not isinstance(field_value, str):
+            continue
+
+        field_str = field_value
+
+        # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
+        try:
+            violation_detected = rule.detects_violation(field_str)
+        except Exception:
+            # If function raises an exception, treat as failure
+            violation_detected = True
+
+        if not violation_detected:
+            reason = format_guardrail_passed_validation_result_message(
+                field_ref=field_ref,
+                operator=operator,
+                rule_description=rule.rule_description,
+            )
+            return True, reason
+
+    return False, get_validated_conditions_description(
+        field_path=field_paths,
+        operator=operator,
+        rule_description=rule.rule_description,
+    )
+
+
+def evaluate_number_rule(
+    rule: NumberRule, input_data: dict[str, Any], output_data: dict[str, Any]
+) -> tuple[bool, str]:
+    """Evaluate a number rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
+    operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
+    field_paths = ", ".join({field_ref.path for _, field_ref in fields})
+    for field_value, field_ref in fields:
+        if field_value is None:
+            continue
+
+        # Number rules should only be applied to numeric values
+        # Skip non-numeric values (strings, booleans, objects, arrays, etc.)
+        # Note: bool is a subclass of int in Python, so we must check for bool first
+        if isinstance(field_value, bool) or not isinstance(field_value, (int, float)):
+            continue
+
+        field_num = float(field_value)
+
+        # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
+        try:
+            violation_detected = rule.detects_violation(field_num)
+        except Exception:
+            # If function raises an exception, treat as failure
+            violation_detected = True
+
+        if not violation_detected:
+            reason = format_guardrail_passed_validation_result_message(
+                field_ref=field_ref,
+                operator=operator,
+                rule_description=rule.rule_description,
+            )
+            return True, reason
+
+    return False, get_validated_conditions_description(
+        field_path=field_paths,
+        operator=operator,
+        rule_description=rule.rule_description,
+    )
+
+
+def evaluate_boolean_rule(
+    rule: BooleanRule,
+    input_data: dict[str, Any],
+    output_data: dict[str, Any],
+) -> tuple[bool, str]:
+    """Evaluate a boolean rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
+    operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
+    field_paths = ", ".join({field_ref.path for _, field_ref in fields})
+    for field_value, field_ref in fields:
+        if field_value is None:
+            continue
+
+        # Boolean rules should only be applied to boolean values
+        # Skip non-boolean values (strings, numbers, objects, arrays, etc.)
+        if not isinstance(field_value, bool):
+            continue
+
+        field_bool = field_value
+
+        # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
+        try:
+            violation_detected = rule.detects_violation(field_bool)
+        except Exception:
+            # If function raises an exception, treat as failure
+            violation_detected = True
+
+        if not violation_detected:
+            reason = format_guardrail_passed_validation_result_message(
+                field_ref=field_ref,
+                operator=operator,
+                rule_description=rule.rule_description,
+            )
+            return True, reason
+
+    return False, get_validated_conditions_description(
+        field_path=field_paths,
+        operator=operator,
+        rule_description=rule.rule_description,
+    )
+
+
+def evaluate_universal_rule(
+    rule: UniversalRule,
+    output_data: dict[str, Any],
+) -> tuple[bool, str]:
+    """Evaluate a universal rule against input and output data.
+
+    Universal rules trigger based on the apply_to scope and execution phase:
+    - Pre-execution (empty output_data):
+      - INPUT: triggers (result = VALIDATION_FAILED)
+      - OUTPUT: does not trigger (result = PASSED)
+      - INPUT_AND_OUTPUT: triggers (result = VALIDATION_FAILED)
+    - Post-execution (output_data has data):
+      - INPUT: does not trigger (result = PASSED)
+      - OUTPUT: triggers (result = VALIDATION_FAILED)
+      - INPUT_AND_OUTPUT: triggers (result = VALIDATION_FAILED)
+    """
+    # Determine if this is pre-execution (no output data) or post-execution
+    is_pre_execution = not output_data or len(output_data) == 0
+
+    if rule.apply_to == ApplyTo.INPUT:
+        # INPUT: triggers in pre-execution, does not trigger in post-execution
+        if is_pre_execution:
+            return False, "Always rule enforced"
+        else:
+            return True, "No rules to apply for output data"
+    elif rule.apply_to == ApplyTo.OUTPUT:
+        # OUTPUT: does not trigger in pre-execution, triggers in post-execution
+        if is_pre_execution:
+            return True, "No rules to apply for input data"
+        else:
+            return False, "Always rule enforced"
+    elif rule.apply_to == ApplyTo.INPUT_AND_OUTPUT:
+        # INPUT_AND_OUTPUT: triggers in both phases
+        return False, "Always rule enforced"
+    else:
+        return False, f"Unknown apply_to value: {rule.apply_to}"
+
+
+def _humanize_guardrail_func(func: Callable[..., Any] | str | None) -> str | None:
+    """Build a user-friendly description of a guardrail predicate.
+
+    Deterministic guardrails store Python callables (often lambdas) to evaluate
+    conditions. For diagnostics, it's useful to include a readable hint about the
+    predicate that failed.
+
+    Args:
+        func: A Python callable used as a predicate, or a pre-rendered string
+            description (for example, ``"s:str -> bool: contains 'test'"``).
+
+    Returns:
+        A human-readable description, or ``None`` if one cannot be produced.
+    """
+    if func is None:
+        return None
+
+    if isinstance(func, str):
+        rendered = func.strip()
+        return rendered or None
+
+    name = getattr(func, "__name__", None)
+    if name and name != "<lambda>":
+        return name
+
+    # Best-effort extraction for lambdas / callables.
+    try:
+        sig = str(inspect.signature(func))
+    except (TypeError, ValueError):
+        sig = ""
+
+    try:
+        source_lines = inspect.getsourcelines(func)
+        source = "".join(source_lines[0]).strip()
+        # Collapse whitespace to keep the message compact.
+        source = " ".join(source.split())
+
+        # Remove "detects_violation=lambda" prefix if present
+        # Pattern: "detects_violation=lambda s: condition" -> "condition"
+        if "detects_violation=lambda" in source:
+            # Find the lambda part
+            lambda_start = source.find("detects_violation=lambda")
+            if lambda_start != -1:
+                # Get everything after "detects_violation=lambda"
+                lambda_part = source[
+                    lambda_start + len("detects_violation=lambda") :
+                ].strip()
+                # Find the colon that separates param from body
+                colon_idx = lambda_part.find(":")
+                if colon_idx != -1:
+                    # Extract just the body (condition)
+                    body = lambda_part[colon_idx + 1 :].strip()
+                    # Remove trailing comma if present
+                    body = body.rstrip(",").strip()
+                    source = body
+    except (OSError, TypeError):
+        source = ""
+
+    if source and sig:
+        return f"{sig}: {source}"
+    if source:
+        return source
+    if sig:
+        return sig
+
+    rendered = repr(func).strip()
+    return rendered or None
diff --git a/packages/uipath-core/src/uipath/core/guardrails/guardrails.py b/packages/uipath-core/src/uipath/core/guardrails/guardrails.py
new file mode 100644
index 000000000..576cc437a
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/guardrails/guardrails.py
@@ -0,0 +1,248 @@
+"""Guardrails models for UiPath Platform."""
+
+from enum import Enum
+from typing import Annotated, Any, Callable, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+def _decapitalize_first_letter(s: str) -> str:
+    """Convert first letter to lowercase (e.g., 'SimpleText' -> 'simpleText')."""
+    if not s or len(s) == 0:
+        return s
+    if len(s) == 1:
+        return s.lower()
+    return s[0].lower() + s[1:]
+
+
+class GuardrailValidationResultType(str, Enum):
+    """Guardrail validation result type enumeration."""
+
+    PASSED = "passed"
+    VALIDATION_FAILED = "validation_failed"
+    ENTITLEMENTS_MISSING = "entitlements_missing"
+    FEATURE_DISABLED = "feature_disabled"
+
+
+class GuardrailValidationResult(BaseModel):
+    """Result returned from validating input with a given guardrail.
+
+    Attributes:
+        result: The validation result type.
+        reason: Textual explanation describing why the validation passed or failed.
+        span_id: Span ID from the guardrail service response, formatted as a GUID
+            for trace correlation. None when the response omits the header.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    result: GuardrailValidationResultType = Field(
+        alias="result", description="Validation result."
+    )
+    reason: str = Field(
+        alias="reason", description="Explanation for the validation result."
+    )
+    span_id: Optional[str] = Field(
+        default=None,
+        alias="spanId",
+        description="Span ID returned by the guardrail service for trace correlation.",
+    )
+
+
+class FieldSource(str, Enum):
+    """Field source enumeration."""
+
+    INPUT = "input"
+    OUTPUT = "output"
+
+
+class ApplyTo(str, Enum):
+    """Apply to enumeration."""
+
+    INPUT = "input"
+    INPUT_AND_OUTPUT = "inputAndOutput"
+    OUTPUT = "output"
+
+
+class FieldReference(BaseModel):
+    """Field reference model."""
+
+    path: str
+    source: FieldSource
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    @field_validator("source", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> Any:
+        """Normalize type by decapitalizing first letter."""
+        return _decapitalize_first_letter(v) if isinstance(v, str) else v
+
+
+class SelectorType(str, Enum):
+    """Selector type enumeration."""
+
+    ALL = "all"
+    SPECIFIC = "specific"
+
+
+class AllFieldsSelector(BaseModel):
+    """All fields selector."""
+
+    selector_type: Literal["all"] = Field(alias="$selectorType")
+    sources: list[FieldSource]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    @field_validator("sources", mode="before")
+    @classmethod
+    def normalize_sources(cls, v: Any) -> Any:
+        """Normalize sources by decapitalizing first letter of each item."""
+        if isinstance(v, list):
+            return [
+                _decapitalize_first_letter(item) if isinstance(item, str) else item
+                for item in v
+            ]
+        return v
+
+
+class SpecificFieldsSelector(BaseModel):
+    """Specific fields selector."""
+
+    selector_type: Literal["specific"] = Field(alias="$selectorType")
+    fields: list[FieldReference]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+FieldSelector = Annotated[
+    AllFieldsSelector | SpecificFieldsSelector,
+    Field(discriminator="selector_type"),
+]
+
+
+class RuleType(str, Enum):
+    """Rule type enumeration."""
+
+    BOOLEAN = "boolean"
+    NUMBER = "number"
+    UNIVERSAL = "always"
+    WORD = "word"
+
+
+class WordRule(BaseModel):
+    """Word rule model."""
+
+    rule_type: Literal["word"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    rule_description: str | None = Field(
+        default=None,
+        exclude=True,
+        description="Human-friendly description of the rule condition.",
+    )
+    detects_violation: Callable[[str], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the string violates the rule (validation should fail).",
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class UniversalRule(BaseModel):
+    """Universal rule model."""
+
+    rule_type: Literal["always"] = Field(alias="$ruleType")
+    apply_to: ApplyTo = Field(alias="applyTo")
+    rule_description: str | None = Field(
+        default=None,
+        exclude=True,
+        description="Human-friendly description of the rule condition.",
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    @field_validator("apply_to", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> Any:
+        """Normalize type by decapitalizing first letter."""
+        return _decapitalize_first_letter(v) if isinstance(v, str) else v
+
+
+class NumberRule(BaseModel):
+    """Number rule model."""
+
+    rule_type: Literal["number"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    rule_description: str | None = Field(
+        default=None,
+        exclude=True,
+        description="Human-friendly description of the rule condition.",
+    )
+    detects_violation: Callable[[float], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the number violates the rule (validation should fail).",
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BooleanRule(BaseModel):
+    """Boolean rule model."""
+
+    rule_type: Literal["boolean"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    rule_description: str | None = Field(
+        default=None,
+        exclude=True,
+        description="Human-friendly description of the rule condition.",
+    )
+    detects_violation: Callable[[bool], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the boolean violates the rule (validation should fail).",
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+Rule = Annotated[
+    WordRule | NumberRule | BooleanRule | UniversalRule,
+    Field(discriminator="rule_type"),
+]
+
+
+class GuardrailScope(str, Enum):
+    """Guardrail scope enumeration."""
+
+    AGENT = "Agent"
+    LLM = "Llm"
+    TOOL = "Tool"
+
+
+class GuardrailSelector(BaseModel):
+    """Guardrail selector model."""
+
+    scopes: list[GuardrailScope] = Field(default=[GuardrailScope.TOOL])
+    match_names: list[str] | None = Field(None, alias="matchNames")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BaseGuardrail(BaseModel):
+    """Base guardrail model."""
+
+    id: str
+    name: str
+    description: str | None = None
+    enabled_for_evals: bool = Field(True, alias="enabledForEvals")
+    selector: GuardrailSelector | None = None
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class DeterministicGuardrail(BaseGuardrail):
+    """Deterministic guardrail model."""
+
+    guardrail_type: Literal["custom"] = Field(alias="$guardrailType")
+    rules: list[Rule]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
diff --git a/py.typed b/packages/uipath-core/src/uipath/core/py.typed
similarity index 100%
rename from py.typed
rename to packages/uipath-core/src/uipath/core/py.typed
diff --git a/packages/uipath-core/src/uipath/core/serialization/__init__.py b/packages/uipath-core/src/uipath/core/serialization/__init__.py
new file mode 100644
index 000000000..9296b1074
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/serialization/__init__.py
@@ -0,0 +1,5 @@
+"""Serialization utilities for converting Python objects to various formats."""
+
+from .json import serialize_defaults, serialize_json, serialize_object
+
+__all__ = ["serialize_defaults", "serialize_json", "serialize_object"]
diff --git a/packages/uipath-core/src/uipath/core/serialization/json.py b/packages/uipath-core/src/uipath/core/serialization/json.py
new file mode 100644
index 000000000..cdc63fcd4
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/serialization/json.py
@@ -0,0 +1,205 @@
+"""JSON serialization utilities for converting Python objects to JSON formats."""
+
+import json
+import uuid
+from dataclasses import asdict, is_dataclass
+from datetime import date, datetime, time, timezone
+from enum import Enum
+from typing import Any, cast
+from zoneinfo import ZoneInfo
+
+from pydantic import BaseModel
+
+
+def serialize_defaults(
+    obj: Any,
+) -> dict[str, Any] | list[Any] | str | int | float | bool | None:
+    """Convert Python objects to JSON-serializable formats.
+
+    Handles common Python types that are not natively JSON-serializable:
+    - Pydantic models (v1 and v2)
+    - Dataclasses
+    - Enums
+    - Datetime objects
+    - Timezone objects
+    - Named tuples
+    - Sets and tuples
+
+    This function is designed to be used as the `default` parameter in json.dumps():
+    ```python
+    import json
+    result = json.dumps(obj, default=serialize_defaults)
+    ```
+
+    Or use the convenience function `serialize_json()` which wraps this:
+    ```python
+    result = serialize_json(obj)
+    ```
+
+    Args:
+        obj: The object to serialize
+
+    Returns:
+        A JSON-serializable representation of the object:
+        - Pydantic models: dict from model_dump()
+        - Dataclasses: dict from asdict()
+        - Enums: the enum value (recursively serialized)
+        - datetime: ISO format string
+        - timezone/ZoneInfo: timezone name
+        - sets/tuples: converted to lists
+        - named tuples: converted to dict
+        - Primitives (None, bool, int, float, str, list, dict): returned unchanged
+        - Other types: converted to string with str()
+
+    Examples:
+        >>> from datetime import datetime
+        >>> from pydantic import BaseModel
+        >>>
+        >>> class User(BaseModel):
+        ...     name: str
+        ...     created_at: datetime
+        >>>
+        >>> user = User(name="Alice", created_at=datetime.now())
+        >>> import json
+        >>> json.dumps(user, default=serialize_defaults)
+        '{"name": "Alice", "created_at": "2024-01-01T12:00:00"}'
+        >>> # Or use the convenience function
+        >>> serialize_json(user)
+        '{"name": "Alice", "created_at": "2024-01-01T12:00:00"}'
+    """
+    try:
+        return _serialize_defaults_inner(obj)
+    except Exception:
+        return str(obj)
+
+
+def _serialize_defaults_inner(
+    obj: Any,
+) -> dict[str, Any] | list[Any] | str | int | float | bool | None:
+    # Handle Pydantic BaseModel instances
+    if hasattr(obj, "model_dump") and not isinstance(obj, type):
+        return obj.model_dump(exclude_none=True, mode="json")
+
+    # Handle Pydantic model classes - convert to schema representation
+    if isinstance(obj, type) and issubclass(obj, BaseModel):
+        return {
+            "__class__": obj.__name__,
+            "__module__": obj.__module__,
+            "schema": obj.model_json_schema(),
+        }
+
+    # Handle Pydantic v1 models
+    if hasattr(obj, "dict") and not isinstance(obj, type):
+        return obj.dict()
+
+    # Handle objects with to_dict method
+    if hasattr(obj, "to_dict") and not isinstance(obj, type):
+        return obj.to_dict()
+
+    # Handle objects with as_dict property (UiPathBaseRuntimeError)
+    if hasattr(obj, "as_dict") and not isinstance(obj, type):
+        return obj.as_dict
+
+    # Handle dataclasses
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return asdict(obj)
+
+    # Handle enums - recursively serialize the value
+    if isinstance(obj, Enum):
+        return _serialize_defaults_inner(obj.value)
+
+    # Handle sets and tuples
+    if isinstance(obj, (set, tuple)):
+        # Check if it's a named tuple (has _asdict method)
+        if hasattr(obj, "_asdict") and callable(
+            obj._asdict  # pyright: ignore[reportAttributeAccessIssue]
+        ):
+            return cast(
+                dict[str, Any],
+                obj._asdict(),  # pyright: ignore[reportAttributeAccessIssue]
+            )
+        # Convert to list
+        return list(obj)
+
+    # Handle exceptions
+    if isinstance(obj, Exception):
+        return str(obj)
+
+    # Handle datetime objects
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+
+    # Handle timezone objects
+    if isinstance(obj, (timezone, ZoneInfo)):
+        return obj.tzname(None)
+
+    # Allow JSON-serializable primitives to pass through unchanged
+    if obj is None or isinstance(obj, (bool, int, float, str, list, dict)):
+        return obj
+
+    # Fallback: convert to string
+    return str(obj)
+
+
+def serialize_json(obj: Any) -> str:
+    """Serialize Python object to JSON string.
+
+    This is a convenience function that wraps json.dumps() with serialize_defaults()
+    as the default handler for non-JSON-serializable types.
+
+    Args:
+        obj: The object to serialize to JSON
+
+    Returns:
+        JSON string representation of the object
+
+    Examples:
+        >>> from datetime import datetime
+        >>> from pydantic import BaseModel
+        >>>
+        >>> class Task(BaseModel):
+        ...     name: str
+        ...     created: datetime
+        >>>
+        >>> task = Task(name="Review PR", created=datetime(2024, 1, 15, 10, 30))
+        >>> serialize_json(task)
+        '{"name": "Review PR", "created": "2024-01-15T10:30:00"}'
+    """
+    return json.dumps(obj, default=serialize_defaults)
+
+
+def serialize_object(obj):
+    """Recursively serializes an object and all its nested components."""
+    # Handle Pydantic models
+    if hasattr(obj, "model_dump"):
+        return serialize_object(obj.model_dump(by_alias=True))
+    elif hasattr(obj, "dict"):
+        return serialize_object(obj.dict())
+    elif hasattr(obj, "to_dict"):
+        return serialize_object(obj.to_dict())
+    # Special handling for UiPathBaseRuntimeErrors
+    elif hasattr(obj, "as_dict"):
+        return serialize_object(obj.as_dict)
+    elif isinstance(obj, (datetime, date, time)):
+        return obj.isoformat()
+    # Handle dictionaries
+    elif isinstance(obj, dict):
+        return {k: serialize_object(v) for k, v in obj.items()}
+    # Handle lists
+    elif isinstance(obj, list):
+        return [serialize_object(item) for item in obj]
+    # Handle exceptions
+    elif isinstance(obj, Exception):
+        return str(obj)
+    # Handle other iterable objects (convert to dict first)
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
+        try:
+            return serialize_object(dict(obj))
+        except (TypeError, ValueError):
+            return obj
+    # UUIDs must be serialized explicitly
+    elif isinstance(obj, uuid.UUID):
+        return str(obj)
+    # Return primitive types as is
+    else:
+        return obj
diff --git a/packages/uipath-core/src/uipath/core/tracing/__init__.py b/packages/uipath-core/src/uipath/core/tracing/__init__.py
new file mode 100644
index 000000000..af6d3c2e1
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/__init__.py
@@ -0,0 +1,17 @@
+"""OpenTelemetry tracing module with UiPath integration.
+
+This module provides decorators and utilities for instrumenting Python functions
+with OpenTelemetry tracing, including custom processors for UiPath execution tracking.
+"""
+
+from uipath.core.tracing.decorators import traced
+from uipath.core.tracing.span_utils import UiPathSpanUtils
+from uipath.core.tracing.trace_manager import UiPathTraceManager
+from uipath.core.tracing.types import UiPathTraceSettings
+
+__all__ = [
+    "traced",
+    "UiPathSpanUtils",
+    "UiPathTraceManager",
+    "UiPathTraceSettings",
+]
diff --git a/packages/uipath-core/src/uipath/core/tracing/_utils.py b/packages/uipath-core/src/uipath/core/tracing/_utils.py
new file mode 100644
index 000000000..841aa67d8
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/_utils.py
@@ -0,0 +1,142 @@
+"""Helper utilities for the tracing module."""
+
+import inspect
+import json
+from collections.abc import Callable
+from typing import Any, Mapping, Optional
+
+from opentelemetry.trace import Span
+
+from uipath.core.serialization import serialize_json
+
+
+def get_supported_params(
+    tracer_impl: Callable[..., Any],
+    params: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Extract the parameters supported by the tracer implementation."""
+    try:
+        sig = inspect.signature(tracer_impl)
+    except (TypeError, ValueError):
+        # If we can't inspect, pass all parameters and let the function handle it
+        return dict(params)
+
+    supported: dict[str, Any] = {}
+    for name, value in params.items():
+        if value is not None and name in sig.parameters:
+            supported[name] = value
+    return supported
+
+
+def format_args_for_trace_json(
+    signature: inspect.Signature, *args: Any, **kwargs: Any
+) -> str:
+    """Return a JSON string of inputs from the function signature."""
+    result = format_args_for_trace(signature, *args, **kwargs)
+    return serialize_json(result)
+
+
+def format_object_for_trace_json(
+    input_object: Any,
+) -> str:
+    """Return a JSON string of inputs from the function signature."""
+    return serialize_json(input_object)
+
+
+def format_args_for_trace(
+    signature: inspect.Signature, *args: Any, **kwargs: Any
+) -> dict[str, Any]:
+    try:
+        """Return a dictionary of inputs from the function signature."""
+        # Create a parameter mapping by partially binding the arguments
+
+        parameter_binding = signature.bind_partial(*args, **kwargs)
+
+        # Fill in default values for any unspecified parameters
+        parameter_binding.apply_defaults()
+
+        # Extract the input parameters, skipping special Python parameters
+        result = {}
+        for name, value in parameter_binding.arguments.items():
+            # Skip class and instance references
+            if name in ("self", "cls"):
+                continue
+
+            # Handle **kwargs parameters specially
+            param_info = signature.parameters.get(name)
+            if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
+                # Flatten nested kwargs directly into the result
+                if isinstance(value, dict):
+                    result.update(value)
+            else:
+                # Regular parameter
+                result[name] = value
+
+        return result
+    except Exception:
+        return {"args": args, "kwargs": kwargs}
+
+
+def set_span_input_attributes(
+    span: Span,
+    trace_name: str,
+    wrapped_func: Callable[..., Any],
+    args: Any,
+    kwargs: Any,
+    span_type: str,
+    run_type: Optional[str],
+    input_processor: Optional[Callable[..., Any]],
+) -> None:
+    """Set span attributes for metadata and inputs before function execution.
+
+    This should be called BEFORE the wrapped function executes to ensure
+    input context is captured even if the function raises an exception.
+
+    Args:
+        span: The OpenTelemetry span to set attributes on
+        trace_name: Name of the trace/span
+        wrapped_func: The function being traced
+        args: Positional arguments passed to the function
+        kwargs: Keyword arguments passed to the function
+        span_type: Span type categorization (set to "TOOL" for OpenInference tool calls)
+        run_type: Optional run type categorization
+        input_processor: Optional function to process inputs before recording
+    """
+    is_tool = span_type and span_type.upper() == "TOOL"
+    if is_tool:
+        span.set_attribute("openinference.span.kind", "TOOL")
+        span.set_attribute("tool.name", trace_name)
+        span.set_attribute("span_type", "TOOL")
+    else:
+        span.set_attribute("span_type", span_type)
+
+    if run_type is not None:
+        span.set_attribute("run_type", run_type)
+
+    inputs = format_args_for_trace_json(
+        inspect.signature(wrapped_func), *args, **kwargs
+    )
+    if input_processor:
+        processed_inputs = input_processor(json.loads(inputs))
+        inputs = json.dumps(processed_inputs, default=str)
+    span.set_attribute("input.mime_type", "application/json")
+    span.set_attribute("input.value", inputs)
+
+
+def set_span_output_attributes(
+    span: Span,
+    result: Any,
+    output_processor: Optional[Callable[..., Any]],
+) -> None:
+    """Set span attributes for outputs after function execution.
+
+    This should be called AFTER the wrapped function executes successfully.
+
+    Args:
+        span: The OpenTelemetry span to set attributes on
+        result: The result from the function execution
+        output_processor: Optional function to process outputs before recording
+    """
+    output = output_processor(result) if output_processor else result
+    span.set_attribute("output.value", format_object_for_trace_json(output))
+    span.set_attribute("output.mime_type", "application/json")
diff --git a/packages/uipath-core/src/uipath/core/tracing/decorators.py b/packages/uipath-core/src/uipath/core/tracing/decorators.py
new file mode 100644
index 000000000..b7204271a
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/decorators.py
@@ -0,0 +1,350 @@
+"""Tracing decorators for function instrumentation."""
+
+import inspect
+import logging
+import random
+from functools import wraps
+from typing import Any, Callable, Optional, overload
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.context import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.trace import SpanContext, TraceFlags
+from opentelemetry.trace.status import StatusCode
+
+from uipath.core.tracing._utils import (
+    get_supported_params,
+    set_span_input_attributes,
+    set_span_output_attributes,
+)
+from uipath.core.tracing.span_utils import (
+    ParentedNonRecordingSpan,
+    UiPathSpanUtils,
+    _span_registry,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _opentelemetry_traced(
+    name: Optional[str] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+    recording: bool = True,
+):
+    """Default tracer implementation using OpenTelemetry.
+
+    Args:
+        name: Optional name for the span
+        run_type: Optional string to categorize the run type
+        span_type: Optional string to categorize the span type. If set to "tool" or "TOOL",
+                   the function is treated as an OpenInference tool call with:
+                   - openinference.span.kind = "TOOL"
+                   - tool.name = function name
+                   - span_type = "TOOL"
+                   - input.value and output.value (already set by default)
+        input_processor: Optional function to process inputs before recording
+        output_processor: Optional function to process outputs before recording
+        recording: If False, span is not recorded
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        trace_name = name or func.__name__
+
+        def get_span():
+            ctx = UiPathSpanUtils.get_parent_context()
+            if not recording:
+                parent_context = trace.get_current_span(ctx).get_span_context()
+
+                # Create a valid but non-sampled trace context
+                # Generate a valid trace ID (not INVALID)
+                trace_id = random.getrandbits(128)
+                span_id = random.getrandbits(64)
+
+                non_sampled_context = SpanContext(
+                    trace_id=trace_id,
+                    span_id=span_id,
+                    is_remote=False,
+                    trace_flags=TraceFlags(0x00),  # NOT sampled
+                )
+                non_recording = ParentedNonRecordingSpan(
+                    non_sampled_context, parent=parent_context
+                )
+
+                # Make it active so children see it
+                span_cm = trace.use_span(non_recording)
+                span_cm.__enter__()
+
+                _span_registry.register_span(non_recording)
+
+                return span_cm, non_recording
+            else:
+                # Normal recording span
+                span_cm = trace.get_tracer(__name__).start_as_current_span(
+                    trace_name, context=ctx
+                )
+                span = span_cm.__enter__()
+                return span_cm, span
+
+        # --------- Sync wrapper ---------
+        @wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+                return func(*args, **kwargs)
+            span_cm, span = get_span()
+            try:
+                # Set input attributes BEFORE execution
+                set_span_input_attributes(
+                    span,
+                    trace_name=trace_name,
+                    wrapped_func=func,
+                    args=args,
+                    kwargs=kwargs,
+                    run_type=run_type,
+                    span_type=span_type or "function_call_sync",
+                    input_processor=input_processor,
+                )
+
+                # Execute the function
+                result = func(*args, **kwargs)
+
+                # Set output attributes AFTER execution
+                set_span_output_attributes(
+                    span,
+                    result=result,
+                    output_processor=output_processor,
+                )
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Async wrapper ---------
+        @wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+                return await func(*args, **kwargs)
+            span_cm, span = get_span()
+            try:
+                # Set input attributes BEFORE execution
+                set_span_input_attributes(
+                    span,
+                    trace_name=trace_name,
+                    wrapped_func=func,
+                    args=args,
+                    kwargs=kwargs,
+                    run_type=run_type,
+                    span_type=span_type or "function_call_async",
+                    input_processor=input_processor,
+                )
+
+                # Execute the function
+                result = await func(*args, **kwargs)
+
+                # Set output attributes AFTER execution
+                set_span_output_attributes(
+                    span,
+                    result=result,
+                    output_processor=output_processor,
+                )
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Generator wrapper ---------
+        @wraps(func)
+        def generator_wrapper(*args: Any, **kwargs: Any) -> Any:
+            if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+                for item in func(*args, **kwargs):
+                    yield item
+                return
+            span_cm, span = get_span()
+            try:
+                # Set input attributes BEFORE execution
+                set_span_input_attributes(
+                    span,
+                    trace_name=trace_name,
+                    wrapped_func=func,
+                    args=args,
+                    kwargs=kwargs,
+                    run_type=run_type,
+                    span_type=span_type or "function_call_generator_sync",
+                    input_processor=input_processor,
+                )
+
+                # Execute the generator and collect outputs
+                outputs = []
+                for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    span.add_event(f"Yielded: {item}")
+                    yield item
+
+                # Set output attributes AFTER execution
+                set_span_output_attributes(
+                    span,
+                    result=outputs,
+                    output_processor=output_processor,
+                )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        # --------- Async generator wrapper ---------
+        @wraps(func)
+        async def async_generator_wrapper(*args: Any, **kwargs: Any) -> Any:
+            if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+                async for item in func(*args, **kwargs):
+                    yield item
+                return
+            span_cm, span = get_span()
+            try:
+                # Set input attributes BEFORE execution
+                set_span_input_attributes(
+                    span,
+                    trace_name=trace_name,
+                    wrapped_func=func,
+                    args=args,
+                    kwargs=kwargs,
+                    run_type=run_type,
+                    span_type=span_type or "function_call_generator_async",
+                    input_processor=input_processor,
+                )
+
+                # Execute the generator and collect outputs
+                outputs = []
+                async for item in func(*args, **kwargs):
+                    outputs.append(item)
+                    span.add_event(f"Yielded: {item}")
+                    yield item
+
+                # Set output attributes AFTER execution
+                set_span_output_attributes(
+                    span,
+                    result=outputs,
+                    output_processor=output_processor,
+                )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(StatusCode.ERROR, str(e))
+                raise
+            finally:
+                if span_cm:
+                    span_cm.__exit__(None, None, None)
+
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        elif inspect.isgeneratorfunction(func):
+            return generator_wrapper
+        elif inspect.isasyncgenfunction(func):
+            return async_generator_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+@overload
+def traced(func: Callable[..., Any], /) -> Callable[..., Any]: ...
+
+
+@overload
+def traced(
+    name: Optional[str] = ...,
+    run_type: Optional[str] = ...,
+    span_type: Optional[str] = ...,
+    input_processor: Optional[Callable[..., Any]] = ...,
+    output_processor: Optional[Callable[..., Any]] = ...,
+    hide_input: bool = ...,
+    hide_output: bool = ...,
+    recording: bool = ...,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ...
+
+
+def traced(
+    name: Optional[str | Callable[..., Any]] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+    hide_input: bool = False,
+    hide_output: bool = False,
+    recording: bool = True,
+):
+    """Decorator that will trace function invocations.
+
+    Args:
+        name: Optional custom name for the span
+        run_type: Optional string to categorize the run type
+        span_type: Optional string to categorize the span type
+        input_processor: Optional function to process function inputs before recording
+            Should accept a dictionary of inputs and return a processed dictionary
+        output_processor: Optional function to process function outputs before recording
+            Should accept the function output and return a processed value
+        hide_input: If True, don't log any input data
+        hide_output: If True, don't log any output data
+        recording: If False, current span and all child spans are not captured
+    """
+    # Handle @traced without parentheses: the decorated function
+    # is passed as the first positional argument (``name``).
+    _func: Optional[Callable[..., Any]] = None
+    if callable(name):
+        _func = name
+        name = None
+
+    # Apply default processors selectively based on hide flags
+    def _default_input_processor(inputs: Any) -> dict[str, str]:
+        """Default input processor that doesn't log any actual input data."""
+        return {"redacted": "Input data not logged for privacy/security"}
+
+    def _default_output_processor(outputs: Any) -> dict[str, str]:
+        """Default output processor that doesn't log any actual output data."""
+        return {"redacted": "Output data not logged for privacy/security"}
+
+    if hide_input:
+        input_processor = _default_input_processor
+    if hide_output:
+        output_processor = _default_output_processor
+
+    # Store the parameters for later reapplication
+    params = {
+        "name": name,
+        "run_type": run_type,
+        "span_type": span_type,
+        "input_processor": input_processor,
+        "output_processor": output_processor,
+        "recording": recording,
+    }
+
+    tracer_impl = _opentelemetry_traced
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        # Check which parameters are supported by the tracer_impl
+        supported_params = get_supported_params(tracer_impl, params)
+
+        # Decorate the function with only supported parameters
+        decorated_func = tracer_impl(**supported_params)(func)
+
+        return decorated_func
+
+    if _func is not None:
+        return decorator(_func)
+
+    return decorator
+
+
+__all__ = ["traced"]
diff --git a/packages/uipath-core/src/uipath/core/tracing/exporters.py b/packages/uipath-core/src/uipath/core/tracing/exporters.py
new file mode 100644
index 000000000..a30723bd3
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/exporters.py
@@ -0,0 +1,45 @@
+"""Custom OpenTelemetry Span Exporter for UiPath Runtime executions."""
+
+from collections import defaultdict
+from typing import Dict, Optional, Sequence
+
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+
+class UiPathRuntimeExecutionSpanExporter(SpanExporter):
+    """Custom exporter that stores spans grouped by execution ids."""
+
+    def __init__(self):
+        """Initialize the exporter."""
+        self._spans: Dict[str, list[ReadableSpan]] = defaultdict(list)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans, grouping them by execution id."""
+        for span in spans:
+            if span.attributes is not None:
+                exec_id = span.attributes.get("execution.id")
+                if exec_id is not None and isinstance(exec_id, str):
+                    self._spans[exec_id].append(span)
+
+        return SpanExportResult.SUCCESS
+
+    def get_spans(self, execution_id: str) -> list[ReadableSpan]:
+        """Retrieve spans for a given execution id."""
+        return self._spans.get(execution_id, [])
+
+    def clear(self, execution_id: Optional[str] = None) -> None:
+        """Clear stored spans for one or all executions."""
+        if execution_id:
+            self._spans.pop(execution_id, None)
+        else:
+            self._spans.clear()
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter and clear all stored spans."""
+        self.clear()
+
+
+__all__ = [
+    "UiPathRuntimeExecutionSpanExporter",
+]
diff --git a/packages/uipath-core/src/uipath/core/tracing/processors.py b/packages/uipath-core/src/uipath/core/tracing/processors.py
new file mode 100644
index 000000000..2fd10f639
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/processors.py
@@ -0,0 +1,76 @@
+"""Custom span processors for UiPath execution tracing."""
+
+from typing import cast
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    SimpleSpanProcessor,
+    SpanExporter,
+)
+
+from uipath.core.tracing.types import UiPathTraceSettings
+
+
+class UiPathExecutionTraceProcessorMixin:
+    """Mixin that propagates execution.id and optionally filters spans."""
+
+    _settings: UiPathTraceSettings | None = None
+
+    def on_start(self, span: Span, parent_context: context_api.Context | None = None):
+        """Called when a span is started."""
+        parent_span: Span | None
+        if parent_context:
+            parent_span = cast(Span, trace.get_current_span(parent_context))
+        else:
+            parent_span = cast(Span, trace.get_current_span())
+
+        if parent_span and parent_span.is_recording() and parent_span.attributes:
+            execution_id = parent_span.attributes.get("execution.id")
+            if execution_id:
+                span.set_attribute("execution.id", execution_id)
+
+    def on_end(self, span: ReadableSpan):
+        """Called when a span ends. Filters before delegating to parent."""
+        span_filter = self._settings.span_filter if self._settings else None
+        if span_filter is None or span_filter(span):
+            parent = cast(SpanProcessor, super())
+            parent.on_end(span)
+
+
+class UiPathExecutionBatchTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, BatchSpanProcessor
+):
+    """Batch span processor that propagates execution.id and optionally filters."""
+
+    def __init__(
+        self,
+        span_exporter: SpanExporter,
+        settings: UiPathTraceSettings | None = None,
+    ):
+        """Initialize the batch trace processor."""
+        super().__init__(span_exporter)
+        self._settings = settings
+
+
+class UiPathExecutionSimpleTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, SimpleSpanProcessor
+):
+    """Simple span processor that propagates execution.id and optionally filters."""
+
+    def __init__(
+        self,
+        span_exporter: SpanExporter,
+        settings: UiPathTraceSettings | None = None,
+    ):
+        """Initialize the simple trace processor."""
+        super().__init__(span_exporter)
+        self._settings = settings
+
+
+__all__ = [
+    "UiPathExecutionBatchTraceProcessor",
+    "UiPathExecutionSimpleTraceProcessor",
+]
diff --git a/packages/uipath-core/src/uipath/core/tracing/span_utils.py b/packages/uipath-core/src/uipath/core/tracing/span_utils.py
new file mode 100644
index 000000000..0e9e9fb22
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/span_utils.py
@@ -0,0 +1,334 @@
+"""Utilities for managing UiPath spans."""
+
+import logging
+from typing import Callable, Optional
+
+from opentelemetry import context, trace
+from opentelemetry.trace import NonRecordingSpan, Span, set_span_in_context
+
+logger = logging.getLogger(__name__)
+
+
+class ParentedNonRecordingSpan(NonRecordingSpan):
+    """Non-recording span with explicit parent tracking.
+
+    Extends NonRecordingSpan to include a parent attribute, allowing the SpanRegistry
+    to properly track parent-child relationships for non-recording spans.
+    This is necessary because NonRecordingSpan instances created directly don't have
+    their parent automatically set like normal recording spans do.
+    """
+
+    def __init__(
+        self, context: trace.SpanContext, parent: Optional[trace.SpanContext] = None
+    ):
+        """Initialize a parented non-recording span.
+
+        Args:
+            context: The SpanContext for this span
+            parent: Optional parent SpanContext
+        """
+        super().__init__(context)
+        self.parent = parent
+
+
+class SpanRegistry:
+    """Registry to track all spans and their parent relationships."""
+
+    MAX_HIERARCHY_DEPTH = 1000  # Hard limit for hierarchy traversal
+
+    def __init__(self):
+        self._spans: dict[int, Span] = {}  # span_id -> span
+        self._parent_map: dict[int, Optional[int]] = {}  # span_id -> parent_id
+
+    def register_span(self, span: Span) -> None:
+        """Register a span and its parent relationship."""
+        span_id = span.get_span_context().span_id
+
+        parent_id: Optional[int] = None
+
+        if hasattr(span, "parent") and span.parent is not None:
+            parent_id = getattr(span.parent, "span_id", None)
+
+        self._spans[span_id] = span
+        self._parent_map[span_id] = parent_id
+
+        parent_str = "{:016x}".format(parent_id) if parent_id is not None else "None"
+
+        logger.debug(
+            "SpanRegistry: registered span: %s (id: %016x, parent: %s)",
+            getattr(span, "name", "unknown"),
+            span_id,
+            parent_str,
+        )
+
+    def get_span(self, span_id: int) -> Optional[Span]:
+        """Get a span by ID."""
+        return self._spans.get(span_id)
+
+    def get_parent_id(self, span_id: int) -> Optional[int]:
+        """Get the parent ID of a span."""
+        return self._parent_map.get(span_id)
+
+    def calculate_depth(self, span_id: int) -> int:
+        """Calculate the depth of a span in the hierarchy.
+
+        Returns:
+            The depth of the span, capped at MAX_HIERARCHY_DEPTH.
+        """
+        depth = 0
+        current_id = span_id
+        visited = set()
+
+        while current_id is not None and current_id not in visited:
+            visited.add(current_id)
+            parent_id = self._parent_map.get(current_id)
+            if parent_id is None:
+                break
+            depth += 1
+            if depth >= self.MAX_HIERARCHY_DEPTH:
+                logger.warning(
+                    "Hit MAX_HIERARCHY_DEPTH (%d) while calculating depth for span %016x",
+                    self.MAX_HIERARCHY_DEPTH,
+                    span_id,
+                )
+                break
+            current_id = parent_id
+
+        return depth
+
+    def is_ancestor(self, ancestor_id: int, descendant_id: int) -> bool:
+        """Check if ancestor_id is an ancestor of descendant_id.
+
+        Returns:
+            True if ancestor_id is an ancestor of descendant_id, False otherwise.
+            If MAX_HIERARCHY_DEPTH is reached, returns False.
+        """
+        current_id: Optional[int] = descendant_id
+        visited = set()
+        steps = 0
+
+        while current_id is not None and current_id not in visited:
+            if current_id == ancestor_id:
+                return True
+            visited.add(current_id)
+            current_id = self._parent_map.get(current_id)
+            steps += 1
+            if steps >= self.MAX_HIERARCHY_DEPTH:
+                logger.warning(
+                    "Hit MAX_HIERARCHY_DEPTH (%d) while checking ancestry between %016x and %016x",
+                    self.MAX_HIERARCHY_DEPTH,
+                    ancestor_id,
+                    descendant_id,
+                )
+                return False
+
+        return False
+
+    def clear(self) -> None:
+        """Clear all registered spans."""
+        self._spans.clear()
+        self._parent_map.clear()
+
+
+# Global span registry instance
+_span_registry = SpanRegistry()
+
+
+class UiPathSpanUtils:
+    """Static utility class to manage tracing implementations and decorated functions."""
+
+    _current_span_provider: Optional[Callable[[], Optional[Span]]] = None
+    _current_span_ancestors_provider: Optional[Callable[[], list[Span]]] = None
+
+    @staticmethod
+    def register_current_span_provider(
+        current_span_provider: Optional[Callable[[], Optional[Span]]],
+    ):
+        """Register a custom current span provider function.
+
+        Args:
+            current_span_provider: A function that returns the current span from an external
+                                 tracing framework. If None, no custom span parenting will be used.
+        """
+        UiPathSpanUtils._current_span_provider = current_span_provider
+
+    @staticmethod
+    def get_parent_context() -> context.Context:
+        """Get the parent context for span creation.
+
+        This method determines the correct parent context when creating a new traced span.
+        It handles scenarios where spans may exist in both OpenTelemetry's context (current_span)
+        and in an external tracing system (external_span), such as LangGraph.
+
+        The algorithm follows this priority:
+
+        1. **No spans available**: Returns the current OpenTelemetry context (empty context)
+
+        2. **Only current_span exists**: Returns a context with current_span set as parent
+           - This is the standard OpenTelemetry behavior for nested traced functions
+
+        3. **Only external_span exists**: Returns a context with external_span set as parent
+           - This occurs when an external tracing system (like LangGraph) has an active span
+             but there's no OTel span in the current call stack
+
+        4. **Both spans exist**: Calls `_get_bottom_most_span()` to determine which is deeper
+           - Uses the SpanRegistry to build parent-child relationships
+           - Returns the span that is closer to the "bottom" (leaf) of the trace tree
+           - This ensures new spans are always attached to the deepest/most specific parent
+
+        Context Sources:
+        - **current_span**: Retrieved from OpenTelemetry's `trace.get_current_span()`
+          - Represents the active OTel span in the current execution context
+          - Created by `@traced` decorators or manual span creation
+
+        - **external_span**: Retrieved from the registered custom span provider
+          - Set via `register_current_span_provider()`
+          - Typically provided by external frameworks (LangGraph, LangChain, etc.)
+          - Allows integration with tracing systems outside of OpenTelemetry
+
+        Returns:
+            context.Context: An OpenTelemetry context containing the appropriate parent span,
+                           or the current empty context if no spans are available
+
+        Example:
+            ```python
+            # Called by the @traced decorator when creating a new span:
+            ctx = UiPathTracingManager.get_parent_context()
+            with tracer.start_as_current_span("my_span", context=ctx) as span:
+                # New span will have the correct parent based on the logic above
+                pass
+            ```
+
+        See Also:
+            - `_get_bottom_most_span()`: Logic for choosing between two available spans
+            - `register_current_span_provider()`: Register external span provider
+            - `get_external_current_span()`: Retrieve span from external provider
+        """
+        current_span = trace.get_current_span()
+        has_current_span = (
+            current_span is not None and current_span.get_span_context().is_valid
+        )
+
+        external_span = UiPathSpanUtils.get_external_current_span()
+
+        # Only one or no spans available
+        if not has_current_span:
+            return (
+                set_span_in_context(external_span)
+                if external_span is not None
+                else context.get_current()
+            )
+        if external_span is None:
+            return set_span_in_context(current_span)
+
+        # Both spans exist - find the bottom-most one
+        bottom_span = UiPathSpanUtils._get_bottom_most_span(current_span, external_span)
+        return set_span_in_context(bottom_span)
+
+    @staticmethod
+    def _get_bottom_most_span(
+        current_span: Span,
+        external_span: Span,
+    ) -> Span:
+        """Determine which span is deeper in the ancestor tree.
+
+        Args:
+            current_span: The OTel current span
+            external_span: The external span from the provider
+
+        Returns:
+            The span that is deeper (closer to the bottom) in the call hierarchy
+        """
+        # Register both spans in the registry
+        _span_registry.register_span(current_span)
+        _span_registry.register_span(external_span)
+
+        # Also register external ancestors
+        external_ancestors = UiPathSpanUtils.get_ancestor_spans() or []
+        for ancestor in external_ancestors:
+            _span_registry.register_span(ancestor)
+
+        current_span_id = current_span.get_span_context().span_id
+        external_span_id = external_span.get_span_context().span_id
+
+        # Check if one span is an ancestor of the other
+        if _span_registry.is_ancestor(external_span_id, current_span_id):
+            logger.debug(
+                "Traced Context: current_span is a descendant of external_span -> returning current_span (deeper)"
+            )
+            return current_span
+        elif _span_registry.is_ancestor(current_span_id, external_span_id):
+            logger.debug(
+                "Traced Context: external_span is a descendant of current_span -> returning external_span (deeper)"
+            )
+            return external_span
+
+        # Neither is an ancestor of the other - they're in different branches
+        # Use depth as tiebreaker
+        current_depth = _span_registry.calculate_depth(current_span_id)
+        external_depth = _span_registry.calculate_depth(external_span_id)
+
+        if current_depth > external_depth:
+            logger.debug(
+                "Traced Context: Different branches, current_span is deeper (depth %d > %d) -> returning current_span",
+                current_depth,
+                external_depth,
+            )
+            return current_span
+        elif external_depth > current_depth:
+            logger.debug(
+                "Traced Context: Different branches, external_span is deeper (depth %d > %d) -> returning external_span",
+                external_depth,
+                current_depth,
+            )
+            return external_span
+        else:
+            # Same depth, different branches - default to external
+            logger.debug(
+                "Traced Context: Same depth (%d), different branches -> defaulting to external_span",
+                current_depth,
+            )
+            return external_span
+
+    @staticmethod
+    def get_external_current_span() -> Optional[Span]:
+        """Get the current span from the external provider, if any."""
+        if UiPathSpanUtils._current_span_provider is not None:
+            try:
+                return UiPathSpanUtils._current_span_provider()
+            except Exception as e:
+                logger.warning("Error getting current span from provider: %s", e)
+        return None
+
+    @staticmethod
+    def get_ancestor_spans() -> list[Span]:
+        """Get the ancestor spans from the registered provider, if any."""
+        if UiPathSpanUtils._current_span_ancestors_provider is not None:
+            try:
+                return UiPathSpanUtils._current_span_ancestors_provider()
+            except Exception as e:
+                logger.warning("Error getting ancestor spans from provider: %s", e)
+        return []
+
+    @staticmethod
+    def register_current_span_ancestors_provider(
+        current_span_ancestors_provider: Optional[Callable[[], list[Span]]],
+    ):
+        """Register a custom current span ancestors provider function.
+
+        Args:
+            current_span_ancestors_provider: A function that returns a list of ancestor spans
+                                           from an external tracing framework. If None, no custom
+                                           span ancestor information will be used.
+        """
+        UiPathSpanUtils._current_span_ancestors_provider = (
+            current_span_ancestors_provider
+        )
+
+    @staticmethod
+    def get_current_span_ancestors_provider():
+        """Get the currently set custom span ancestors provider."""
+        return UiPathSpanUtils._current_span_ancestors_provider
+
+
+__all__ = ["ParentedNonRecordingSpan", "UiPathSpanUtils"]
diff --git a/packages/uipath-core/src/uipath/core/tracing/trace_manager.py b/packages/uipath-core/src/uipath/core/tracing/trace_manager.py
new file mode 100644
index 000000000..672774fb7
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/trace_manager.py
@@ -0,0 +1,195 @@
+"""Tracing manager for handling tracer implementations and function registry."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import threading
+from typing import Any, ClassVar, Generator, Optional
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor, TracerProvider
+from opentelemetry.sdk.trace.export import SpanExporter
+from opentelemetry.util._decorator import _AgnosticContextManager
+
+from uipath.core.tracing.exporters import UiPathRuntimeExecutionSpanExporter
+from uipath.core.tracing.processors import (
+    UiPathExecutionBatchTraceProcessor,
+    UiPathExecutionSimpleTraceProcessor,
+)
+from uipath.core.tracing.types import UiPathTraceSettings
+
+logger = logging.getLogger(__name__)
+
+
+class _DelegatingSpanProcessor(SpanProcessor):
+    """A span processor that delegates to a mutable list of children.
+
+    Registered once on the global TracerProvider. Children can be added
+    and cleared between jobs without touching the provider's internal state.
+
+    WORKAROUND: This exists because OTel's global TracerProvider is set once
+    and has no public API to remove span processors. When a pod runs multiple
+    jobs, each job creates a new UiPathTraceManager that adds processors to
+    the same provider, causing linear accumulation of HTTP calls.
+    The proper fix is for cli_server to create the TracerProvider and
+    trace manager once, and register processors only at startup rather than
+    per-job.
+    """
+
+    _instance: ClassVar[_DelegatingSpanProcessor | None] = None
+    _init_lock: ClassVar[threading.Lock] = threading.Lock()
+
+    def __init__(self) -> None:
+        self._processors: list[SpanProcessor] = []
+
+    @classmethod
+    def get_instance(cls, provider: TracerProvider) -> _DelegatingSpanProcessor:
+        """Get or create the singleton, registering it on the provider once."""
+        if cls._instance is None:
+            with cls._init_lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+                    provider.add_span_processor(cls._instance)
+        return cls._instance
+
+    def add(self, processor: SpanProcessor) -> None:
+        """Add a child processor."""
+        self._processors.append(processor)
+
+    def clear(self) -> list[SpanProcessor]:
+        """Remove and return all child processors."""
+        removed = self._processors.copy()
+        self._processors.clear()
+        return removed
+
+    def on_start(
+        self, span: Span, parent_context: context_api.Context | None = None
+    ) -> None:
+        for p in self._processors:
+            p.on_start(span, parent_context)
+
+    def on_end(self, span: ReadableSpan) -> None:
+        for p in self._processors:
+            p.on_end(span)
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return all(p.force_flush(timeout_millis) for p in self._processors)
+
+    def shutdown(self) -> None:
+        for p in self._processors:
+            p.shutdown()
+
+
+class UiPathTraceManager:
+    """Trace manager.
+
+    Uses a single delegating processor on the global TracerProvider so that
+    child processors can be added and removed between jobs without accumulation.
+    """
+
+    def __init__(self) -> None:
+        """Initialize a trace manager."""
+        trace.set_tracer_provider(TracerProvider())
+        # If a previous provider was already set, reuse it.
+        current_provider = trace.get_tracer_provider()
+        assert isinstance(current_provider, TracerProvider), (
+            "An incompatible Otel TracerProvider was instantiated. Please check runtime configuration."
+        )
+        self.tracer_provider: TracerProvider = current_provider
+        self._delegating = _DelegatingSpanProcessor.get_instance(current_provider)
+        self.tracer_span_processors: list[SpanProcessor] = []
+        self.execution_span_exporter = UiPathRuntimeExecutionSpanExporter()
+        self.add_span_exporter(self.execution_span_exporter)
+
+    def add_span_exporter(
+        self,
+        span_exporter: SpanExporter,
+        batch: bool = True,
+        settings: UiPathTraceSettings | None = None,
+    ) -> UiPathTraceManager:
+        """Add a span exporter to the tracer provider.
+
+        Args:
+            span_exporter: The exporter to add.
+            batch: Whether to use batch processing (default: True).
+            settings: Optional trace settings for filtering, etc.
+        """
+        span_processor: SpanProcessor
+        if batch:
+            span_processor = UiPathExecutionBatchTraceProcessor(span_exporter, settings)
+        else:
+            span_processor = UiPathExecutionSimpleTraceProcessor(
+                span_exporter, settings
+            )
+        self.tracer_span_processors.append(span_processor)
+        self._delegating.add(span_processor)
+        return self
+
+    def add_span_processor(
+        self,
+        span_processor: SpanProcessor,
+    ) -> UiPathTraceManager:
+        """Add a span processor to the tracer provider."""
+        self.tracer_span_processors.append(span_processor)
+        self._delegating.add(span_processor)
+        return self
+
+    def get_execution_spans(
+        self,
+        execution_id: str,
+    ) -> list[ReadableSpan]:
+        """Retrieve spans for a given execution id."""
+        return self.execution_span_exporter.get_spans(execution_id)
+
+    @contextlib.contextmanager
+    def start_execution_span(
+        self,
+        root_span: str,
+        execution_id: str,
+        attributes: Optional[dict[str, str]] = None,
+    ) -> Generator[_AgnosticContextManager[Any] | Any, Any, None]:
+        """Start an execution span."""
+        try:
+            tracer = trace.get_tracer("uipath-runtime")
+            span_attributes: dict[str, Any] = {}
+            if execution_id:
+                span_attributes["execution.id"] = execution_id
+            if attributes:
+                span_attributes.update(attributes)
+            with tracer.start_as_current_span(
+                root_span, attributes=span_attributes
+            ) as span:
+                yield span
+        finally:
+            self.flush_spans()
+
+    def flush_spans(self) -> None:
+        """Flush all span processors."""
+        for span_processor in self.tracer_span_processors:
+            span_processor.force_flush()
+
+    def shutdown(self) -> None:
+        """Flush, shutdown, and remove all span processors registered by this manager.
+
+        Removes child processors from the delegating processor so they no longer
+        receive span events. Must be called between jobs when the same process
+        handles multiple executions to prevent linear accumulation.
+        """
+        for processor in self.tracer_span_processors:
+            try:
+                processor.force_flush()
+                processor.shutdown()
+            except Exception:
+                logger.warning(
+                    "Failed to shutdown processor %s",
+                    type(processor).__name__,
+                    exc_info=True,
+                )
+        self._delegating.clear()
+        self.tracer_span_processors.clear()
+        self.execution_span_exporter.clear()
+
+
+__all__ = ["UiPathTraceManager"]
diff --git a/packages/uipath-core/src/uipath/core/tracing/types.py b/packages/uipath-core/src/uipath/core/tracing/types.py
new file mode 100644
index 000000000..7130718f3
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/tracing/types.py
@@ -0,0 +1,21 @@
+"""Tracing types for UiPath SDK."""
+
+from typing import Callable
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, Field
+
+
+class UiPathTraceSettings(BaseModel):
+    """Trace settings for UiPath SDK."""
+
+    model_config = {"arbitrary_types_allowed": True}  # Needed for Callable
+
+    span_filter: Callable[[ReadableSpan], bool] | None = Field(
+        default=None,
+        description=(
+            "Optional filter to decide whether a span should be exported. "
+            "Called when a span ends with a ReadableSpan argument. "
+            "Return True to export, False to skip."
+        ),
+    )
diff --git a/packages/uipath-core/src/uipath/core/triggers/__init__.py b/packages/uipath-core/src/uipath/core/triggers/__init__.py
new file mode 100644
index 000000000..fb4ee6ae5
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/triggers/__init__.py
@@ -0,0 +1,17 @@
+"""Module containing UiPath trigger definitions."""
+
+__all__ = [
+    "UiPathResumeTrigger",
+    "UiPathResumeTriggerType",
+    "UiPathApiTrigger",
+    "UiPathIntegrationTrigger",
+    "UiPathResumeTriggerName",
+]
+
+from uipath.core.triggers.trigger import (
+    UiPathApiTrigger,
+    UiPathIntegrationTrigger,
+    UiPathResumeTrigger,
+    UiPathResumeTriggerName,
+    UiPathResumeTriggerType,
+)
diff --git a/packages/uipath-core/src/uipath/core/triggers/trigger.py b/packages/uipath-core/src/uipath/core/triggers/trigger.py
new file mode 100644
index 000000000..c897acd28
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/triggers/trigger.py
@@ -0,0 +1,94 @@
+"""Module defining resume trigger types and data models."""
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiPathResumeTriggerType(str, Enum):
+    """Constants representing different types of resume job triggers in the system."""
+
+    NONE = "None"
+    QUEUE_ITEM = "QueueItem"
+    JOB = "Job"
+    TASK = "Task"
+    TIMER = "Timer"
+    INBOX = "Inbox"
+    API = "Api"
+    DEEP_RAG = "DeepRag"
+    BATCH_RAG = "BatchRag"
+    INDEX_INGESTION = "IndexIngestion"
+    IXP_EXTRACTION = "IxpExtraction"
+    IXP_VS_ESCALATION = "IxpVsEscalation"
+
+
+class UiPathResumeTriggerName(str, Enum):
+    """Constants representing specific names for resume job triggers in the system."""
+
+    UNKNOWN = "Unknown"
+    QUEUE_ITEM = "QueueItem"
+    JOB = "Job"
+    TASK = "Task"
+    ESCALATION = "Escalation"
+    TIMER = "Timer"
+    INBOX = "Inbox"
+    API = "Api"
+    DEEP_RAG = "DeepRag"
+    BATCH_RAG = "BatchRag"
+    INDEX_INGESTION = "IndexIngestion"
+    EXTRACTION = "Extraction"
+    IXP_VS_ESCALATION = "IxpVsEscalation"
+    JOB_RAW = "JobRaw"
+    INDEX_INGESTION_RAW = "IndexIngestionRaw"
+    DEEP_RAG_RAW = "DeepRagRaw"
+
+
+class UiPathApiTrigger(BaseModel):
+    """API resume trigger request."""
+
+    inbox_id: str | None = Field(default=None, alias="inboxId")
+    request: Any = None
+
+    model_config = ConfigDict(validate_by_name=True)
+
+
+class UiPathIntegrationTrigger(BaseModel):
+    """Integration Services (Inbox) resume trigger request.
+
+    Mirrors Orchestrator's `IntegrationResumeDto`: the configuration needed to
+    register a remote event trigger through the Connections service and
+    correlate the eventual payload back to the suspended job via `inbox_id`.
+    """
+
+    connector: str = Field(alias="connector")
+    connection_id: str = Field(alias="connectionId")
+    operation: str = Field(alias="operation")
+    object_name: str = Field(alias="objectName")
+    filter_expression: str | None = Field(default=None, alias="filterExpression")
+    parameters: dict[str, str] | None = Field(default=None, alias="parameters")
+    inbox_id: str = Field(alias="inboxId")
+
+    model_config = ConfigDict(validate_by_name=True)
+
+
+class UiPathResumeTrigger(BaseModel):
+    """Information needed to resume execution."""
+
+    interrupt_id: str | None = Field(default=None, alias="interruptId")
+    trigger_type: UiPathResumeTriggerType = Field(
+        default=UiPathResumeTriggerType.API, alias="triggerType"
+    )
+    trigger_name: UiPathResumeTriggerName = Field(
+        default=UiPathResumeTriggerName.UNKNOWN, alias="triggerName", exclude=True
+    )
+    item_key: str | None = Field(default=None, alias="itemKey")
+    api_resume: UiPathApiTrigger | None = Field(default=None, alias="apiResume")
+    integration_resume: UiPathIntegrationTrigger | None = Field(
+        default=None, alias="integrationResume"
+    )
+    folder_path: str | None = Field(default=None, alias="folderPath")
+    folder_key: str | None = Field(default=None, alias="folderKey")
+    payload: Any | None = Field(default=None, alias="interruptObject", exclude=True)
+
+    model_config = ConfigDict(validate_by_name=True)
diff --git a/packages/uipath-core/src/uipath/core/workspace/__init__.py b/packages/uipath-core/src/uipath/core/workspace/__init__.py
new file mode 100644
index 000000000..c05992aae
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/workspace/__init__.py
@@ -0,0 +1,8 @@
+"""UiPath workspace hydration shared contracts."""
+
+from .protocols import AttachmentsProtocol, JobsProtocol
+
+__all__ = [
+    "AttachmentsProtocol",
+    "JobsProtocol",
+]
diff --git a/packages/uipath-core/src/uipath/core/workspace/protocols.py b/packages/uipath-core/src/uipath/core/workspace/protocols.py
new file mode 100644
index 000000000..c3f39c170
--- /dev/null
+++ b/packages/uipath-core/src/uipath/core/workspace/protocols.py
@@ -0,0 +1,56 @@
+"""Service protocols for workspace hydration backend interactions."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+from uuid import UUID
+
+
+@runtime_checkable
+class AttachmentsProtocol(Protocol):
+    """Subset of the UiPath attachments service used by workspace hydration."""
+
+    async def download_async(
+        self,
+        *,
+        key: UUID,
+        destination_path: str,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> str:
+        """Download an attachment to a local path."""
+
+    async def upload_async(
+        self,
+        *,
+        name: str,
+        content: str | bytes | None = None,
+        source_path: str | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> UUID:
+        """Upload content or a local file and return its attachment key."""
+
+
+@runtime_checkable
+class JobsProtocol(Protocol):
+    """Subset of the UiPath jobs service used by workspace hydration."""
+
+    async def list_attachments_async(
+        self,
+        *,
+        job_key: UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> list[str]:
+        """List the attachment ids linked to a job."""
+
+    async def link_attachment_async(
+        self,
+        *,
+        job_key: UUID,
+        attachment_key: UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> None:
+        """Link an existing attachment to a job."""
diff --git a/packages/uipath-core/tests/__init__.py b/packages/uipath-core/tests/__init__.py
new file mode 100644
index 000000000..6152bacfc
--- /dev/null
+++ b/packages/uipath-core/tests/__init__.py
@@ -0,0 +1,4 @@
+"""
+Test suite for UiPath Runtime SDK.
+Contains test cases for all runtime abstractions.
+"""
diff --git a/src/uipath/py.typed b/packages/uipath-core/tests/adapters/__init__.py
similarity index 100%
rename from src/uipath/py.typed
rename to packages/uipath-core/tests/adapters/__init__.py
diff --git a/packages/uipath-core/tests/adapters/test_base.py b/packages/uipath-core/tests/adapters/test_base.py
new file mode 100644
index 000000000..9be6346ed
--- /dev/null
+++ b/packages/uipath-core/tests/adapters/test_base.py
@@ -0,0 +1,163 @@
+"""Tests for BaseAdapter defaults and GovernedAgentBase proxy behavior."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from uipath.core.adapters import BaseAdapter, EvaluatorProtocol
+from uipath.core.adapters.base import GovernedAgentBase
+
+
+class _StubEvaluator:
+    """No-op evaluator that structurally matches EvaluatorProtocol."""
+
+    def evaluate_before_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+    def evaluate_after_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+    def evaluate_before_model(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+    def evaluate_after_model(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+    def evaluate_tool_call(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+    def evaluate_after_tool(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+
+class _MinimalAdapter(BaseAdapter):
+    """Concrete adapter that does NOT override ``name`` — exercises the default."""
+
+    def can_handle(self, agent: Any) -> bool:
+        return True
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _Agent:
+    """Simple stand-in for a framework agent with one attribute and one method."""
+
+    foo = "bar"
+
+    def greet(self) -> str:
+        return "hello"
+
+
+# ---------------------------------------------------------------------------
+# BaseAdapter defaults
+# ---------------------------------------------------------------------------
+
+
+def test_default_name_is_class_name():
+    """The default ``name`` property returns the class name."""
+    assert _MinimalAdapter().name == "_MinimalAdapter"
+
+
+def test_detach_returns_unwrapped_when_present():
+    """``detach`` honours the ``unwrapped`` contract on a governed proxy."""
+    adapter = _MinimalAdapter()
+    original = object()
+
+    class _Proxy:
+        unwrapped = original
+
+    assert adapter.detach(_Proxy()) is original
+
+
+def test_detach_returns_input_when_no_unwrapped_attribute():
+    """For non-proxy adapters, ``detach`` returns the input unchanged."""
+    adapter = _MinimalAdapter()
+    raw = object()
+    assert adapter.detach(raw) is raw
+
+
+def test_generate_trace_id_returns_unique_uuid_string():
+    """``_generate_trace_id`` returns a string UUID; consecutive calls differ."""
+    adapter = _MinimalAdapter()
+    a = adapter._generate_trace_id()
+    b = adapter._generate_trace_id()
+    assert isinstance(a, str)
+    assert a != b
+    assert len(a) == 36  # canonical UUID4 form: 32 hex + 4 dashes
+
+
+# ---------------------------------------------------------------------------
+# GovernedAgentBase proxy
+# ---------------------------------------------------------------------------
+
+
+def test_governed_agent_base_stores_metadata_and_generates_trace_id():
+    """Constructor wires every governance field and pulls a trace id from the adapter."""
+    agent = _Agent()
+    adapter = _MinimalAdapter()
+    evaluator = _StubEvaluator()
+
+    governed = GovernedAgentBase(
+        agent=agent,
+        adapter=adapter,
+        agent_id="agent-123",
+        session_id="session-abc",
+        evaluator=evaluator,
+    )
+
+    assert governed._agent is agent
+    assert governed._adapter is adapter
+    assert governed._agent_id == "agent-123"
+    assert governed._session_id == "session-abc"
+    assert governed._evaluator is evaluator
+    assert isinstance(governed._trace_id, str)
+    assert len(governed._trace_id) == 36
+
+
+def test_governed_agent_base_unwrapped_returns_original_agent():
+    agent = _Agent()
+    governed = GovernedAgentBase(
+        agent=agent,
+        adapter=_MinimalAdapter(),
+        agent_id="a",
+        session_id="s",
+        evaluator=_StubEvaluator(),
+    )
+    assert governed.unwrapped is agent
+
+
+def test_governed_agent_base_forwards_attribute_access_to_agent():
+    """Unknown attributes fall through to the wrapped agent via __getattr__."""
+    governed = GovernedAgentBase(
+        agent=_Agent(),
+        adapter=_MinimalAdapter(),
+        agent_id="a",
+        session_id="s",
+        evaluator=_StubEvaluator(),
+    )
+
+    assert governed.foo == "bar"
+    assert governed.greet() == "hello"
+
+
+def test_governed_agent_base_attribute_miss_raises_attribute_error():
+    """If the wrapped agent also lacks the attribute, AttributeError surfaces."""
+    governed = GovernedAgentBase(
+        agent=_Agent(),
+        adapter=_MinimalAdapter(),
+        agent_id="a",
+        session_id="s",
+        evaluator=_StubEvaluator(),
+    )
+
+    with pytest.raises(AttributeError):
+        _ = governed.does_not_exist
diff --git a/packages/uipath-core/tests/adapters/test_evaluator.py b/packages/uipath-core/tests/adapters/test_evaluator.py
new file mode 100644
index 000000000..5c9e5c9e5
--- /dev/null
+++ b/packages/uipath-core/tests/adapters/test_evaluator.py
@@ -0,0 +1,104 @@
+"""Tests for EvaluatorProtocol.
+
+The protocol is a structural type. These tests verify two things:
+
+1. A class whose method shapes match the protocol passes ``isinstance``
+   against the ``runtime_checkable`` Protocol.
+2. Subclassing the Protocol and calling ``super().<method>`` actually
+   executes the stub bodies — this both documents that the stubs are
+   safely callable (they return ``None``) and brings the contract module
+   to full line coverage.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from uipath.core.adapters import EvaluatorProtocol
+
+
+class _MissingMethodEvaluator:
+    """Only implements one method — fails the structural check."""
+
+    def evaluate_before_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return None
+
+
+class _CompleteEvaluator:
+    """All six methods present with the expected names — passes ``isinstance``."""
+
+    def evaluate_before_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return "before-agent"
+
+    def evaluate_after_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return "after-agent"
+
+    def evaluate_before_model(self, *args: Any, **kwargs: Any) -> Any:
+        return "before-model"
+
+    def evaluate_after_model(self, *args: Any, **kwargs: Any) -> Any:
+        return "after-model"
+
+    def evaluate_tool_call(self, *args: Any, **kwargs: Any) -> Any:
+        return "tool-call"
+
+    def evaluate_after_tool(self, *args: Any, **kwargs: Any) -> Any:
+        return "after-tool"
+
+
+class _ProtocolSubclass(EvaluatorProtocol):
+    """Subclass that delegates to ``super()`` — exercises the stub bodies.
+
+    Each override calls ``super().<method>(...)`` so the ``...`` body of
+    the Protocol method actually executes (returns ``None``).
+    """
+
+    def evaluate_before_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_before_agent(*args, **kwargs)  # type: ignore[safe-super]
+
+    def evaluate_after_agent(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_after_agent(*args, **kwargs)  # type: ignore[safe-super]
+
+    def evaluate_before_model(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_before_model(*args, **kwargs)  # type: ignore[safe-super]
+
+    def evaluate_after_model(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_after_model(*args, **kwargs)  # type: ignore[safe-super]
+
+    def evaluate_tool_call(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_tool_call(*args, **kwargs)  # type: ignore[safe-super]
+
+    def evaluate_after_tool(self, *args: Any, **kwargs: Any) -> Any:
+        return super().evaluate_after_tool(*args, **kwargs)  # type: ignore[safe-super]
+
+
+# ---------------------------------------------------------------------------
+# Structural conformance
+# ---------------------------------------------------------------------------
+
+
+def test_complete_evaluator_is_recognized_by_runtime_check():
+    """A class with all six methods passes ``isinstance`` against the protocol."""
+    assert isinstance(_CompleteEvaluator(), EvaluatorProtocol)
+
+
+def test_partial_evaluator_is_rejected_by_runtime_check():
+    """A class missing methods does NOT pass the structural check."""
+    assert not isinstance(_MissingMethodEvaluator(), EvaluatorProtocol)
+
+
+# ---------------------------------------------------------------------------
+# Stub-body execution (line coverage for the ``...`` placeholders)
+# ---------------------------------------------------------------------------
+
+
+def test_protocol_subclass_methods_execute_stub_bodies():
+    """Calling each method via ``super()`` executes the stub body and returns None."""
+    e = _ProtocolSubclass()
+
+    assert e.evaluate_before_agent("input", "agent", "rt", "trace") is None
+    assert e.evaluate_after_agent("output", "agent", "rt", "trace") is None
+    assert e.evaluate_before_model("input", "agent", "rt", "trace") is None
+    assert e.evaluate_after_model("output", "agent", "rt", "trace") is None
+    assert e.evaluate_tool_call("tool", {"arg": 1}, "agent", "rt", "trace") is None
+    assert e.evaluate_after_tool("tool", "result", "agent", "rt", "trace") is None
diff --git a/packages/uipath-core/tests/adapters/test_registry.py b/packages/uipath-core/tests/adapters/test_registry.py
new file mode 100644
index 000000000..b16b29b1e
--- /dev/null
+++ b/packages/uipath-core/tests/adapters/test_registry.py
@@ -0,0 +1,492 @@
+"""Tests for AdapterRegistry — ordering, resolution, entry-point discovery."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from uipath.core.adapters import BaseAdapter, EvaluatorProtocol
+from uipath.core.adapters.registry import (
+    AdapterRegistry,
+    _discover_entry_point_adapters,
+    get_adapter_registry,
+    reset_adapter_registry,
+)
+
+# ---------------------------------------------------------------------------
+# Test adapters
+# ---------------------------------------------------------------------------
+
+
+class _SpecificAdapter(BaseAdapter):
+    """Matches only objects with a ``__specific__`` marker."""
+
+    @property
+    def name(self) -> str:
+        return "specific"
+
+    def can_handle(self, agent: Any) -> bool:
+        return hasattr(agent, "__specific__")
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _FallbackAdapter(BaseAdapter):
+    """Matches anything — must always sort last."""
+
+    is_fallback = True
+
+    @property
+    def name(self) -> str:
+        return "fallback"
+
+    def can_handle(self, agent: Any) -> bool:
+        return True
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _SecondaryAdapter(BaseAdapter):
+    """Another specific adapter, used to test ordering between two specifics."""
+
+    @property
+    def name(self) -> str:
+        return "secondary"
+
+    def can_handle(self, agent: Any) -> bool:
+        return hasattr(agent, "__secondary__")
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _HighPriorityAdapter(BaseAdapter):
+    """Specific adapter with an elevated priority."""
+
+    priority = 100
+
+    @property
+    def name(self) -> str:
+        return "high"
+
+    def can_handle(self, agent: Any) -> bool:
+        return True
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _LowPriorityAdapter(BaseAdapter):
+    """Generic adapter that should yield to higher-priority specifics."""
+
+    priority = -10
+
+    @property
+    def name(self) -> str:
+        return "low"
+
+    def can_handle(self, agent: Any) -> bool:
+        return True
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        return agent
+
+
+class _BrokenAdapter(BaseAdapter):
+    """``can_handle`` raises — must be skipped, not crash resolution."""
+
+    @property
+    def name(self) -> str:
+        return "broken"
+
+    def can_handle(self, agent: Any) -> bool:
+        raise RuntimeError("can_handle exploded")
+
+    def attach(
+        self,
+        agent: Any,
+        agent_id: str,
+        session_id: str,
+        evaluator: EvaluatorProtocol,
+    ) -> Any:
+        raise RuntimeError("attach exploded")
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture(autouse=True)
+def _isolate_global_registry():
+    """Each test starts with no singleton registry."""
+    reset_adapter_registry()
+    yield
+    reset_adapter_registry()
+
+
+# ---------------------------------------------------------------------------
+# register / resolve / get_all / clear
+# ---------------------------------------------------------------------------
+
+
+def test_empty_registry_resolves_to_none():
+    reg = AdapterRegistry()
+    assert reg.resolve(object()) is None
+    assert reg.get_all() == []
+
+
+def test_register_appends_in_order():
+    reg = AdapterRegistry()
+    a, b = _SpecificAdapter(), _SecondaryAdapter()
+    reg.register(a)
+    reg.register(b)
+    assert reg.get_all() == [a, b]
+
+
+def test_resolve_returns_first_matching_adapter():
+    reg = AdapterRegistry()
+    reg.register(_SpecificAdapter())
+    reg.register(_SecondaryAdapter())
+
+    agent = MagicMock()
+    agent.__secondary__ = True  # only secondary should match
+    resolved = reg.resolve(agent)
+    assert resolved is not None
+    assert resolved.name == "secondary"
+
+
+def test_resolve_skips_broken_can_handle_and_continues():
+    """A can_handle() that raises must not break the whole resolve loop."""
+    reg = AdapterRegistry()
+    reg.register(_BrokenAdapter())
+    reg.register(_SpecificAdapter())
+
+    agent = MagicMock()
+    agent.__specific__ = True
+    resolved = reg.resolve(agent)
+    assert resolved is not None
+    assert resolved.name == "specific"
+
+
+def test_register_position_inserts_at_index():
+    reg = AdapterRegistry()
+    a, b, c = _SpecificAdapter(), _SecondaryAdapter(), _SpecificAdapter()
+    reg.register(a)
+    reg.register(b)
+    reg.register(c, position=0)  # c jumps to head
+    assert reg.get_all()[0] is c
+    assert reg.get_all()[1:] == [a, b]
+
+
+def test_higher_priority_adapter_inserted_before_lower_priority():
+    """A specific (higher-priority) adapter must sort before a generic one
+    even when the generic one was registered first."""
+    reg = AdapterRegistry()
+    generic = _LowPriorityAdapter()
+    specific = _HighPriorityAdapter()
+    reg.register(generic)
+    reg.register(specific)  # registered later, but higher priority
+
+    adapters = reg.get_all()
+    assert adapters[0] is specific
+    assert adapters[1] is generic
+
+
+def test_same_priority_preserves_registration_order():
+    """Adapters with equal priority should fall back to insertion order."""
+    reg = AdapterRegistry()
+    a, b = _SpecificAdapter(), _SecondaryAdapter()  # both priority=0
+    reg.register(a)
+    reg.register(b)
+    assert reg.get_all() == [a, b]
+
+
+def test_higher_priority_adapter_inserted_before_fallback():
+    """High-priority adapter goes in front of an already-registered fallback."""
+    reg = AdapterRegistry()
+    fallback = _FallbackAdapter()
+    reg.register(fallback)
+    reg.register(_HighPriorityAdapter())
+
+    adapters = reg.get_all()
+    assert adapters[0].name == "high"
+    assert adapters[-1] is fallback
+
+
+def test_lower_priority_adapter_inserted_before_fallback_after_specifics():
+    """Negative-priority adapter sorts after default-priority specifics but
+    still before the fallback."""
+    reg = AdapterRegistry()
+    reg.register(_SpecificAdapter())  # priority=0
+    reg.register(_FallbackAdapter())
+    reg.register(_LowPriorityAdapter())  # priority=-10
+
+    adapters = reg.get_all()
+    assert adapters[0].name == "specific"
+    assert adapters[1].name == "low"
+    assert adapters[-1].name == "fallback"
+
+
+def test_priority_overrides_registration_order_in_resolve():
+    """Resolution must follow priority ordering, not registration order."""
+    reg = AdapterRegistry()
+    reg.register(_LowPriorityAdapter())  # both adapters match every agent,
+    reg.register(_HighPriorityAdapter())  # so priority decides which wins.
+
+    resolved = reg.resolve(object())
+    assert resolved is not None
+    assert resolved.name == "high"
+
+
+def test_fallback_stays_last_when_new_adapter_registered():
+    """When the last entry has ``is_fallback`` set, new adapters insert before it."""
+    reg = AdapterRegistry()
+    fallback = _FallbackAdapter()
+    reg.register(fallback)
+    reg.register(_SpecificAdapter())  # this should insert BEFORE fallback
+
+    adapters = reg.get_all()
+    assert adapters[-1] is fallback
+    assert adapters[0].name == "specific"
+
+
+def test_fallback_resolves_only_when_no_specific_matches():
+    reg = AdapterRegistry()
+    reg.register(_SpecificAdapter())
+    reg.register(_FallbackAdapter())
+
+    # Agent without the __specific__ marker → fallback wins.
+    resolved = reg.resolve(object())
+    assert resolved is not None
+    assert resolved.name == "fallback"
+
+
+def test_clear_removes_all_adapters():
+    reg = AdapterRegistry()
+    reg.register(_SpecificAdapter())
+    reg.register(_SecondaryAdapter())
+    reg.clear()
+    assert reg.get_all() == []
+    assert reg.resolve(object()) is None
+
+
+def test_get_all_returns_copy_not_internal_list():
+    """Callers must not be able to mutate the registry through get_all()."""
+    reg = AdapterRegistry()
+    reg.register(_SpecificAdapter())
+    snapshot = reg.get_all()
+    snapshot.clear()
+    assert len(reg.get_all()) == 1  # unaffected
+
+
+# ---------------------------------------------------------------------------
+# Singleton + entry-point discovery
+# ---------------------------------------------------------------------------
+
+
+def test_get_adapter_registry_returns_singleton():
+    reg1 = get_adapter_registry()
+    reg2 = get_adapter_registry()
+    assert reg1 is reg2
+
+
+def test_reset_adapter_registry_drops_singleton():
+    first = get_adapter_registry()
+    reset_adapter_registry()
+    second = get_adapter_registry()
+    assert first is not second
+
+
+def test_entry_point_discovery_invokes_registrars(monkeypatch):
+    """Each entry-point's zero-arg callable must be loaded and called."""
+    called: list[str] = []
+
+    def make_registrar(name: str):
+        def _register() -> None:
+            called.append(name)
+
+        return _register
+
+    ep_a = MagicMock()
+    ep_a.name = "a"
+    ep_a.value = "pkg_a:register"
+    ep_a.load.return_value = make_registrar("a")
+
+    ep_b = MagicMock()
+    ep_b.name = "b"
+    ep_b.value = "pkg_b:register"
+    ep_b.load.return_value = make_registrar("b")
+
+    monkeypatch.setattr(
+        "uipath.core.adapters.registry.entry_points",
+        lambda group: [ep_a, ep_b] if group == "uipath.governance.adapters" else [],
+        raising=False,
+    )
+
+    # entry_points lives in importlib.metadata; the registry imports it
+    # lazily inside the function. Patch the import target directly.
+    import importlib.metadata as importlib_metadata
+
+    monkeypatch.setattr(
+        importlib_metadata,
+        "entry_points",
+        lambda group=None: (
+            [ep_a, ep_b] if group == "uipath.governance.adapters" else []
+        ),
+    )
+
+    _discover_entry_point_adapters()
+    assert sorted(called) == ["a", "b"]
+
+
+def test_entry_point_discovery_skips_broken_loader(monkeypatch):
+    """One broken entry-point must not stop the others from registering."""
+    called: list[str] = []
+
+    ep_broken = MagicMock()
+    ep_broken.name = "broken"
+    ep_broken.value = "pkg_broken:register"
+    ep_broken.load.side_effect = ImportError("cannot import")
+
+    ep_ok = MagicMock()
+    ep_ok.name = "ok"
+    ep_ok.value = "pkg_ok:register"
+    ep_ok.load.return_value = lambda: called.append("ok")
+
+    import importlib.metadata as importlib_metadata
+
+    monkeypatch.setattr(
+        importlib_metadata,
+        "entry_points",
+        lambda group=None: (
+            [ep_broken, ep_ok] if group == "uipath.governance.adapters" else []
+        ),
+    )
+
+    _discover_entry_point_adapters()  # must not raise
+    assert called == ["ok"]
+
+
+def test_entry_point_discovery_skips_non_callable(monkeypatch):
+    """An entry-point that resolves to a non-callable must be logged and skipped."""
+    called: list[str] = []
+
+    ep_bad = MagicMock()
+    ep_bad.name = "bad"
+    ep_bad.value = "pkg_bad:NOT_A_FUNCTION"
+    ep_bad.load.return_value = "not callable"
+
+    ep_ok = MagicMock()
+    ep_ok.name = "ok"
+    ep_ok.value = "pkg_ok:register"
+    ep_ok.load.return_value = lambda: called.append("ok")
+
+    import importlib.metadata as importlib_metadata
+
+    monkeypatch.setattr(
+        importlib_metadata,
+        "entry_points",
+        lambda group=None: (
+            [ep_bad, ep_ok] if group == "uipath.governance.adapters" else []
+        ),
+    )
+
+    _discover_entry_point_adapters()
+    assert called == ["ok"]
+
+
+def test_entry_point_discovery_swallows_registrar_exception(monkeypatch):
+    """A registrar that raises mid-call must not stop subsequent registrars."""
+    called: list[str] = []
+
+    def _raises() -> None:
+        raise RuntimeError("registrar exploded")
+
+    ep_raising = MagicMock()
+    ep_raising.name = "raises"
+    ep_raising.value = "pkg:register"
+    ep_raising.load.return_value = _raises
+
+    ep_ok = MagicMock()
+    ep_ok.name = "ok"
+    ep_ok.value = "pkg:register2"
+    ep_ok.load.return_value = lambda: called.append("ok")
+
+    import importlib.metadata as importlib_metadata
+
+    monkeypatch.setattr(
+        importlib_metadata,
+        "entry_points",
+        lambda group=None: (
+            [ep_raising, ep_ok] if group == "uipath.governance.adapters" else []
+        ),
+    )
+
+    _discover_entry_point_adapters()
+    assert called == ["ok"]
+
+
+def test_entry_point_discovery_swallows_entry_points_failure(monkeypatch):
+    """If ``entry_points()`` itself raises, discovery must log and return cleanly."""
+    import importlib.metadata as importlib_metadata
+
+    def _boom(group=None):
+        raise RuntimeError("entry_points API exploded")
+
+    monkeypatch.setattr(importlib_metadata, "entry_points", _boom)
+
+    # Must not raise — and must not register anything.
+    _discover_entry_point_adapters()
+    reg = get_adapter_registry()
+    assert reg.get_all() == []
+
+
+# ---------------------------------------------------------------------------
+# Protocol conformance smoke tests
+# ---------------------------------------------------------------------------
+
+
+def test_baseadapter_is_abc():
+    """BaseAdapter must be abstract — direct instantiation must fail."""
+    with pytest.raises(TypeError):
+        BaseAdapter()  # type: ignore[abstract]
+
+
+def test_concrete_adapter_is_baseadapter():
+    """A concrete subclass must be recognized as a BaseAdapter."""
+    assert isinstance(_SpecificAdapter(), BaseAdapter)
diff --git a/packages/uipath-core/tests/chat/__init__.py b/packages/uipath-core/tests/chat/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-core/tests/chat/test_message.py b/packages/uipath-core/tests/chat/test_message.py
new file mode 100644
index 000000000..113d34a66
--- /dev/null
+++ b/packages/uipath-core/tests/chat/test_message.py
@@ -0,0 +1,59 @@
+"""Tests for `UiPathConversationMessage` input validation.
+
+Conversational Agent Service contract treats `role` + `contentParts` as
+the load-bearing fields for an inbound user message. `messageId` and
+`contentPartId` are GUIDs that identify entities in the conversation
+hierarchy; when omitted on input, the model fills them with fresh
+UUIDs (matching what `uipath dev` does server-side). `createdAt`,
+`updatedAt`, `spanId`, and `toolCalls` are server-allocated and absent
+from client input.
+
+These tests pin that behavior so `--input-file` payloads from
+`uip codedagent run` validate against the model without requiring
+callers to hand-generate UUIDs.
+"""
+
+from __future__ import annotations
+
+from uipath.core.chat import UiPathConversationMessage
+
+
+def test_minimal_user_message_validates_and_fills_ids() -> None:
+    msg = UiPathConversationMessage.model_validate(
+        {
+            "role": "user",
+            "contentParts": [
+                {
+                    "mimeType": "text/plain",
+                    "data": {"inline": "hello world"},
+                }
+            ],
+        }
+    )
+    assert msg.role == "user"
+    assert msg.tool_calls == []
+    assert msg.created_at is None
+    assert msg.updated_at is None
+    assert msg.message_id  # auto-generated UUID
+    assert msg.content_parts[0].content_part_id  # auto-generated UUID
+    assert msg.content_parts[0].citations == []
+
+
+def test_explicit_ids_are_preserved() -> None:
+    msg = UiPathConversationMessage.model_validate(
+        {
+            "messageId": "00000000-0000-0000-0000-000000000001",
+            "role": "user",
+            "contentParts": [
+                {
+                    "contentPartId": "00000000-0000-0000-0000-000000000002",
+                    "mimeType": "text/plain",
+                    "data": {"inline": "hello world"},
+                }
+            ],
+        }
+    )
+    assert msg.message_id == "00000000-0000-0000-0000-000000000001"
+    assert (
+        msg.content_parts[0].content_part_id == "00000000-0000-0000-0000-000000000002"
+    )
diff --git a/packages/uipath-core/tests/conftest.py b/packages/uipath-core/tests/conftest.py
new file mode 100644
index 000000000..ed5b894e0
--- /dev/null
+++ b/packages/uipath-core/tests/conftest.py
@@ -0,0 +1,50 @@
+"""Shared pytest fixtures for all tests."""
+
+import pytest
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+
+class SpanCapture:
+    """Helper to capture and analyze spans."""
+
+    def __init__(self):
+        self.exporter = InMemorySpanExporter()
+        self.provider = TracerProvider()
+        self.provider.add_span_processor(SimpleSpanProcessor(self.exporter))
+        trace.set_tracer_provider(self.provider)
+
+    def get_spans(self):
+        """Get all captured spans."""
+        return self.exporter.get_finished_spans()
+
+    def clear(self):
+        """Clear captured spans."""
+        self.exporter.clear()
+
+    def print_hierarchy(self):
+        """Print the span hierarchy for debugging."""
+        spans = self.get_spans()
+        print("\n=== Span Hierarchy ===")
+        for span in spans:
+            parent_id = span.parent.span_id if span.parent else "ROOT"
+            print(f"  {span.name}")
+            print(f"    Span ID: {span.context.span_id}")
+            print(f"    Parent ID: {parent_id}")
+            print(f"    Trace ID: {span.context.trace_id}")
+        print("======================\n")
+
+
+@pytest.fixture(scope="session")
+def span_capture() -> SpanCapture:
+    """Fixture to capture spans - created once for entire test session."""
+    return SpanCapture()
+
+
+@pytest.fixture(autouse=True)
+def clear_spans_between_tests(span_capture: SpanCapture):
+    """Clear captured spans before each test."""
+    span_capture.clear()
+    yield
diff --git a/packages/uipath-core/tests/errors/__init__.py b/packages/uipath-core/tests/errors/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-core/tests/errors/test_trigger_errors.py b/packages/uipath-core/tests/errors/test_trigger_errors.py
new file mode 100644
index 000000000..93dd72363
--- /dev/null
+++ b/packages/uipath-core/tests/errors/test_trigger_errors.py
@@ -0,0 +1,65 @@
+"""Tests for UiPath trigger error classes."""
+
+from uipath.core.errors import (
+    ErrorCategory,
+    UiPathFaultedTriggerError,
+    UiPathPendingTriggerError,
+)
+
+
+class TestUiPathFaultedTriggerError:
+    """Test UiPathFaultedTriggerError constructor and behavior."""
+
+    def test_init_with_detail(self) -> None:
+        """Test that category, message, and detail are stored and str includes both."""
+        err = UiPathFaultedTriggerError(
+            category=ErrorCategory.USER,
+            message="Something failed",
+            detail="missing input",
+        )
+        assert err.category == ErrorCategory.USER
+        assert err.message == "Something failed"
+        assert err.detail == "missing input"
+        assert str(err) == "Something failed: missing input"
+
+    def test_init_without_detail(self) -> None:
+        """Test that detail defaults to empty string and str is just the message."""
+        err = UiPathFaultedTriggerError(
+            category=ErrorCategory.SYSTEM,
+            message="Internal error",
+        )
+        assert err.category == ErrorCategory.SYSTEM
+        assert err.message == "Internal error"
+        assert err.detail == ""
+        assert str(err) == "Internal error"
+
+    def test_is_exception(self) -> None:
+        """Test that the error can be raised and caught as an Exception."""
+        with __import__("pytest").raises(UiPathFaultedTriggerError, match="boom"):
+            raise UiPathFaultedTriggerError(
+                category=ErrorCategory.DEPLOYMENT,
+                message="boom",
+            )
+
+
+class TestUiPathPendingTriggerError:
+    """Test UiPathPendingTriggerError inherits correctly."""
+
+    def test_inherits_faulted_trigger_error(self) -> None:
+        """Test that PendingTriggerError is a subclass of FaultedTriggerError."""
+        err = UiPathPendingTriggerError(
+            category=ErrorCategory.UNKNOWN,
+            message="Pending",
+            detail="waiting for response",
+        )
+        assert isinstance(err, UiPathFaultedTriggerError)
+        assert err.category == ErrorCategory.UNKNOWN
+        assert str(err) == "Pending: waiting for response"
+
+    def test_catchable_as_faulted(self) -> None:
+        """Test that PendingTriggerError can be caught as FaultedTriggerError."""
+        with __import__("pytest").raises(UiPathFaultedTriggerError):
+            raise UiPathPendingTriggerError(
+                category=ErrorCategory.USER,
+                message="still pending",
+            )
diff --git a/packages/uipath-core/tests/feature_flags/__init__.py b/packages/uipath-core/tests/feature_flags/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-core/tests/feature_flags/test_feature_flags.py b/packages/uipath-core/tests/feature_flags/test_feature_flags.py
new file mode 100644
index 000000000..8193d74e5
--- /dev/null
+++ b/packages/uipath-core/tests/feature_flags/test_feature_flags.py
@@ -0,0 +1,167 @@
+"""Unit tests for the feature flags registry."""
+
+from typing import TYPE_CHECKING
+
+from uipath.core.feature_flags import FeatureFlags
+from uipath.core.feature_flags.feature_flags import _parse_env_value
+
+if TYPE_CHECKING:
+    from _pytest.monkeypatch import MonkeyPatch
+
+
+class TestParseEnvValue:
+    """Tests for _parse_env_value."""
+
+    def test_true_string(self) -> None:
+        assert _parse_env_value("true") is True
+
+    def test_true_uppercase(self) -> None:
+        assert _parse_env_value("TRUE") is True
+
+    def test_true_mixed_case(self) -> None:
+        assert _parse_env_value("True") is True
+
+    def test_false_string(self) -> None:
+        assert _parse_env_value("false") is False
+
+    def test_false_uppercase(self) -> None:
+        assert _parse_env_value("FALSE") is False
+
+    def test_string_passthrough(self) -> None:
+        assert _parse_env_value("gpt-4") == "gpt-4"
+
+    def test_empty_string(self) -> None:
+        assert _parse_env_value("") == ""
+
+    def test_numeric_string(self) -> None:
+        assert _parse_env_value("42") == "42"
+
+    def test_json_dict(self) -> None:
+        result = _parse_env_value('{"model": "gpt-4", "enabled": true}')
+        assert result == {"model": "gpt-4", "enabled": True}
+
+    def test_json_list(self) -> None:
+        result = _parse_env_value('["a", "b", "c"]')
+        assert result == ["a", "b", "c"]
+
+    def test_json_nested_dict(self) -> None:
+        result = _parse_env_value('{"outer": {"inner": 1}}')
+        assert result == {"outer": {"inner": 1}}
+
+    def test_float_string_stays_string(self) -> None:
+        assert _parse_env_value("3.14") == "3.14"
+
+    def test_plain_string_not_json(self) -> None:
+        assert _parse_env_value("gpt-4") == "gpt-4"
+
+
+class TestConfigureFlags:
+    """Tests for configure_flags / reset_flags."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+
+    def test_configure_sets_flags(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True, "FeatureB": "value"})
+        assert FeatureFlags.get_flag("FeatureA") is True
+        assert FeatureFlags.get_flag("FeatureB") == "value"
+
+    def test_configure_merges(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        FeatureFlags.configure_flags({"FeatureB": False})
+        assert FeatureFlags.get_flag("FeatureA") is True
+        assert FeatureFlags.get_flag("FeatureB") is False
+
+    def test_configure_overwrites(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        FeatureFlags.configure_flags({"FeatureA": False})
+        assert FeatureFlags.get_flag("FeatureA") is False
+
+    def test_reset_clears_all(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        FeatureFlags.reset_flags()
+        assert FeatureFlags.get_flag("FeatureA") is None
+
+
+class TestGetFlag:
+    """Tests for get_flag."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+
+    def test_returns_default_when_unset(self) -> None:
+        assert FeatureFlags.get_flag("Missing") is None
+
+    def test_returns_custom_default(self) -> None:
+        assert FeatureFlags.get_flag("Missing", default="fallback") == "fallback"
+
+    def test_returns_configured_value(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": "hello"})
+        assert FeatureFlags.get_flag("FeatureA") == "hello"
+
+    def test_configured_value_takes_precedence_over_env_var(
+        self, monkeypatch: "MonkeyPatch"
+    ) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        monkeypatch.setenv("UIPATH_FEATURE_FeatureA", "false")
+        assert FeatureFlags.get_flag("FeatureA") is True
+
+    def test_env_var_used_when_nothing_configured(
+        self, monkeypatch: "MonkeyPatch"
+    ) -> None:
+        monkeypatch.setenv("UIPATH_FEATURE_X", "custom")
+        assert FeatureFlags.get_flag("X", default="other") == "custom"
+
+    def test_env_var_string_value(self, monkeypatch: "MonkeyPatch") -> None:
+        monkeypatch.setenv("UIPATH_FEATURE_Model", "gpt-4-turbo")
+        assert FeatureFlags.get_flag("Model") == "gpt-4-turbo"
+
+    def test_env_var_json_dict(self, monkeypatch: "MonkeyPatch") -> None:
+        monkeypatch.setenv("UIPATH_FEATURE_Models", '{"gpt-4": true, "claude": false}')
+        assert FeatureFlags.get_flag("Models") == {"gpt-4": True, "claude": False}
+
+    def test_env_var_json_list(self, monkeypatch: "MonkeyPatch") -> None:
+        monkeypatch.setenv("UIPATH_FEATURE_AllowedModels", '["gpt-4", "claude"]')
+        assert FeatureFlags.get_flag("AllowedModels") == ["gpt-4", "claude"]
+
+
+class TestIsFlagEnabled:
+    """Tests for is_flag_enabled."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+
+    def test_enabled_flag(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        assert FeatureFlags.is_flag_enabled("FeatureA") is True
+
+    def test_disabled_flag(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": False})
+        assert FeatureFlags.is_flag_enabled("FeatureA") is False
+
+    def test_missing_flag_defaults_false(self) -> None:
+        assert FeatureFlags.is_flag_enabled("Missing") is False
+
+    def test_missing_flag_custom_default(self) -> None:
+        assert FeatureFlags.is_flag_enabled("Missing", default=True) is True
+
+    def test_truthy_string_is_enabled(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": "some-value"})
+        assert FeatureFlags.is_flag_enabled("FeatureA") is True
+
+    def test_none_is_disabled(self) -> None:
+        FeatureFlags.configure_flags({"FeatureA": None})
+        assert FeatureFlags.is_flag_enabled("FeatureA") is False
+
+    def test_configured_value_takes_precedence_over_env_var(
+        self, monkeypatch: "MonkeyPatch"
+    ) -> None:
+        FeatureFlags.configure_flags({"FeatureA": True})
+        monkeypatch.setenv("UIPATH_FEATURE_FeatureA", "false")
+        assert FeatureFlags.is_flag_enabled("FeatureA") is True
+
+    def test_env_var_used_when_nothing_configured(
+        self, monkeypatch: "MonkeyPatch"
+    ) -> None:
+        monkeypatch.setenv("UIPATH_FEATURE_FeatureA", "true")
+        assert FeatureFlags.is_flag_enabled("FeatureA") is True
diff --git a/packages/uipath-core/tests/governance/__init__.py b/packages/uipath-core/tests/governance/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-core/tests/governance/test_config.py b/packages/uipath-core/tests/governance/test_config.py
new file mode 100644
index 000000000..54642a413
--- /dev/null
+++ b/packages/uipath-core/tests/governance/test_config.py
@@ -0,0 +1,54 @@
+"""Tests for the governance feature-flag gate."""
+
+from __future__ import annotations
+
+import pytest
+
+from uipath.core.feature_flags import FeatureFlags
+from uipath.core.governance.config import (
+    GOVERNANCE_FEATURE_FLAG,
+    is_governance_enabled,
+)
+
+
+@pytest.fixture(autouse=True)
+def _reset_flags():
+    """Each test starts and ends with a clean flags registry."""
+    FeatureFlags.reset_flags()
+    yield
+    FeatureFlags.reset_flags()
+
+
+def test_governance_flag_name_is_stable():
+    """The flag name is a public contract shared with the runtime layer."""
+    assert GOVERNANCE_FEATURE_FLAG == "EnablePythonGovernanceChecker"
+
+
+def test_is_governance_enabled_defaults_to_false():
+    """With nothing configured, the gate defaults to disabled.
+
+    The platform / host runtime must explicitly opt into governance
+    (programmatically via :class:`FeatureFlags`, via gitops, or via the
+    ``UIPATH_FEATURE_EnablePythonGovernanceChecker`` env var). This
+    keeps the SDK safe-by-default for callers that haven't yet
+    integrated with the governance backend.
+    """
+    assert is_governance_enabled() is False
+
+
+def test_is_governance_enabled_respects_programmatic_disable():
+    """Programmatic ``False`` flips the gate off."""
+    FeatureFlags.configure_flags({GOVERNANCE_FEATURE_FLAG: False})
+    assert is_governance_enabled() is False
+
+
+def test_is_governance_enabled_respects_programmatic_enable():
+    """Programmatic ``True`` keeps the gate on."""
+    FeatureFlags.configure_flags({GOVERNANCE_FEATURE_FLAG: True})
+    assert is_governance_enabled() is True
+
+
+def test_is_governance_enabled_reads_env_var_fallback(monkeypatch):
+    """When nothing is configured programmatically, the env-var fallback wins."""
+    monkeypatch.setenv(f"UIPATH_FEATURE_{GOVERNANCE_FEATURE_FLAG}", "false")
+    assert is_governance_enabled() is False
diff --git a/packages/uipath-core/tests/governance/test_exceptions.py b/packages/uipath-core/tests/governance/test_exceptions.py
new file mode 100644
index 000000000..257feb3d4
--- /dev/null
+++ b/packages/uipath-core/tests/governance/test_exceptions.py
@@ -0,0 +1,205 @@
+"""Tests for GovernanceBlockException constructors.
+
+The classmethod constructors (:meth:`from_violation`,
+:meth:`from_audit_record`) form the documented contract that the
+evaluator and adapter packages depend on — the evaluator only ever
+builds a block via ``from_audit_record``. These tests pin the message
+format and attribute population so a future refactor cannot silently
+drop the rule id, name, or detail.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pytest
+
+from uipath.core.governance.exceptions import (
+    GovernanceBlockException,
+    GovernanceViolation,
+    Severity,
+)
+from uipath.core.governance.models import (
+    Action,
+    AuditRecord,
+    LifecycleHook,
+    RuleEvaluation,
+)
+
+# ---------------------------------------------------------------------------
+# GovernanceViolation
+# ---------------------------------------------------------------------------
+
+
+def test_violation_defaults_to_high_severity():
+    v = GovernanceViolation(rule_id="A-1", rule_name="No PII", detail="ssn leaked")
+    assert v.severity == Severity.HIGH
+
+
+def test_violation_severity_can_be_overridden():
+    v = GovernanceViolation(
+        rule_id="A-1",
+        rule_name="No PII",
+        detail="ssn leaked",
+        severity=Severity.CRITICAL,
+    )
+    assert v.severity == Severity.CRITICAL
+
+
+# ---------------------------------------------------------------------------
+# GovernanceBlockException base constructor
+# ---------------------------------------------------------------------------
+
+
+def test_default_constructor_emits_prefixed_message():
+    exc = GovernanceBlockException()
+    assert "[Governance Policy Violation]" in str(exc)
+    assert exc.violation is None
+    assert exc.audit_record is None
+
+
+def test_default_constructor_carries_default_rule_metadata():
+    """Constructing without context still gives the documented fallback IDs."""
+    exc = GovernanceBlockException()
+    assert exc.rule_id == "POLICY"
+    assert exc.rule_name == "Governance Policy"
+
+
+def test_explicit_message_is_used_verbatim():
+    exc = GovernanceBlockException("custom message")
+    assert str(exc) == "custom message"
+
+
+def test_error_code_constant_for_orchestrator_categorization():
+    """error_code is a class-level constant the Orchestrator UI reads."""
+    assert GovernanceBlockException.error_code == "GOVERNANCE_POLICY_VIOLATION"
+    exc = GovernanceBlockException()
+    assert exc.error_code == "GOVERNANCE_POLICY_VIOLATION"
+
+
+# ---------------------------------------------------------------------------
+# from_violation
+# ---------------------------------------------------------------------------
+
+
+def test_from_violation_populates_rule_metadata():
+    v = GovernanceViolation(rule_id="A-1", rule_name="No PII", detail="ssn leaked")
+    exc = GovernanceBlockException.from_violation(v)
+    assert exc.rule_id == "A-1"
+    assert exc.rule_name == "No PII"
+    assert exc.violation is v
+
+
+def test_from_violation_message_includes_rule_id_name_detail():
+    v = GovernanceViolation(rule_id="A-1", rule_name="No PII", detail="ssn leaked")
+    msg = str(GovernanceBlockException.from_violation(v))
+    assert "A-1" in msg
+    assert "No PII" in msg
+    assert "ssn leaked" in msg
+    assert "[Governance Policy Violation]" in msg
+
+
+# ---------------------------------------------------------------------------
+# from_audit_record
+# ---------------------------------------------------------------------------
+
+
+def _audit_record_with(*evaluations: RuleEvaluation) -> AuditRecord:
+    return AuditRecord(
+        timestamp=datetime.now(timezone.utc),
+        agent_name="agent",
+        runtime_id="run-1",
+        trace_id="trace-1",
+        hook=LifecycleHook.BEFORE_AGENT,
+        evaluations=list(evaluations),
+        final_action=Action.DENY,
+    )
+
+
+def test_from_audit_record_picks_first_matched_rule():
+    """Even when later evaluations matched, the first matched wins the message."""
+    audit = _audit_record_with(
+        RuleEvaluation(
+            rule_id="UNMATCHED",
+            rule_name="Did not fire",
+            matched=False,
+            detail="",
+            action=Action.ALLOW,
+        ),
+        RuleEvaluation(
+            rule_id="MATCHED-FIRST",
+            rule_name="First match",
+            matched=True,
+            detail="bad input",
+            action=Action.DENY,
+        ),
+        RuleEvaluation(
+            rule_id="MATCHED-SECOND",
+            rule_name="Second match",
+            matched=True,
+            detail="also bad",
+            action=Action.DENY,
+        ),
+    )
+
+    exc = GovernanceBlockException.from_audit_record(audit)
+    assert exc.rule_id == "MATCHED-FIRST"
+    assert exc.rule_name == "First match"
+    assert "bad input" in str(exc)
+    assert exc.audit_record is audit
+
+
+def test_from_audit_record_falls_back_when_no_match():
+    """When the audit has no matches, the exception is still constructible."""
+    audit = _audit_record_with(
+        RuleEvaluation(
+            rule_id="UNMATCHED",
+            rule_name="Did not fire",
+            matched=False,
+            detail="",
+            action=Action.ALLOW,
+        )
+    )
+
+    exc = GovernanceBlockException.from_audit_record(audit)
+    assert "Rules evaluated: 1" in str(exc)
+    assert exc.audit_record is audit
+
+
+def test_from_audit_record_matched_detail_default_when_empty():
+    """A matched evaluation with empty detail still produces a sensible message."""
+    audit = _audit_record_with(
+        RuleEvaluation(
+            rule_id="A-1",
+            rule_name="No PII",
+            matched=True,
+            detail="",  # empty
+            action=Action.DENY,
+        )
+    )
+
+    msg = str(GovernanceBlockException.from_audit_record(audit))
+    assert "A-1" in msg
+    assert "No PII" in msg
+    # Falls back to a non-empty detail string.
+    assert "Policy violation detected" in msg
+
+
+# ---------------------------------------------------------------------------
+# Exception identity — must be a real Exception so callers can catch broadly
+# ---------------------------------------------------------------------------
+
+
+def test_block_exception_is_exception_subclass():
+    assert issubclass(GovernanceBlockException, Exception)
+
+
+def test_block_exception_can_be_caught_via_base_exception():
+    try:
+        raise GovernanceBlockException.from_violation(
+            GovernanceViolation(rule_id="A-1", rule_name="X", detail="d")
+        )
+    except Exception as e:  # noqa: BLE001 - intentional broad catch
+        assert isinstance(e, GovernanceBlockException)
+    else:
+        pytest.fail("Did not raise")
diff --git a/packages/uipath-core/tests/governance/test_providers.py b/packages/uipath-core/tests/governance/test_providers.py
new file mode 100644
index 000000000..083b62663
--- /dev/null
+++ b/packages/uipath-core/tests/governance/test_providers.py
@@ -0,0 +1,149 @@
+"""Tests for the governance provider protocols + wire-format models."""
+
+from __future__ import annotations
+
+import pytest
+
+from uipath.core.governance import (
+    EnforcementMode,
+    FiredRule,
+    GovernanceCompensationProvider,
+    GovernancePolicyProvider,
+    GovernRequest,
+    PolicyContext,
+    PolicyResponse,
+)
+
+
+class _FakePolicyProvider:
+    def __init__(self) -> None:
+        self.calls: list[PolicyContext] = []
+
+    def get_policy(self, context: PolicyContext) -> PolicyResponse:
+        self.calls.append(context)
+        return PolicyResponse(mode=EnforcementMode.ENFORCE, policies="rules: []")
+
+
+class _FakeCompensationProvider:
+    def __init__(self) -> None:
+        self.calls: list[GovernRequest] = []
+
+    def compensate(self, request: GovernRequest) -> None:
+        self.calls.append(request)
+
+
+def _make_request() -> GovernRequest:
+    return GovernRequest(
+        validators=["pii_detection"],
+        rules=[
+            FiredRule(
+                rule_id="ASI-01",
+                rule_name="Block PII in flight",
+                pack_name="agent-safety",
+                validator="pii_detection",
+            )
+        ],
+        data={"prompt": "hi"},
+        hook="before_model",
+        trace_id="0123456789abcdef0123456789abcdef",
+        src_timestamp="2026-06-22T10:00:00Z",
+        agent_name="my-agent",
+        runtime_id="runtime-1",
+    )
+
+
+class TestPolicyContext:
+    def test_defaults(self) -> None:
+        ctx = PolicyContext()
+        assert ctx.is_conversational is None
+
+    def test_ignores_unknown_fields(self) -> None:
+        ctx = PolicyContext.model_validate(
+            {"is_conversational": True, "future_selector": "x"}
+        )
+        assert ctx.is_conversational is True
+
+
+class TestPolicyResponse:
+    def test_defaults(self) -> None:
+        response = PolicyResponse()
+        assert response.mode is None
+        assert response.policies == ""
+
+    @pytest.mark.parametrize(
+        ("wire_value", "expected"),
+        [
+            ("audit", EnforcementMode.AUDIT),
+            ("enforce", EnforcementMode.ENFORCE),
+            ("disabled", EnforcementMode.DISABLED),
+        ],
+    )
+    def test_parses_known_modes(
+        self, wire_value: str, expected: EnforcementMode
+    ) -> None:
+        response = PolicyResponse.model_validate({"mode": wire_value})
+        assert response.mode is expected
+
+    def test_unknown_mode_falls_back_to_none(self) -> None:
+        # Forward-compat: a server-added mode the SDK doesn't know about
+        # must not break agent startup. Parses as None so the runtime
+        # falls back to its safe default rather than raising.
+        response = PolicyResponse.model_validate({"mode": "ludicrous"})
+        assert response.mode is None
+
+
+class TestGovernRequest:
+    def test_serializes_wire_aliases(self) -> None:
+        payload = _make_request().model_dump(by_alias=True, exclude_none=True)
+        assert payload["type"] == ["pii_detection"]
+        assert payload["traceId"] == "0123456789abcdef0123456789abcdef"
+        assert payload["agentName"] == "my-agent"
+        assert payload["runtimeId"] == "runtime-1"
+        # src_timestamp is intentionally snake_case on the wire.
+        assert payload["src_timestamp"] == "2026-06-22T10:00:00Z"
+        # Optional job-context fields left None → excluded.
+        for absent in (
+            "folderKey",
+            "jobKey",
+            "processKey",
+            "referenceId",
+            "agentVersion",
+        ):
+            assert absent not in payload
+
+
+class TestProtocolConformance:
+    """`runtime_checkable` Protocols should accept structurally-matching objects."""
+
+    def test_fake_policy_provider_satisfies_protocol(self) -> None:
+        provider = _FakePolicyProvider()
+        assert isinstance(provider, GovernancePolicyProvider)
+
+    def test_fake_compensation_provider_satisfies_protocol(self) -> None:
+        provider = _FakeCompensationProvider()
+        assert isinstance(provider, GovernanceCompensationProvider)
+
+    def test_object_without_methods_rejected(self) -> None:
+        class _NotAProvider:
+            pass
+
+        assert not isinstance(_NotAProvider(), GovernancePolicyProvider)
+        assert not isinstance(_NotAProvider(), GovernanceCompensationProvider)
+
+
+class TestEndToEndDispatch:
+    """Caller passes a provider directly to the consumer (no global registry)."""
+
+    def test_policy_round_trip(self) -> None:
+        provider = _FakePolicyProvider()
+        response = provider.get_policy(PolicyContext(is_conversational=True))
+
+        assert response.mode is EnforcementMode.ENFORCE
+        assert provider.calls == [PolicyContext(is_conversational=True)]
+
+    def test_compensation_round_trip(self) -> None:
+        provider = _FakeCompensationProvider()
+        request = _make_request()
+        provider.compensate(request)
+
+        assert provider.calls == [request]
diff --git a/packages/uipath-core/tests/guardrails/test_deterministic_guardrails_service.py b/packages/uipath-core/tests/guardrails/test_deterministic_guardrails_service.py
new file mode 100644
index 000000000..e506f49ac
--- /dev/null
+++ b/packages/uipath-core/tests/guardrails/test_deterministic_guardrails_service.py
@@ -0,0 +1,1676 @@
+import re
+from typing import Any
+
+import pytest
+
+from uipath.core.guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    DeterministicGuardrail,
+    DeterministicGuardrailsService,
+    FieldReference,
+    FieldSource,
+    GuardrailScope,
+    GuardrailSelector,
+    GuardrailValidationResultType,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+@pytest.fixture
+def service() -> DeterministicGuardrailsService:
+    return DeterministicGuardrailsService()
+
+
+class TestDeterministicGuardrailsService:
+    """Test GuardrailsService functionality."""
+
+    def test_evaluate_post_deterministic_guardrail_validation_passed(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation with passing rules."""
+        # Create a deterministic guardrail matching the C# example
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Pre execution Guardrail",
+            description="Test pre-execution guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+            ],
+        )
+
+        # Input data matching the C# example
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_evaluate_post_deterministic_guardrail_validation_passes_when_input_data_dont_violates_all_the_rules(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation fails when age is too low."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Pre execution Guardrail",
+            description="Test pre-execution guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        # Input data with age < 21
+        input_data = {
+            "userName": "John",
+            "age": 18,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Input data didn't match the guardrail condition: [isActive] comparing function [(b): b is not True]"
+        )
+
+    def test_evaluate_post_deterministic_guardrail_validation_passes_when_input_and_output_data_dont_violates_all_the_rules(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation fails when isActive is False."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Pre execution Guardrail",
+            description="Test pre-execution guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        # Input data with isActive = False
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": False,
+        }
+        output_data = {
+            "status": 200,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Input data didn't match the guardrail condition: [age] comparing function [(n): n < 21.0]"
+        )
+
+    def test_evaluate_post_deterministic_guardrail_uses_rule_description(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Ensure rule_description is returned when a rule fails validation."""
+        friendly_description = "Username must include 'te' and a digit"
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-rule-desc-id",
+            name="Regex Guardrail With Description",
+            description="Test regex guardrail with description",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="userName", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    rule_description=friendly_description,
+                    detects_violation=lambda s: not bool(re.search(".*te.*3.*", s)),
+                ),
+            ],
+        )
+
+        # Input data with userName that doesn't match the regex pattern
+        input_data = {
+            "userName": "test",
+        }
+
+        result = service.evaluate_pre_deterministic_guardrail(
+            input_data=input_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert (
+            result.reason
+            == "Data matched all guardrail conditions: [Username must include 'te' and a digit]"
+        )
+
+    def test_evaluate_post_deterministic_guardrail_passes_validation_when_no_output_rules(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation passes when regex matches."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Regex Guardrail",
+            description="Test regex guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="userName", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: not bool(re.search(".*te.*3.*", s)),
+                ),
+            ],
+        )
+
+        # Input data with userName that matches the regex pattern
+        input_data = {
+            "userName": "test123",
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_evaluate_post_deterministic_guardrail_failes_validation_when_data_macthes_rules(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation fails when regex doesn't match."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Regex Guardrail",
+            description="Test regex guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="userName", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: not bool(re.search(".*te.*3.*", s)),
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        # Input data with userName that doesn't match the regex pattern
+        input_data = {
+            "userName": "test",
+        }
+        output_data = {
+            "status": 201,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        expected_reason = (
+            "Data matched all guardrail conditions: [[userName] comparing function "
+            '[(s): not bool(re.search(".*te.*3.*", s))], '
+            "[status] comparing function [(n): n != 200.0]]"
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == expected_reason
+
+    def test_evaluate_post_deterministic_guardrail_word_contains_substring_detects_violation(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation fails when string contains forbidden substring."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Word Contains Guardrail",
+            description="Test word contains guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="userName", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: "dre" in s,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        # Input data with userName that contains "dre" - should fail
+        input_data = {
+            "userName": "andrei",
+        }
+        output_data = {
+            "status": 201,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert (
+            result.reason
+            == "Data matched all guardrail conditions: [[userName] comparing function "
+            '[(s): "dre" in s], [status] comparing function [(n): n != 200.0]]'
+        )
+
+    def test_evaluate_post_deterministic_guardrail_number_func_passes_when_no_input_rules(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation passes when number func returns True."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Number Func Guardrail",
+            description="Test number func guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 18 or n > 65,
+                ),
+            ],
+        )
+
+        # Input data with age that passes the function check
+        input_data = {
+            "age": 25,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_evaluate_post_deterministic_guardrail_number_func_negative(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail validation fails when number func returns False."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-deterministic-id",
+            name="Number Func Guardrail",
+            description="Test number func guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 18 or n > 65,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        # Input data with age that fails the function check
+        input_data = {
+            "age": 70,
+        }
+        output_data = {
+            "status": 201,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_evaluate_post_execution_pases_when_only_some_rules_not_met(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post-execution guardrail passes when only some rules are not met."""
+        guardrail = self._create_guardrail_for_pre_execution()
+        input_data = {
+            "userName": "John",
+            "age": 18,  # Less than 21
+            "isActive": True,
+        }
+        output_data = {
+            "status": 200,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_should_ignore_post_execution_guardrail_for_pre_execution_returns_false(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test that pre-execution guardrail ignores post-execution data."""
+        guardrail = self._create_guardrail_for_post_execution()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        # Should fail because post-execution guardrail needs output data
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_should_trigger_policy_post_execution_guardrail_for_pre_execution_returns_false(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test that pre-execution guardrail does not trigger in post-execution."""
+        guardrail = self._create_guardrail_for_pre_execution()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        # Pre-execution guardrail should still pass in post-execution
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_should_trigger_policy_post_execution_with_output_fields_when_no_violation_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        guardrail = self._create_guardrail_for_post_execution()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_with_output_fields_when_only_input_conditions_violated_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        guardrail = self._create_guardrail_for_post_execution()
+        input_data = {
+            "userName": "John",
+            "age": 18,  # Less than 21
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_with_input_and_output_fields_output_when_only_output_conditions_violated_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        guardrail = self._create_guardrail_for_post_execution()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 400,  # Not 200
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_multiple_rules_when_all_conditions_when_no_condition_is_violated_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        guardrail = self._create_guardrail_with_multiple_rules()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_rule_with_multiple_conditions_when_no_condition_is_violated_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test guardrail with rule having multiple conditions passes when all are met."""
+        guardrail = self._create_guardrail_with_rule_having_multiple_conditions()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_rule_with_multiple_conditions_when_only_some_conditions_are_violated_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test guardrail with multiple conditions fails when one condition is not met."""
+        guardrail = self._create_guardrail_with_rule_having_multiple_conditions()
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": False,  # Not True
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_rule_with_multiple_conditions_when_all_condition_are_violated_then_returns_false(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test guardrail with multiple conditions fails when one condition is not met."""
+        guardrail = self._create_guardrail_with_rule_having_multiple_conditions()
+        input_data = {
+            "userName": "John",
+            "age": 15,  # < 18
+            "isActive": False,  # Not True
+        }
+        output_data = {
+            "result": "Success",
+            "status": 201,  # Not 200
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_post_execution_with_all_fields_selector_when_no_field_violates_condition_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test guardrail with AllFieldsSelector passes when output has matching fields."""
+        guardrail = DeterministicGuardrail(
+            id="test-all-fields-id",
+            name="Guardrail With All Fields Selector",
+            description="Test all fields selector",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=AllFieldsSelector(
+                        selector_type="all", sources=[FieldSource.OUTPUT]
+                    ),
+                    detects_violation=lambda n: n != 25.0,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 25,  # Doesn't match the rule value
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_post_execution_with_all_fields_selector_when_all_fields_violate_condition_then_returns_false(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-all-fields-id",
+            name="Guardrail With All Fields Selector",
+            description="Test all fields selector",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=AllFieldsSelector(
+                        selector_type="all", sources=[FieldSource.OUTPUT]
+                    ),
+                    detects_violation=lambda n: n != 25.0,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 20,  # Matches the rule value
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_post_execution_with_all_fields_selector_when_empty_output_schema_then_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test guardrail with AllFieldsSelector fails when output is empty."""
+        guardrail = DeterministicGuardrail(
+            id="test-all-fields-id",
+            name="Guardrail With All Fields Selector",
+            description="Test all fields selector",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=AllFieldsSelector(
+                        selector_type="all", sources=[FieldSource.INPUT]
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}  # Empty output
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_should_trigger_policy_pre_execution_always_rule_with_input_apply_to_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with INPUT ApplyTo triggers in pre-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.INPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+
+        result = service.evaluate_pre_deterministic_guardrail(
+            input_data=input_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == "Always rule enforced"
+
+    def test_should_trigger_policy_pre_execution_always_rule_with_output_apply_to_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with OUTPUT ApplyTo does not trigger in pre-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.OUTPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for input data"
+
+    def test_should_trigger_policy_pre_execution_always_rule_with_input_and_output_apply_to_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with INPUT_AND_OUTPUT ApplyTo triggers in pre-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.INPUT_AND_OUTPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == "Always rule enforced"
+
+    def test_should_trigger_policy_post_execution_always_rule_with_input_apply_to_returns_false(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with INPUT ApplyTo does not trigger in post-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.INPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_should_trigger_policy_post_execution_always_rule_with_output_apply_to_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with OUTPUT ApplyTo triggers in post-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.OUTPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == "Always rule enforced"
+
+    def test_should_trigger_policy_post_execution_always_rule_with_input_and_output_apply_to_returns_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test UniversalRule with INPUT_AND_OUTPUT ApplyTo triggers in post-execution."""
+        guardrail = self._create_guardrail_with_always_rule(ApplyTo.INPUT_AND_OUTPUT)
+        input_data = {
+            "userName": "John",
+            "age": 25,
+            "isActive": True,
+        }
+        output_data = {
+            "result": "Success",
+            "status": 200,
+            "success": True,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == "Always rule enforced"
+
+        # Helper methods to create guardrails
+
+    def _create_guardrail_for_pre_execution(self) -> DeterministicGuardrail:
+        """Create a guardrail for pre-execution testing."""
+        return DeterministicGuardrail(
+            id="test-pre-exec-id",
+            name="Pre execution Guardrail",
+            description="Test pre-execution guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+    def _create_guardrail_for_post_execution(self) -> DeterministicGuardrail:
+        """Create a guardrail for post-execution testing."""
+        return DeterministicGuardrail(
+            id="test-post-exec-id",
+            name="Guardrail for Post execution",
+            description="Test post-execution guardrail",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+    def _create_guardrail_with_multiple_rules(self) -> DeterministicGuardrail:
+        """Create a guardrail with multiple rules."""
+        return DeterministicGuardrail(
+            id="test-multiple-rules-id",
+            name="Guardrail With Multiple Rules",
+            description="Test guardrail with multiple rules",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+    def _create_guardrail_with_rule_having_multiple_conditions(
+        self,
+    ) -> DeterministicGuardrail:
+        """Create a guardrail with rule having multiple conditions."""
+        return DeterministicGuardrail(
+            id="test-multiple-conditions-id",
+            name="Guardrail With Rule Having Multiple Conditions",
+            description="Test guardrail with multiple conditions",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+    def test_evaluate_post_deterministic_guardrail_word_contains_operator_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail with word contains operator passes for pre-execution."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="b4283bd4-5ce0-49de-a918-2604d830460c",
+            name="Before",
+            description="",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["ConverterToStringAgent"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(
+                                path="input_string", source=FieldSource.INPUT
+                            )
+                        ],
+                    ),
+                    detects_violation=lambda s: "cti" in s,
+                ),
+            ],
+        )
+
+        # Input data without "cti" in input_string - should pass
+        input_data = {
+            "input_string": "test value",
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_evaluate_post_deterministic_guardrail_only_output_rules_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail with only output rules passes when conditions are met."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-output-id",
+            name="Output Only Guardrail",
+            description="Test guardrail with only output rules",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="result", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: s != "Success",
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+        }
+        output_data = {
+            "status": 200,
+            "result": "Success",
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Output data didn't match the guardrail condition: [status] comparing function [(n): n != 200.0]"
+        )
+
+    def test_evaluate_post_deterministic_guardrail_only_always_rule_fails(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail with only UniversalRule always fails."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-always-id",
+            name="Always Rule Only Guardrail",
+            description="Test guardrail with only always rule",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                UniversalRule(
+                    rule_type="always",
+                    apply_to=ApplyTo.OUTPUT,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+        }
+        output_data = {
+            "status": 200,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        assert result.reason == "Always rule enforced"
+
+    def test_evaluate_post_deterministic_guardrail_only_input_rules_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail passes when only input rules exist (no output data required)."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-input-id",
+            name="Input Only Guardrail",
+            description="Test guardrail with only input rules",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 18,
+                ),
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="name", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda s: len(s) < 2,
+                ),
+            ],
+        )
+
+        input_data = {
+            "age": 25,
+            "name": "John",
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "No rules to apply for output data."
+
+    def test_evaluate_pre_deterministic_guardrail_with_input_and_output_rules_input_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test pre-execution guardrail with input rule and output rules, should pass because is ignored."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-pre-mixed-rules-id",
+            name="Pre Execution Mixed Rules Guardrail",
+            description="Test pre-execution with both input and output rules",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                # Output rule - should be ignored in pre-execution
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+            "age": 18,
+            "isActive": True,
+        }
+
+        result = service.evaluate_pre_deterministic_guardrail(
+            input_data=input_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def _create_guardrail_with_always_rule(
+        self, apply_to: ApplyTo
+    ) -> DeterministicGuardrail:
+        """Create a guardrail with an AlwaysRule (UniversalRule)."""
+        return DeterministicGuardrail(
+            id="test-always-rule-id",
+            name="Guardrail With Always Rule",
+            description="Test guardrail with always rule",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                UniversalRule(
+                    rule_type="always",
+                    apply_to=apply_to,
+                ),
+            ],
+        )
+
+
+class TestMissingFieldPassesValidation:
+    """Test that rules referencing missing fields pass validation."""
+
+    def test_word_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="sentence2", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: len(s or "") > 0,
+                    rule_description="sentence2 is not empty",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"sentence1": "hello"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_number_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n is not None and n < 0,
+                    rule_description="age is negative",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"name": "test"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_boolean_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="is_active", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is False,
+                    rule_description="is_active is false",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"name": "test"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+
+class TestWrappedArrayOutputEvaluation:
+    """Test that guardrails work when tool output is a dict-wrapped array.
+
+    When a tool returns a JSON array, _extract_tool_output_data wraps it as
+    {"output": [...]}.  Field paths starting with [*] (e.g. [*].author.email)
+    must still resolve correctly against the wrapped structure.
+    """
+
+    def test_word_rule_on_wrapped_array_output_detects_violation(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-wrapped-array",
+            name="Wrapped Array Guardrail",
+            description="Test wrapped array output",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(
+                                path="[*].author.emailAddress",
+                                source=FieldSource.OUTPUT,
+                            )
+                        ],
+                    ),
+                    detects_violation=lambda s: "iana" in s,
+                    rule_description="email contains 'iana'",
+                ),
+            ],
+        )
+        # Simulates output from _extract_tool_output_data when tool returns an array.
+        # All emails contain "iana" so every field violates the rule → guardrail fails.
+        output_data = {
+            "output": [
+                {
+                    "author": {"emailAddress": "briana.smith@test.com"},
+                    "body": "comment1",
+                },
+                {
+                    "author": {"emailAddress": "adriana.jones@test.com"},
+                    "body": "comment2",
+                },
+            ]
+        }
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data={},
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_word_rule_on_wrapped_array_output_passes_when_no_match(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-wrapped-array",
+            name="Wrapped Array Guardrail",
+            description="Test wrapped array output",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(
+                                path="[*].author.emailAddress",
+                                source=FieldSource.OUTPUT,
+                            )
+                        ],
+                    ),
+                    detects_violation=lambda s: "iana" in s,
+                    rule_description="email contains 'iana'",
+                ),
+            ],
+        )
+        output_data = {
+            "output": [
+                {
+                    "author": {"emailAddress": "mike.wilson@test.com"},
+                    "body": "comment1",
+                },
+                {
+                    "author": {"emailAddress": "sarah.clark@test.com"},
+                    "body": "comment2",
+                },
+            ]
+        }
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data={},
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
diff --git a/packages/uipath-core/tests/guardrails/test_guardrails_models.py b/packages/uipath-core/tests/guardrails/test_guardrails_models.py
new file mode 100644
index 000000000..954cdd41c
--- /dev/null
+++ b/packages/uipath-core/tests/guardrails/test_guardrails_models.py
@@ -0,0 +1,53 @@
+"""Tests for guardrails models normalization validators."""
+
+from typing import TYPE_CHECKING
+
+from uipath.core.guardrails import (
+    AllFieldsSelector,
+    FieldReference,
+    FieldSource,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+class TestGuardrailsModelsNormalization:
+    """Test guardrails models field normalization."""
+
+    def test_field_reference_normalizes_capitalized_source(
+        self,
+    ) -> None:
+        """Test that FieldReference normalizes capitalized source values to lowercase."""
+        # Create FieldReference with capitalized "Input" - should normalize to FieldSource.INPUT
+        field_ref = FieldReference(path="testField", source="Input")  # type: ignore[arg-type]
+        assert field_ref.source == FieldSource.INPUT
+
+        # Create FieldReference with capitalized "Output" - should normalize to FieldSource.OUTPUT
+        field_ref = FieldReference(path="testField", source="Output")  # type: ignore[arg-type]
+        assert field_ref.source == FieldSource.OUTPUT
+
+        # Create FieldReference with lowercase "input" - should work as-is
+        field_ref = FieldReference(path="testField", source="input")  # type: ignore[arg-type]
+        assert field_ref.source == FieldSource.INPUT
+
+    def test_all_fields_selector_normalizes_capitalized_sources(
+        self,
+    ) -> None:
+        """Test that AllFieldsSelector normalizes capitalized source values in the list."""
+        # Create AllFieldsSelector with capitalized "Input" and "Output" - should normalize
+        selector = AllFieldsSelector(
+            selector_type="all",
+            sources=["Input", "Output"],  # type: ignore[list-item]
+        )
+        assert FieldSource.INPUT in selector.sources
+        assert FieldSource.OUTPUT in selector.sources
+        assert len(selector.sources) == 2
+
+        # Create AllFieldsSelector with mixed case - should normalize all
+        selector = AllFieldsSelector(
+            selector_type="all",
+            sources=["Input", "output"],  # type: ignore[list-item]
+        )
+        assert FieldSource.INPUT in selector.sources
+        assert FieldSource.OUTPUT in selector.sources
diff --git a/packages/uipath-core/tests/serialization/test_json.py b/packages/uipath-core/tests/serialization/test_json.py
new file mode 100644
index 000000000..dd8e3aa68
--- /dev/null
+++ b/packages/uipath-core/tests/serialization/test_json.py
@@ -0,0 +1,659 @@
+"""Tests for serialization utilities."""
+
+import json
+from collections import namedtuple
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+from zoneinfo import ZoneInfo
+
+import pytest
+from pydantic import BaseModel
+
+from uipath.core.serialization import serialize_json
+
+
+def _has_tzdata() -> bool:
+    """Check if timezone data is available."""
+    try:
+        ZoneInfo("America/New_York")
+        return True
+    except Exception:
+        return False
+
+
+class Color(Enum):
+    """Test enum."""
+
+    RED = "red"
+    GREEN = "green"
+    BLUE = 3
+
+
+class Priority(Enum):
+    """Test enum with int values."""
+
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+
+
+class SimpleModel(BaseModel):
+    """Simple Pydantic v2 model."""
+
+    name: str
+    value: int
+
+
+class NestedModel(BaseModel):
+    """Pydantic model with nested model."""
+
+    id: str
+    inner: SimpleModel
+    items: list[SimpleModel]
+
+
+@dataclass
+class SimpleDataclass:
+    """Simple dataclass for testing."""
+
+    name: str
+    count: int
+
+
+@dataclass
+class NestedDataclass:
+    """Dataclass with nested dataclass."""
+
+    id: str
+    inner: SimpleDataclass
+
+
+Point = namedtuple("Point", ["x", "y"])
+
+
+class TestSimpleSerializeDefaults:
+    """Tests for serialize_defaults and serialize_json functions."""
+
+    def test_serializes_none(self) -> None:
+        """Test None serialization via json.dumps."""
+        data = {"value": None}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["value"] is None
+
+    def test_serializes_primitives(self) -> None:
+        """Test primitive types pass through json.dumps unchanged."""
+        data = {
+            "bool_true": True,
+            "bool_false": False,
+            "integer": 42,
+            "float": 3.14,
+            "string": "hello",
+        }
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["bool_true"] is True
+        assert parsed["bool_false"] is False
+        assert parsed["integer"] == 42
+        assert parsed["float"] == 3.14
+        assert parsed["string"] == "hello"
+
+    def test_serializes_pydantic_model(self) -> None:
+        """Test Pydantic BaseModel serialization via json.dumps."""
+        model = SimpleModel(name="test", value=42)
+        result = serialize_json(model)
+        parsed = json.loads(result)
+        assert isinstance(parsed, dict)
+        assert parsed["name"] == "test"
+        assert parsed["value"] == 42
+
+    def test_serializes_nested_pydantic_model(self) -> None:
+        """Test nested Pydantic models via json.dumps."""
+        inner = SimpleModel(name="inner", value=10)
+        model = NestedModel(
+            id="123",
+            inner=inner,
+            items=[
+                SimpleModel(name="item1", value=1),
+                SimpleModel(name="item2", value=2),
+            ],
+        )
+        result = serialize_json(model)
+        parsed = json.loads(result)
+        assert isinstance(parsed, dict)
+        assert parsed["id"] == "123"
+        assert parsed["inner"]["name"] == "inner"
+        assert len(parsed["items"]) == 2
+        assert parsed["items"][0]["name"] == "item1"
+        assert parsed["items"][1]["value"] == 2
+
+    def test_serializes_pydantic_model_excludes_none(self) -> None:
+        """Test Pydantic model with None values excluded via json.dumps."""
+
+        class OptionalModel(BaseModel):
+            required: str
+            optional: str | None = None
+
+        model = OptionalModel(required="value")
+        result = serialize_json(model)
+        parsed = json.loads(result)
+        assert isinstance(parsed, dict)
+        assert parsed["required"] == "value"
+        # exclude_none=True should exclude the None field
+        assert "optional" not in parsed
+
+    def test_serializes_pydantic_model_class(self) -> None:
+        """Test Pydantic model class (not instance) serialization via json.dumps."""
+        data = {"model_class": SimpleModel}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["model_class"], dict)
+        assert parsed["model_class"]["__class__"] == "SimpleModel"
+        assert parsed["model_class"]["__module__"] == "test_json"
+        assert "schema" in parsed["model_class"]
+        assert isinstance(parsed["model_class"]["schema"], dict)
+
+    def test_serializes_dataclass(self) -> None:
+        """Test dataclass serialization via json.dumps."""
+        obj = SimpleDataclass(name="test", count=5)
+        result = serialize_json(obj)
+        parsed = json.loads(result)
+        assert isinstance(parsed, dict)
+        assert parsed["name"] == "test"
+        assert parsed["count"] == 5
+
+    def test_serializes_nested_dataclass(self) -> None:
+        """Test nested dataclass serialization via json.dumps."""
+        inner = SimpleDataclass(name="inner", count=10)
+        obj = NestedDataclass(id="123", inner=inner)
+        result = serialize_json(obj)
+        parsed = json.loads(result)
+        assert isinstance(parsed, dict)
+        assert parsed["id"] == "123"
+        assert parsed["inner"]["name"] == "inner"
+        assert parsed["inner"]["count"] == 10
+
+    def test_serializes_enum_string_value(self) -> None:
+        """Test enum with string value via json.dumps."""
+        data = {"color": Color.RED}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["color"] == "red"
+
+    def test_serializes_enum_int_value(self) -> None:
+        """Test enum with int value via json.dumps."""
+        data = {"priority": Priority.HIGH}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["priority"] == 3
+
+    def test_serializes_enum_mixed_value(self) -> None:
+        """Test enum with mixed types via json.dumps."""
+        data = {"color1": Color.GREEN, "color2": Color.BLUE}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["color1"] == "green"
+        assert parsed["color2"] == 3
+
+    def test_serializes_datetime(self) -> None:
+        """Test datetime serialization via json.dumps."""
+        dt = datetime(2024, 1, 15, 10, 30, 45)
+        data = {"timestamp": dt}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["timestamp"], str)
+        assert "2024-01-15" in parsed["timestamp"]
+        assert "10:30:45" in parsed["timestamp"]
+
+    def test_serializes_datetime_with_timezone(self) -> None:
+        """Test datetime with timezone via json.dumps."""
+        dt = datetime(2024, 1, 15, 10, 30, 45, tzinfo=timezone.utc)
+        data = {"timestamp": dt}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["timestamp"], str)
+        assert parsed["timestamp"] == "2024-01-15T10:30:45+00:00"
+
+    def test_serializes_timezone(self) -> None:
+        """Test timezone object serialization via json.dumps."""
+        tz = timezone.utc
+        data = {"timezone": tz}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["timezone"] == "UTC"
+
+    @pytest.mark.skipif(not _has_tzdata(), reason="Timezone data not available")
+    def test_serializes_zoneinfo(self) -> None:
+        """Test ZoneInfo serialization via json.dumps."""
+        tz = ZoneInfo("America/New_York")
+        data = {"timezone": tz}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        # ZoneInfo returns timezone name or None
+        assert isinstance(parsed["timezone"], (str, type(None)))
+
+    def test_serializes_set(self) -> None:
+        """Test set serialization via json.dumps."""
+        obj = {1, 2, 3}
+        data = {"numbers": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["numbers"], list)
+        assert set(parsed["numbers"]) == {1, 2, 3}
+
+    def test_serializes_tuple(self) -> None:
+        """Test tuple serialization via json.dumps."""
+        obj = (1, 2, 3)
+        data = {"numbers": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["numbers"], list)
+        assert parsed["numbers"] == [1, 2, 3]
+
+    def test_serializes_named_tuple(self) -> None:
+        """Test named tuple serialization via json.dumps.
+
+        Note: Python's json encoder treats namedtuples as regular tuples,
+        so they serialize as lists [x, y] rather than dicts {"x": x, "y": y}.
+        The serialize_defaults function is not called for namedtuples
+        because they're natively JSON-serializable as tuples.
+        """
+        point = Point(x=10, y=20)
+        data = {"point": point}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        # Namedtuples serialize as lists through json.dumps
+        assert isinstance(parsed["point"], list)
+        assert parsed["point"] == [10, 20]
+
+    def test_serializes_object_with_as_dict(self) -> None:
+        """Test object with as_dict property via json.dumps."""
+
+        class RuntimeLike:
+            @property
+            def as_dict(self) -> dict[str, Any]:
+                return {"host": "localhost", "port": 8080}
+
+        obj = RuntimeLike()
+        data = {"runtime": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["runtime"] == {"host": "localhost", "port": 8080}
+
+    def test_serializes_object_with_to_dict(self) -> None:
+        """Test object with to_dict method via json.dumps."""
+
+        class CustomObject:
+            def to_dict(self) -> dict[str, Any]:
+                return {"custom": "value"}
+
+        obj = CustomObject()
+        data = {"obj": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["obj"] == {"custom": "value"}
+
+    def test_serializes_unknown_object_to_str(self) -> None:
+        """Test unknown object falls back to str() via json.dumps."""
+
+        class CustomClass:
+            def __str__(self) -> str:
+                return "custom_string"
+
+        obj = CustomClass()
+        data = {"obj": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["obj"] == "custom_string"
+
+    def test_serializes_exception(self) -> None:
+        """Test Exception serialization via json.dumps."""
+        err = ValueError("something went wrong")
+        data = {"error": err}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["error"] == "something went wrong"
+
+    def test_with_json_dumps(self) -> None:
+        """Test integration with json.dumps()."""
+
+        class ComplexObject(BaseModel):
+            name: str
+            created_at: datetime
+            priority: Priority
+
+        obj = ComplexObject(
+            name="task",
+            created_at=datetime(2024, 1, 15, 10, 30),
+            priority=Priority.HIGH,
+        )
+
+        # Should not raise TypeError
+        result = serialize_json(obj)
+        parsed = json.loads(result)
+
+        assert parsed["name"] == "task"
+        assert "2024-01-15" in parsed["created_at"]
+        assert parsed["priority"] == 3
+
+    def test_with_json_dumps_complex_nested(self) -> None:
+        """Test with complex nested structure."""
+        data = {
+            "model": SimpleModel(name="test", value=42),
+            "dataclass": SimpleDataclass(name="dc", count=5),
+            "enum": Color.RED,
+            "datetime": datetime(2024, 1, 1),
+            "set": {1, 2, 3},
+            "tuple": (4, 5, 6),
+            "error": ValueError("something failed"),
+        }
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert parsed["model"]["name"] == "test"
+        assert parsed["dataclass"]["name"] == "dc"
+        assert parsed["enum"] == "red"
+        assert "2024-01-01" in parsed["datetime"]
+        assert set(parsed["set"]) == {1, 2, 3}
+        assert parsed["tuple"] == [4, 5, 6]
+        assert parsed["error"] == "something failed"
+
+    def test_with_list_of_pydantic_models(self) -> None:
+        """Test with list of Pydantic models (common MCP scenario)."""
+        models = [
+            SimpleModel(name="first", value=1),
+            SimpleModel(name="second", value=2),
+            SimpleModel(name="third", value=3),
+        ]
+
+        # This should not raise TypeError
+        result = serialize_json(models)
+        parsed = json.loads(result)
+
+        assert len(parsed) == 3
+        assert parsed[0]["name"] == "first"
+        assert parsed[1]["value"] == 2
+
+    def test_recursive_enum_serialization(self) -> None:
+        """Test that enum values are recursively serialized via json.dumps."""
+
+        class NestedEnum(Enum):
+            """Enum with complex value."""
+
+            COMPLEX = {"key": "value"}
+
+        data = {"enum": NestedEnum.COMPLEX}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        # The enum value itself (a dict) should be returned as-is
+        assert parsed["enum"] == {"key": "value"}
+        assert isinstance(parsed["enum"], dict)
+
+    def test_dataclass_class_returns_string(self) -> None:
+        """Test that dataclass class (not instance) falls back to str via json.dumps."""
+        data = {"dataclass_class": SimpleDataclass}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["dataclass_class"], str)
+        assert "SimpleDataclass" in parsed["dataclass_class"]
+
+    def test_empty_collections(self) -> None:
+        """Test empty collections via json.dumps."""
+        data: dict[str, Any] = {"empty_set": set(), "empty_tuple": (), "empty_list": []}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["empty_set"] == []
+        assert parsed["empty_tuple"] == []
+        assert parsed["empty_list"] == []
+
+    def test_with_dict_method(self) -> None:
+        """Test object with dict() method (Pydantic v1 compatibility) via json.dumps."""
+
+        class OldStyleModel:
+            def dict(self) -> dict[str, Any]:
+                return {"old": "style"}
+
+        obj = OldStyleModel()
+        data = {"obj": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert parsed["obj"] == {"old": "style"}
+
+    def test_dict_of_pydantic_models(self) -> None:
+        """Test dictionary containing Pydantic models as values."""
+        data = {
+            "user1": SimpleModel(name="Alice", value=100),
+            "user2": SimpleModel(name="Bob", value=200),
+            "user3": SimpleModel(name="Charlie", value=300),
+        }
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, dict)
+        assert parsed["user1"]["name"] == "Alice"
+        assert parsed["user1"]["value"] == 100
+        assert parsed["user2"]["name"] == "Bob"
+        assert parsed["user2"]["value"] == 200
+        assert parsed["user3"]["name"] == "Charlie"
+        assert parsed["user3"]["value"] == 300
+
+    def test_dict_of_dataclass_models(self) -> None:
+        """Test dictionary containing dataclass instances as values."""
+        data = {
+            "item1": SimpleDataclass(name="First", count=1),
+            "item2": SimpleDataclass(name="Second", count=2),
+            "item3": SimpleDataclass(name="Third", count=3),
+        }
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, dict)
+        assert parsed["item1"]["name"] == "First"
+        assert parsed["item1"]["count"] == 1
+        assert parsed["item2"]["name"] == "Second"
+        assert parsed["item2"]["count"] == 2
+        assert parsed["item3"]["name"] == "Third"
+        assert parsed["item3"]["count"] == 3
+
+    def test_normal_class_fallback_to_str(self) -> None:
+        """Test normal class (not Pydantic, dataclass, or enum) falls back to str()."""
+
+        class RegularClass:
+            def __init__(self, value: str) -> None:
+                self.value = value
+
+            def __str__(self) -> str:
+                return f"RegularClass({self.value})"
+
+        obj = RegularClass("test_value")
+        data = {"object": obj, "name": "test"}
+        json_result = serialize_json(data)
+        parsed = json.loads(json_result)
+        assert parsed["object"] == "RegularClass(test_value)"
+        assert parsed["name"] == "test"
+
+    def test_list_of_dataclass(self) -> None:
+        """Test list containing dataclass instances."""
+        data = [
+            SimpleDataclass(name="First", count=1),
+            SimpleDataclass(name="Second", count=2),
+            SimpleDataclass(name="Third", count=3),
+        ]
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list)
+        assert len(parsed) == 3
+        assert parsed[0]["name"] == "First"
+        assert parsed[0]["count"] == 1
+        assert parsed[1]["name"] == "Second"
+        assert parsed[2]["count"] == 3
+
+    def test_list_of_pydantic_models(self) -> None:
+        """Test list containing Pydantic model instances."""
+        data = [
+            SimpleModel(name="Alice", value=100),
+            SimpleModel(name="Bob", value=200),
+            SimpleModel(name="Charlie", value=300),
+        ]
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list)
+        assert len(parsed) == 3
+        assert parsed[0]["name"] == "Alice"
+        assert parsed[0]["value"] == 100
+        assert parsed[1]["name"] == "Bob"
+        assert parsed[2]["value"] == 300
+
+    def test_list_of_normal_classes(self) -> None:
+        """Test list containing normal class instances (fallback to str)."""
+
+        class Item:
+            def __init__(self, id: int, label: str) -> None:
+                self.id = id
+                self.label = label
+
+            def __str__(self) -> str:
+                return f"Item(id={self.id}, label={self.label})"
+
+        data = [
+            Item(1, "First"),
+            Item(2, "Second"),
+            Item(3, "Third"),
+        ]
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list)
+        assert len(parsed) == 3
+        assert parsed[0] == "Item(id=1, label=First)"
+        assert parsed[1] == "Item(id=2, label=Second)"
+        assert parsed[2] == "Item(id=3, label=Third)"
+
+    def test_list_of_mixed_types(self) -> None:
+        """Test list containing mixed types: Pydantic, dataclass, normal class, primitives."""
+
+        class CustomItem:
+            def __init__(self, name: str) -> None:
+                self.name = name
+
+            def __str__(self) -> str:
+                return f"CustomItem({self.name})"
+
+        data = [
+            SimpleModel(name="pydantic", value=1),
+            SimpleDataclass(name="dataclass", count=2),
+            CustomItem("custom"),
+            "plain_string",
+            42,
+            True,
+            None,
+            Color.RED,
+        ]
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list)
+        assert len(parsed) == 8
+        # Pydantic model
+        assert parsed[0]["name"] == "pydantic"
+        assert parsed[0]["value"] == 1
+        # Dataclass
+        assert parsed[1]["name"] == "dataclass"
+        assert parsed[1]["count"] == 2
+        # Normal class (str fallback)
+        assert parsed[2] == "CustomItem(custom)"
+        # Primitives
+        assert parsed[3] == "plain_string"
+        assert parsed[4] == 42
+        assert parsed[5] is True
+        assert parsed[6] is None
+        # Enum
+        assert parsed[7] == "red"
+
+    def test_list_of_lists_mixed(self) -> None:
+        """Test nested lists containing mixed types."""
+
+        class Widget:
+            def __init__(self, id: int) -> None:
+                self.id = id
+
+            def __str__(self) -> str:
+                return f"Widget({self.id})"
+
+        data = [
+            [SimpleModel(name="model1", value=1), SimpleModel(name="model2", value=2)],
+            [
+                SimpleDataclass(name="dc1", count=10),
+                SimpleDataclass(name="dc2", count=20),
+            ],
+            [Widget(1), Widget(2), Widget(3)],
+            ["string1", "string2"],
+            [1, 2, 3, 4],
+            [Color.RED, Color.GREEN, Priority.HIGH],
+            [True, False, None],
+        ]
+
+        result = serialize_json(data)
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list)
+        assert len(parsed) == 7
+
+        # First sublist: Pydantic models
+        assert len(parsed[0]) == 2
+        assert parsed[0][0]["name"] == "model1"
+        assert parsed[0][1]["value"] == 2
+
+        # Second sublist: Dataclasses
+        assert len(parsed[1]) == 2
+        assert parsed[1][0]["name"] == "dc1"
+        assert parsed[1][1]["count"] == 20
+
+        # Third sublist: Normal classes
+        assert len(parsed[2]) == 3
+        assert parsed[2][0] == "Widget(1)"
+        assert parsed[2][2] == "Widget(3)"
+
+        # Fourth sublist: Strings
+        assert parsed[3] == ["string1", "string2"]
+
+        # Fifth sublist: Integers
+        assert parsed[4] == [1, 2, 3, 4]
+
+        # Sixth sublist: Enums
+        assert parsed[5] == ["red", "green", 3]
+
+        # Seventh sublist: Booleans and None
+        assert parsed[6] == [True, False, None]
+
+    def test_dataclass_with_unpicklable_field_falls_back_to_str(self) -> None:
+        """Test dataclass containing unpicklable objects (e.g. SimpleQueue) falls back to str().
+
+        dataclasses.asdict() uses copy.deepcopy internally, which fails on objects
+        that cannot be pickled (like _queue.SimpleQueue found in httpx clients).
+        The serializer should gracefully fall back to str() instead of raising.
+        """
+        import queue
+
+        @dataclass
+        class DataclassWithQueue:
+            name: str
+            internal: Any
+
+        obj = DataclassWithQueue(name="test", internal=queue.SimpleQueue())
+        data = {"obj": obj}
+        result = serialize_json(data)
+        parsed = json.loads(result)
+        assert isinstance(parsed["obj"], str)
+        assert "DataclassWithQueue" in parsed["obj"]
diff --git a/packages/uipath-core/tests/tracing/test_external_integration.py b/packages/uipath-core/tests/tracing/test_external_integration.py
new file mode 100644
index 000000000..2c27cf28d
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_external_integration.py
@@ -0,0 +1,89 @@
+"""Test span nesting behavior for traced decorators."""
+
+from opentelemetry import trace
+
+from tests.conftest import SpanCapture
+
+
+def test_external_span_provider_integration(span_capture: SpanCapture):
+    """Test integration with external span provider."""
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+    # Create a mock external span
+    external_tracer = trace.get_tracer("external")
+
+    with external_tracer.start_as_current_span("external_span"):
+        # Register a provider that returns the external span
+        UiPathSpanUtils.register_current_span_provider(lambda: trace.get_current_span())
+
+        @traced(name="internal_span")
+        def internal_function():
+            return "result"
+
+        result = internal_function()
+
+        assert result == "result"
+
+    # Clean up
+    UiPathSpanUtils.register_current_span_provider(None)
+
+    spans = span_capture.get_spans()
+
+    # Should have both external and internal spans
+    internal_span = next((s for s in spans if s.name == "internal_span"), None)
+    external_span_recorded = next((s for s in spans if s.name == "external_span"), None)
+
+    assert internal_span is not None
+    assert external_span_recorded is not None
+
+    # Internal span should be child of external span
+    assert internal_span.parent.span_id == external_span_recorded.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+def test_external_span_provider_returns_none(span_capture: SpanCapture):
+    """Test that None from external span provider is handled."""
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+    # Register a provider that returns None
+    UiPathSpanUtils.register_current_span_provider(lambda: None)
+
+    @traced(name="test_span")
+    def test_function():
+        return "result"
+
+    result = test_function()
+    assert result == "result"
+
+    # Clean up
+    UiPathSpanUtils.register_current_span_provider(None)
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+
+def test_external_span_provider_raises_exception(span_capture: SpanCapture):
+    """Test that exceptions from external span provider are caught."""
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+    def failing_provider():
+        raise RuntimeError("Provider failed!")
+
+    UiPathSpanUtils.register_current_span_provider(failing_provider)
+
+    @traced(name="test_span")
+    def test_function():
+        return "result"
+
+    result = test_function()
+    assert result == "result"
+
+    # Clean up
+    UiPathSpanUtils.register_current_span_provider(None)
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
diff --git a/packages/uipath-core/tests/tracing/test_serialization.py b/packages/uipath-core/tests/tracing/test_serialization.py
new file mode 100644
index 000000000..7f04daf6f
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_serialization.py
@@ -0,0 +1,171 @@
+import json
+
+from tests.conftest import SpanCapture
+
+
+def test_traced_with_pydantic_model_input(span_capture: SpanCapture):
+    """Test tracing with Pydantic model as input."""
+    from pydantic import BaseModel
+
+    from uipath.core.tracing.decorators import traced
+
+    class UserModel(BaseModel):
+        name: str
+        age: int
+
+    @traced(name="process_user")
+    def process_user(user: UserModel):
+        return f"{user.name} is {user.age}"
+
+    user = UserModel(name="Alice", age=30)
+    result = process_user(user)
+
+    assert result == "Alice is 30"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    # Verify input was serialized
+    input_value = span.attributes.get("input.value")
+    assert input_value is not None
+    input_data = json.loads(input_value)
+    assert input_data["user"]["name"] == "Alice"
+    assert input_data["user"]["age"] == 30
+
+
+def test_traced_with_dataclass_input(span_capture: SpanCapture):
+    """Test tracing with dataclass as input."""
+    from dataclasses import dataclass
+
+    from uipath.core.tracing.decorators import traced
+
+    @dataclass
+    class Product:
+        name: str
+        price: float
+
+    @traced(name="calculate_total")
+    def calculate_total(product: Product, quantity: int):
+        return product.price * quantity
+
+    product = Product(name="Widget", price=9.99)
+    result = calculate_total(product, 5)
+
+    assert result == 49.95
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    input_value = span.attributes.get("input.value")
+    assert input_value is not None
+    input_data = json.loads(input_value)
+    assert input_data["product"]["name"] == "Widget"
+    assert input_data["product"]["price"] == 9.99
+
+
+def test_traced_with_enum_input(span_capture: SpanCapture):
+    """Test tracing with enum as input."""
+    from enum import Enum
+
+    from uipath.core.tracing.decorators import traced
+
+    class Status(Enum):
+        PENDING = "pending"
+        COMPLETED = "completed"
+
+    @traced(name="update_status")
+    def update_status(status: Status):
+        return f"Status is {status.value}"
+
+    result = update_status(Status.COMPLETED)
+
+    assert result == "Status is completed"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    input_value = span.attributes.get("input.value")
+    assert input_value is not None
+    input_data = json.loads(input_value)
+    assert input_data["status"] == "completed"
+
+
+def test_traced_with_datetime_input(span_capture: SpanCapture):
+    """Test tracing with datetime as input."""
+    from datetime import datetime
+
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="process_timestamp")
+    def process_timestamp(timestamp: datetime):
+        return timestamp.isoformat()
+
+    dt = datetime(2024, 1, 15, 10, 30, 0)
+    process_timestamp(dt)
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    input_value = span.attributes.get("input.value")
+    assert input_value is not None
+    input_data = json.loads(input_value)
+    assert "2024-01-15" in input_data["timestamp"]
+
+
+def test_traced_with_complex_return_value(span_capture: SpanCapture):
+    """Test tracing with complex return value."""
+    from typing import Any
+
+    from pydantic import BaseModel
+
+    from uipath.core.tracing.decorators import traced
+
+    class Result(BaseModel):
+        success: bool
+        data: dict[str, Any]
+
+    @traced(name="get_result")
+    def get_result():
+        return Result(success=True, data={"key": "value"})
+
+    get_result()
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    output_value = span.attributes.get("output.value")
+    assert output_value is not None
+    output_data = json.loads(output_value)
+    assert output_data["success"] is True
+    assert output_data["data"]["key"] == "value"
+
+
+def test_traced_with_set_and_tuple(span_capture: SpanCapture):
+    """Test tracing with set and tuple inputs."""
+    from typing import Set, Tuple
+
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="process_collections")
+    def process_collections(items: Set[int], pair: Tuple[int, ...]) -> int:
+        return len(items) + len(pair)
+
+    result = process_collections({1, 2, 3}, (4, 5))
+
+    assert result == 5
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 1
+
+    span = spans[0]
+    input_value = span.attributes.get("input.value")
+    assert input_value is not None
+    input_data = json.loads(input_value)
+    # Sets and tuples should be converted to lists
+    assert isinstance(input_data["items"], list)
+    assert isinstance(input_data["pair"], list)
diff --git a/packages/uipath-core/tests/tracing/test_span_filtering.py b/packages/uipath-core/tests/tracing/test_span_filtering.py
new file mode 100644
index 000000000..1c6efabf2
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_span_filtering.py
@@ -0,0 +1,248 @@
+"""Tests for span filtering in trace manager and processors."""
+
+from opentelemetry import trace
+
+from uipath.core.tracing.trace_manager import UiPathTraceManager
+from uipath.core.tracing.types import UiPathTraceSettings
+
+
+class TestSpanFiltering:
+    """Tests for span filtering functionality."""
+
+    def test_no_filter_exports_all_spans(self):
+        """Test that without a filter, all spans are exported."""
+        trace_manager = UiPathTraceManager()
+
+        tracer = trace.get_tracer("test")
+        with trace_manager.start_execution_span("root", "exec-1"):
+            with tracer.start_as_current_span("child-1"):
+                pass
+            with tracer.start_as_current_span("child-2"):
+                pass
+
+        spans = trace_manager.get_execution_spans("exec-1")
+        assert len(spans) == 3
+        span_names = {s.name for s in spans}
+        assert span_names == {"root", "child-1", "child-2"}
+
+    def test_filter_drops_non_matching_spans(self):
+        """Test that filter drops spans that don't match the predicate."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter = MagicMock(spec=SpanExporter)
+        mock_exporter.export.return_value = SpanExportResult.SUCCESS
+
+        settings = UiPathTraceSettings(
+            span_filter=lambda span: (
+                span.attributes is not None and span.attributes.get("keep") is True
+            )
+        )
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(mock_exporter, batch=False, settings=settings)
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span("kept", attributes={"keep": True}):
+            pass
+        with tracer.start_as_current_span("dropped", attributes={"keep": False}):
+            pass
+        with tracer.start_as_current_span("also-dropped"):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_spans = []
+        for call in mock_exporter.export.call_args_list:
+            exported_spans.extend(call[0][0])
+
+        exported_names = {s.name for s in exported_spans}
+        assert "kept" in exported_names
+        assert "dropped" not in exported_names
+        assert "also-dropped" not in exported_names
+
+    def test_filter_by_span_name(self):
+        """Test filtering spans by name pattern."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter = MagicMock(spec=SpanExporter)
+        mock_exporter.export.return_value = SpanExportResult.SUCCESS
+
+        settings = UiPathTraceSettings(
+            span_filter=lambda span: span.name.startswith("uipath.")
+        )
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(mock_exporter, batch=False, settings=settings)
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span("uipath.action"):
+            pass
+        with tracer.start_as_current_span("uipath.tool"):
+            pass
+        with tracer.start_as_current_span("http.request"):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_spans = []
+        for call in mock_exporter.export.call_args_list:
+            exported_spans.extend(call[0][0])
+
+        exported_names = {s.name for s in exported_spans}
+        assert "uipath.action" in exported_names
+        assert "uipath.tool" in exported_names
+        assert "http.request" not in exported_names
+
+    def test_filter_custom_instrumentation_attribute(self):
+        """Test filtering by custom instrumentation attribute (low-code scenario)."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter = MagicMock(spec=SpanExporter)
+        mock_exporter.export.return_value = SpanExportResult.SUCCESS
+
+        settings = UiPathTraceSettings(
+            span_filter=lambda span: bool(
+                span.attributes and span.attributes.get("uipath.custom_instrumentation")
+            )
+        )
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(mock_exporter, batch=False, settings=settings)
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span(
+            "custom-span",
+            attributes={"uipath.custom_instrumentation": True},
+        ):
+            pass
+        with tracer.start_as_current_span(
+            "auto-instrumented",
+            attributes={"http.method": "GET"},
+        ):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_spans = []
+        for call in mock_exporter.export.call_args_list:
+            exported_spans.extend(call[0][0])
+
+        exported_names = {s.name for s in exported_spans}
+        assert "custom-span" in exported_names
+        assert "auto-instrumented" not in exported_names
+
+    def test_none_filter_same_as_no_filter(self):
+        """Test that explicit None filter behaves same as no filter."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter = MagicMock(spec=SpanExporter)
+        mock_exporter.export.return_value = SpanExportResult.SUCCESS
+
+        settings = UiPathTraceSettings(span_filter=None)
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(mock_exporter, batch=False, settings=settings)
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span("span-1"):
+            pass
+        with tracer.start_as_current_span("span-2"):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_spans = []
+        for call in mock_exporter.export.call_args_list:
+            exported_spans.extend(call[0][0])
+
+        assert len(exported_spans) == 2
+
+    def test_filter_with_empty_attributes(self):
+        """Test that filter handles spans with no attributes gracefully."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter = MagicMock(spec=SpanExporter)
+        mock_exporter.export.return_value = SpanExportResult.SUCCESS
+
+        settings = UiPathTraceSettings(
+            span_filter=lambda span: (
+                span.attributes is not None and span.attributes.get("required") is True
+            )
+        )
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(mock_exporter, batch=False, settings=settings)
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span("no-attrs"):
+            pass
+        with tracer.start_as_current_span(
+            "has-required", attributes={"required": True}
+        ):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_spans = []
+        for call in mock_exporter.export.call_args_list:
+            exported_spans.extend(call[0][0])
+
+        exported_names = {s.name for s in exported_spans}
+        assert "has-required" in exported_names
+        assert "no-attrs" not in exported_names
+
+    def test_different_filters_per_exporter(self):
+        """Test that different exporters can have different filters."""
+        from unittest.mock import MagicMock
+
+        from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+        mock_exporter_a = MagicMock(spec=SpanExporter)
+        mock_exporter_a.export.return_value = SpanExportResult.SUCCESS
+
+        mock_exporter_b = MagicMock(spec=SpanExporter)
+        mock_exporter_b.export.return_value = SpanExportResult.SUCCESS
+
+        settings_a = UiPathTraceSettings(
+            span_filter=lambda span: (
+                span.attributes is not None and span.attributes.get("dest") == "a"
+            )
+        )
+        settings_b = UiPathTraceSettings(
+            span_filter=lambda span: (
+                span.attributes is not None and span.attributes.get("dest") == "b"
+            )
+        )
+
+        trace_manager = UiPathTraceManager()
+        trace_manager.add_span_exporter(
+            mock_exporter_a, batch=False, settings=settings_a
+        )
+        trace_manager.add_span_exporter(
+            mock_exporter_b, batch=False, settings=settings_b
+        )
+
+        tracer = trace.get_tracer("test")
+        with tracer.start_as_current_span("to-a", attributes={"dest": "a"}):
+            pass
+        with tracer.start_as_current_span("to-b", attributes={"dest": "b"}):
+            pass
+        with tracer.start_as_current_span("to-neither", attributes={"dest": "c"}):
+            pass
+
+        trace_manager.flush_spans()
+
+        exported_a = []
+        for call in mock_exporter_a.export.call_args_list:
+            exported_a.extend(call[0][0])
+        assert {s.name for s in exported_a} == {"to-a"}
+
+        exported_b = []
+        for call in mock_exporter_b.export.call_args_list:
+            exported_b.extend(call[0][0])
+        assert {s.name for s in exported_b} == {"to-b"}
diff --git a/packages/uipath-core/tests/tracing/test_span_nesting.py b/packages/uipath-core/tests/tracing/test_span_nesting.py
new file mode 100644
index 000000000..7245f648a
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_span_nesting.py
@@ -0,0 +1,650 @@
+"""Test span nesting behavior for traced decorators."""
+
+import pytest
+
+from tests.conftest import SpanCapture
+
+
+def test_simple_sync_nesting(span_capture: SpanCapture):
+    """Test that nested sync functions create proper parent-child relationships."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="outer")
+    def outer_function():
+        return inner_function()
+
+    @traced(name="inner")
+    def inner_function():
+        return "result"
+
+    result = outer_function()
+
+    assert result == "result"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 2, f"Expected 2 spans, got {len(spans)}"
+
+    # Find spans by name
+    inner_span = next(s for s in spans if s.name == "inner")
+    outer_span = next(s for s in spans if s.name == "outer")
+
+    # Verify parent-child relationship
+    assert inner_span.parent is not None, "Inner span should have a parent"
+    assert inner_span.parent.span_id == outer_span.context.span_id, (
+        "Inner span's parent should be outer span"
+    )
+
+    # Verify they're in the same trace
+    assert inner_span.context.trace_id == outer_span.context.trace_id, (
+        "Spans should be in the same trace"
+    )
+
+    span_capture.print_hierarchy()
+
+
+def test_deep_sync_nesting(span_capture: SpanCapture):
+    """Test deeply nested sync functions."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="level1")
+    def level1():
+        return level2()
+
+    @traced(name="level2")
+    def level2():
+        return level3()
+
+    @traced(name="level3")
+    def level3():
+        return "deep_result"
+
+    result = level1()
+
+    assert result == "deep_result"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 3, f"Expected 3 spans, got {len(spans)}"
+
+    # Find spans
+    level1_span = next(s for s in spans if s.name == "level1")
+    level2_span = next(s for s in spans if s.name == "level2")
+    level3_span = next(s for s in spans if s.name == "level3")
+
+    # Verify chain: level1 -> level2 -> level3
+    assert level1_span.parent is None, "Level1 should be root"
+    assert level2_span.parent.span_id == level1_span.context.span_id
+    assert level3_span.parent.span_id == level2_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+@pytest.mark.asyncio
+async def test_async_nesting(span_capture: SpanCapture):
+    """Test that nested async functions create proper parent-child relationships."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="async_outer")
+    async def async_outer():
+        return await async_inner()
+
+    @traced(name="async_inner")
+    async def async_inner():
+        return "async_result"
+
+    result = await async_outer()
+
+    assert result == "async_result"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 2, f"Expected 2 spans, got {len(spans)}"
+
+    inner_span = next(s for s in spans if s.name == "async_inner")
+    outer_span = next(s for s in spans if s.name == "async_outer")
+
+    assert inner_span.parent is not None
+    assert inner_span.parent.span_id == outer_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+@pytest.mark.asyncio
+async def test_mixed_sync_async_nesting(span_capture: SpanCapture):
+    """Test mixing sync and async traced functions."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="async_root")
+    async def async_root():
+        return await async_child()
+
+    @traced(name="async_child")
+    async def async_child():
+        return sync_child()
+
+    @traced(name="sync_child")
+    def sync_child():
+        return "mixed_result"
+
+    result = await async_root()
+
+    assert result == "mixed_result"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 3
+
+    # Verify hierarchy
+    async_root_span = next(s for s in spans if s.name == "async_root")
+    async_child_span = next(s for s in spans if s.name == "async_child")
+    sync_child_span = next(s for s in spans if s.name == "sync_child")
+
+    assert async_child_span.parent.span_id == async_root_span.context.span_id
+    assert sync_child_span.parent.span_id == async_child_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+def test_multiple_calls_same_function(span_capture: SpanCapture):
+    """Test that multiple calls to the same function create separate spans."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="called_multiple_times")
+    def reusable_function(value):
+        return value * 2
+
+    @traced(name="caller")
+    def caller():
+        result1 = reusable_function(5)
+        result2 = reusable_function(10)
+        return result1 + result2
+
+    result = caller()
+
+    assert result == 30
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 3, f"Expected 3 spans (1 caller + 2 calls), got {len(spans)}"
+
+    # Find the caller span
+    caller_span = next(s for s in spans if s.name == "caller")
+
+    # Both reusable_function calls should be children of caller
+    reusable_spans = [s for s in spans if s.name == "called_multiple_times"]
+    assert len(reusable_spans) == 2
+
+    for reusable_span in reusable_spans:
+        assert reusable_span.parent.span_id == caller_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+def test_sibling_functions(span_capture: SpanCapture):
+    """Test that sibling function calls are handled correctly."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="sibling1")
+    def sibling1():
+        return "s1"
+
+    @traced(name="sibling2")
+    def sibling2():
+        return "s2"
+
+    @traced(name="parent")
+    def parent():
+        r1 = sibling1()
+        r2 = sibling2()
+        return r1 + r2
+
+    result = parent()
+
+    assert result == "s1s2"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 3
+
+    parent_span = next(s for s in spans if s.name == "parent")
+    sibling1_span = next(s for s in spans if s.name == "sibling1")
+    sibling2_span = next(s for s in spans if s.name == "sibling2")
+
+    # Both siblings should have the same parent
+    assert sibling1_span.parent.span_id == parent_span.context.span_id
+    assert sibling2_span.parent.span_id == parent_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+def test_generator_nesting(span_capture: SpanCapture):
+    """Test that generator functions maintain proper span nesting."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="generator_parent")
+    def generator_parent():
+        results = list(generator_child())
+        return sum(results)
+
+    @traced(name="generator_child")
+    def generator_child():
+        for i in range(3):
+            yield i * 2
+
+    result = generator_parent()
+
+    assert result == 6  # 0 + 2 + 4
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 2
+
+    parent_span = next(s for s in spans if s.name == "generator_parent")
+    child_span = next(s for s in spans if s.name == "generator_child")
+
+    assert child_span.parent.span_id == parent_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+@pytest.mark.asyncio
+async def test_async_generator_nesting(span_capture: SpanCapture):
+    """Test async generator nesting."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="async_gen_parent")
+    async def async_gen_parent():
+        results = []
+        async for item in async_gen_child():
+            results.append(item)
+        return sum(results)
+
+    @traced(name="async_gen_child")
+    async def async_gen_child():
+        for i in range(3):
+            yield i * 3
+
+    result = await async_gen_parent()
+
+    assert result == 9  # 0 + 3 + 6
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 2
+
+    parent_span = next(s for s in spans if s.name == "async_gen_parent")
+    child_span = next(s for s in spans if s.name == "async_gen_child")
+
+    assert child_span.parent.span_id == parent_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+
+def test_non_recording_blocks_children(span_capture: SpanCapture):
+    """Test that recording=False on parent prevents children from being recorded."""
+    from uipath.core.tracing.decorators import traced
+
+    @traced(name="non_recording_parent", recording=False)
+    def non_recording_parent():
+        return recording_child()
+
+    @traced(name="recording_child")
+    def recording_child():
+        return "result"
+
+    result = non_recording_parent()
+
+    assert result == "result"
+
+    spans = span_capture.get_spans()
+    # When parent has recording=False, children are also not recorded due to ParentBased sampler
+    assert len(spans) == 0, (
+        f"Expected 0 spans, but got {len(spans)}: {[s.name for s in spans]}"
+    )
+
+    span_capture.print_hierarchy()
+
+
+def test_nested_non_recording_parents_with_external_span(span_capture: SpanCapture):
+    """Test nested non-recording parents maintain hierarchy with external span provider.
+
+    Scenario:
+    1. External system (like LangGraph) creates a span manually
+    2. Inside, @traced(recording=False) creates non-recording parent 1
+    3. Inside that, @traced(recording=False) creates non-recording parent 2
+    4. Inside that, @traced(recording=True) creates recording child
+
+    Validates that the hierarchy is preserved:
+    - non-recording parent 1 should have external_span as parent
+    - non-recording parent 2 should have non-recording parent 1 as parent
+    - Recording child should recognize non-recording parent 2 as the deeper parent
+    """
+    from opentelemetry import trace
+
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils, _span_registry
+
+    # Simulate external system (like LangGraph) creating a span manually
+    external_tracer = trace.get_tracer("external_system")
+    with external_tracer.start_as_current_span("external_span") as external_span:
+        stored_external_span = external_span
+
+        # Register this as the external span provider
+        UiPathSpanUtils.register_current_span_provider(lambda: stored_external_span)
+
+        try:
+
+            @traced(name="non_recording_parent_1", recording=False)
+            def non_recording_parent_1():
+                return non_recording_parent_2()
+
+            @traced(name="non_recording_parent_2", recording=False)
+            def non_recording_parent_2():
+                return recording_child()
+
+            @traced(name="recording_child", recording=True)
+            def recording_child():
+                return "child_result"
+
+            result = non_recording_parent_1()
+            assert result == "child_result"
+
+            external_span_id = stored_external_span.get_span_context().span_id
+        finally:
+            UiPathSpanUtils.register_current_span_provider(None)
+
+    spans = span_capture.get_spans()
+
+    # Should have: external_span only (non-recording spans aren't recorded)
+    external_span_recorded = next((s for s in spans if s.name == "external_span"), None)
+    assert external_span_recorded is not None, "external_span should be recorded"
+
+    # Find non-recording parents in SpanRegistry
+    non_recording_parent_1_id = None
+    non_recording_parent_2_id = None
+
+    for span_id, parent_id in _span_registry._parent_map.items():
+        stored_span = _span_registry.get_span(span_id)
+        if stored_span is not None:
+            # Find parent 1 (direct child of external_span)
+            if parent_id == external_span_id:
+                non_recording_parent_1_id = span_id
+            # Find parent 2 (child of parent 1)
+            elif (
+                parent_id == non_recording_parent_1_id
+                and non_recording_parent_1_id is not None
+            ):
+                non_recording_parent_2_id = span_id
+
+    assert non_recording_parent_1_id is not None, (
+        "BUG: non_recording_parent_1 should be registered in SpanRegistry "
+        "with external_span as its parent"
+    )
+    assert non_recording_parent_2_id is not None, (
+        "BUG: non_recording_parent_2 should be registered in SpanRegistry "
+        "with non_recording_parent_1 as its parent"
+    )
+
+    # Verify the hierarchy and depths
+    parent_1_parent = _span_registry.get_parent_id(non_recording_parent_1_id)
+    parent_2_parent = _span_registry.get_parent_id(non_recording_parent_2_id)
+
+    assert parent_1_parent == external_span_id, (
+        f"non_recording_parent_1 should have external_span as parent, "
+        f"got {parent_1_parent}"
+    )
+    assert parent_2_parent == non_recording_parent_1_id, (
+        f"non_recording_parent_2 should have non_recording_parent_1 as parent, "
+        f"got {parent_2_parent}"
+    )
+
+    # Verify depths: external=0, parent_1=1, parent_2=2
+    external_depth = _span_registry.calculate_depth(external_span_id)
+    parent_1_depth = _span_registry.calculate_depth(non_recording_parent_1_id)
+    parent_2_depth = _span_registry.calculate_depth(non_recording_parent_2_id)
+
+    assert external_depth == 0, (
+        f"External span should have depth 0, got {external_depth}"
+    )
+    assert parent_1_depth == 1, (
+        f"non_recording_parent_1 should have depth 1 (parent=external), got {parent_1_depth}"
+    )
+    assert parent_2_depth == 2, (
+        f"non_recording_parent_2 should have depth 2 (parent=parent_1), got {parent_2_depth}"
+    )
+
+    # Verify the fix: _get_bottom_most_span should recognize parent 2 as deepest
+    # This simulates what child calls get_parent_context()
+    current_span_mock = _span_registry.get_span(non_recording_parent_2_id)
+    external_span_mock = external_span_recorded
+
+    if current_span_mock is not None:
+        bottom_span = UiPathSpanUtils._get_bottom_most_span(
+            current_span_mock, external_span_mock
+        )
+        assert bottom_span.get_span_context().span_id == non_recording_parent_2_id, (
+            "BUG: _get_bottom_most_span should return non_recording_parent_2 (deepest), "
+            f"but returned {bottom_span.get_span_context().span_id}"
+        )
+
+    _span_registry.clear()
+    span_capture.print_hierarchy()
+
+
+def test_non_recording_parent_picks_external_when_outside_context(
+    span_capture: SpanCapture,
+):
+    """Test that non-recording parent correctly picks external span when called outside OTel context.
+
+    Scenario:
+    1. External span provider is registered and stored
+    2. Exit the OTel context (so trace.get_current_span() returns default/invalid)
+    3. @traced(recording=False) is called OUTSIDE the context
+
+    The test: Non-recording parent should have the external span as parent.
+
+    This test fails with: parent_context = trace.get_current_span().get_span_context()
+    Because outside the context, trace.get_current_span() returns a default NonRecordingSpan,
+    not the external span we want.
+
+    This test passes with: parent_context from get_parent_context() logic
+    Because get_parent_context() checks both current (invalid) and external (valid),
+    and picks the external one.
+    """
+    from opentelemetry import trace
+
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils, _span_registry
+
+    # Create external span INSIDE a context
+    external_tracer = trace.get_tracer("external_system")
+    external_span_cm = external_tracer.start_as_current_span("external_span")
+    external_span = external_span_cm.__enter__()
+    external_span_id = external_span.get_span_context().span_id
+
+    # Store and register the external span
+    stored_external_span = external_span
+    UiPathSpanUtils.register_current_span_provider(lambda: stored_external_span)
+
+    # Exit the OTel context manager
+    external_span_cm.__exit__(None, None, None)
+
+    # NOW we're OUTSIDE the context - trace.get_current_span() returns default/invalid
+    # But the external provider is still active
+
+    try:
+
+        @traced(name="non_recording_parent", recording=False)
+        def non_recording_parent():
+            return "result"
+
+        result = non_recording_parent()
+        assert result == "result"
+
+        # The non-recording parent should have the external span as parent
+        # NOT the invalid span from trace.get_current_span()
+        non_recording_parent_id = None
+        for span_id, parent_id in _span_registry._parent_map.items():
+            if parent_id == external_span_id:
+                stored_span = _span_registry.get_span(span_id)
+                if stored_span is not None:
+                    non_recording_parent_id = span_id
+                    break
+
+        assert non_recording_parent_id is not None, (
+            "Non-recording parent should be parented to external_span. "
+            "With trace.get_current_span() directly, it would pick an invalid/default span instead."
+        )
+
+        # Verify hierarchy
+        non_recording_depth = _span_registry.calculate_depth(non_recording_parent_id)
+        external_depth = _span_registry.calculate_depth(external_span_id)
+
+        assert external_depth == 0, (
+            f"External span should have depth 0, got {external_depth}"
+        )
+        assert non_recording_depth == 1, (
+            f"Non-recording parent should have depth 1 (parent=external), got {non_recording_depth}"
+        )
+
+        _span_registry.clear()
+    finally:
+        UiPathSpanUtils.register_current_span_provider(None)
+
+
+def test_ctx_parameter_required_when_external_deeper_than_current(
+    span_capture: SpanCapture,
+):
+    """Test that trace.get_current_span(ctx) is required when external span is deeper.
+
+    Scenario:
+    1. Create an external span (depth 0)
+    2. Create a deeper nested external span (depth 1) - this becomes current external
+    3. Create an OTel span INSIDE the deepest external context
+    4. Register the deepest external span as the external provider
+    5. Create a non-recording span
+
+    Expected behavior with trace.get_current_span(ctx):
+    - get_parent_context() compares: current OTel span vs external span
+    - External span is deeper (depth 1), so it's chosen
+    - trace.get_current_span(ctx) gets the external span from ctx
+    - Non-recording span is parented to external
+
+    Bug with trace.get_current_span() without ctx:
+    - trace.get_current_span() (no args) returns the OTel span (from thread-local)
+    - Non-recording span gets parented to OTel span (wrong!)
+
+    This test PASSES with the fix (ctx parameter) and FAILS without it.
+    """
+    from opentelemetry import trace
+
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import UiPathSpanUtils, _span_registry
+
+    # Step 1: Create external span hierarchy
+    external_tracer = trace.get_tracer("external_system")
+
+    # Create external_root (depth 0)
+    external_root_cm = external_tracer.start_as_current_span("external_root")
+    external_root = external_root_cm.__enter__()
+    external_root_id = external_root.get_span_context().span_id
+
+    # Create external_deep (depth 1) - child of external_root
+    external_deep_cm = external_tracer.start_as_current_span("external_deep")
+    external_deep = external_deep_cm.__enter__()
+    external_deep_id = external_deep.get_span_context().span_id
+
+    # Register external_deep as the external provider BEFORE exiting context
+    UiPathSpanUtils.register_current_span_provider(lambda: external_deep)
+
+    # Exit the external context to create a separate branch
+    external_deep_cm.__exit__(None, None, None)
+    external_root_cm.__exit__(None, None, None)
+
+    # NOW create OTel span in a SEPARATE context (not inside external_deep)
+    otel_tracer = trace.get_tracer(__name__)
+    otel_span_cm = otel_tracer.start_as_current_span("otel_span")
+    otel_span = otel_span_cm.__enter__()
+    otel_span_id = otel_span.get_span_context().span_id
+
+    try:
+        from uipath.core.tracing.span_utils import ParentedNonRecordingSpan
+
+        # Register external spans with parent relationship
+        _span_registry.register_span(external_root)
+        _span_registry.register_span(external_deep)
+
+        # Register OTel span as ParentedNonRecordingSpan with NO parent
+        # (This simulates OTel span in a separate branch)
+        otel_span_context = otel_span.get_span_context()
+        otel_span_tracked = ParentedNonRecordingSpan(otel_span_context, parent=None)
+        _span_registry.register_span(otel_span_tracked)
+
+        # Verify depths
+        external_root_depth = _span_registry.calculate_depth(external_root_id)
+        external_deep_depth = _span_registry.calculate_depth(external_deep_id)
+        otel_depth = _span_registry.calculate_depth(otel_span_id)
+
+        assert external_root_depth == 0, (
+            f"External root depth should be 0, got {external_root_depth}"
+        )
+        assert external_deep_depth == 1, (
+            f"External deep depth should be 1, got {external_deep_depth}"
+        )
+        assert otel_depth == 0, (
+            f"OTel span depth should be 0 (no parent), got {otel_depth}"
+        )
+
+        # Verify external_deep is deeper than otel_span
+        assert external_deep_depth > otel_depth, (
+            "External deep should be deeper than otel span"
+        )
+
+        # Create non-recording span INSIDE the otel_span context
+        @traced(name="non_recording_inside_otel", recording=False)
+        def non_recording_func():
+            # Add a recording child inside the non-recording parent
+            return recording_child_func()
+
+        @traced(name="recording_child_of_non_recording", recording=True)
+        def recording_child_func():
+            return "child_result"
+
+        result = non_recording_func()
+        assert result == "child_result"
+
+        # Get all spans captured
+        captured_spans = span_capture.get_spans()
+
+        # Verify that neither non-recording nor its recording child are in the captured spans
+        # (because the parent was non-recording, children should not be recorded per ParentBased sampler)
+        captured_span_names = [s.name for s in captured_spans]
+        assert "non_recording_inside_otel" not in captured_span_names, (
+            "Non-recording span should not be captured in span_capture"
+        )
+        assert "recording_child_of_non_recording" not in captured_span_names, (
+            "Recording child of non-recording parent should not be captured due to ParentBased sampler"
+        )
+
+        # Step 2: Verify the non-recording span was parented to external_deep (deeper)
+        # NOT to otel_span (which is current in thread-local context)
+        non_recording_id = None
+        for span_id, parent_id in _span_registry._parent_map.items():
+            stored_span = _span_registry.get_span(span_id)
+            if stored_span is not None and parent_id == external_deep_id:
+                non_recording_id = span_id
+                break
+
+        assert non_recording_id is not None, (
+            "CRITICAL: Non-recording span should be parented to external_deep (deeper). "
+            "This requires using trace.get_current_span(ctx) NOT trace.get_current_span(). "
+            "With trace.get_current_span() alone, it would pick the OTel span "
+            "(which is current in thread-local context), not the external span."
+        )
+
+        # Verify it's NOT parented to the OTel span
+        for _span_id, parent_id in _span_registry._parent_map.items():
+            if parent_id == otel_span_id:
+                raise AssertionError(
+                    "Non-recording span should NOT be parented to otel_span. "
+                    "This indicates trace.get_current_span() was used instead of trace.get_current_span(ctx)."
+                )
+
+        _span_registry.clear()
+
+    finally:
+        otel_span_cm.__exit__(None, None, None)
+        UiPathSpanUtils.register_current_span_provider(None)
diff --git a/packages/uipath-core/tests/tracing/test_span_registry.py b/packages/uipath-core/tests/tracing/test_span_registry.py
new file mode 100644
index 000000000..544c89303
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_span_registry.py
@@ -0,0 +1,290 @@
+"""Test span registry and parent context resolution."""
+
+from opentelemetry.trace import Span
+
+from tests.conftest import SpanCapture
+from uipath.core.tracing.decorators import traced
+from uipath.core.tracing.span_utils import UiPathSpanUtils, _span_registry
+
+
+def test_nested_traced_functions_with_external_context(span_capture: SpanCapture):
+    """Test nested traced functions when external span context is provided.
+
+    Simulates the scenario where:
+    - An external tracing system (like LangGraph) has active spans
+    - Our traced decorators create OTel spans
+    - The registry determines which span is deeper
+    """
+
+    external_span_stack: list[Span] = []
+
+    def mock_external_span_provider():
+        return external_span_stack[-1] if external_span_stack else None
+
+    def mock_ancestors_provider():
+        return list(external_span_stack)
+
+    UiPathSpanUtils.register_current_span_provider(mock_external_span_provider)
+    UiPathSpanUtils.register_current_span_ancestors_provider(mock_ancestors_provider)
+
+    @traced(name="root")
+    def root():
+        spans = span_capture.get_spans()
+        if spans:
+            external_span_stack.append(spans[-1])
+
+        result = level1()
+
+        if external_span_stack:
+            external_span_stack.pop()
+
+        return result
+
+    @traced(name="level1")
+    def level1():
+        return level2()
+
+    @traced(name="level2")
+    def level2():
+        return level3()
+
+    @traced(name="level3")
+    def level3():
+        return level4()
+
+    @traced(name="level4")
+    def level4():
+        return level5()
+
+    @traced(name="level5")
+    def level5():
+        return "done"
+
+    result = root()
+
+    assert result == "done"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 6, f"Expected 6 spans, got {len(spans)}"
+
+    root_span = next(s for s in spans if s.name == "root")
+    level1_span = next(s for s in spans if s.name == "level1")
+    level2_span = next(s for s in spans if s.name == "level2")
+    level3_span = next(s for s in spans if s.name == "level3")
+    level4_span = next(s for s in spans if s.name == "level4")
+    level5_span = next(s for s in spans if s.name == "level5")
+
+    # Verify hierarchy
+    assert root_span.parent is None, "Root should have no parent"
+    assert level1_span.parent is not None
+    assert level1_span.parent.span_id == root_span.context.span_id
+    assert level2_span.parent is not None
+    assert level2_span.parent.span_id == level1_span.context.span_id
+    assert level3_span.parent is not None
+    assert level3_span.parent.span_id == level2_span.context.span_id
+    assert level4_span.parent is not None
+    assert level4_span.parent.span_id == level3_span.context.span_id
+    assert level5_span.parent is not None
+    assert level5_span.parent.span_id == level4_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+    # Cleanup
+    UiPathSpanUtils.register_current_span_provider(None)
+    UiPathSpanUtils.register_current_span_ancestors_provider(None)
+
+
+def test_span_registry_depth_calculation(span_capture: SpanCapture):
+    """Test that the span registry correctly calculates span depths."""
+    from uipath.core.tracing.decorators import traced
+    from uipath.core.tracing.span_utils import _span_registry
+
+    @traced(name="depth0")
+    def depth0():
+        return depth1()
+
+    @traced(name="depth1")
+    def depth1():
+        return depth2()
+
+    @traced(name="depth2")
+    def depth2():
+        return depth3()
+
+    @traced(name="depth3")
+    def depth3():
+        return "max_depth"
+
+    result = depth0()
+
+    assert result == "max_depth"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 4
+
+    # Register all spans in the registry
+    for span in spans:
+        _span_registry.register_span(span)
+
+    # Get span IDs
+    depth0_span = next(s for s in spans if s.name == "depth0")
+    depth1_span = next(s for s in spans if s.name == "depth1")
+    depth2_span = next(s for s in spans if s.name == "depth2")
+    depth3_span = next(s for s in spans if s.name == "depth3")
+
+    # Verify depths
+    assert _span_registry.calculate_depth(depth0_span.context.span_id) == 0
+    assert _span_registry.calculate_depth(depth1_span.context.span_id) == 1
+    assert _span_registry.calculate_depth(depth2_span.context.span_id) == 2
+    assert _span_registry.calculate_depth(depth3_span.context.span_id) == 3
+
+    span_capture.print_hierarchy()
+
+
+def test_span_registry_is_ancestor(span_capture: SpanCapture):
+    """Test that the span registry correctly identifies ancestor relationships."""
+
+    @traced(name="grandparent")
+    def grandparent():
+        return parent()
+
+    @traced(name="parent")
+    def parent():
+        return child()
+
+    @traced(name="child")
+    def child():
+        return "leaf"
+
+    result = grandparent()
+
+    assert result == "leaf"
+
+    spans = span_capture.get_spans()
+    assert len(spans) == 3
+
+    # Register all spans
+    for span in spans:
+        _span_registry.register_span(span)
+
+    grandparent_span = next(s for s in spans if s.name == "grandparent")
+    parent_span = next(s for s in spans if s.name == "parent")
+    child_span = next(s for s in spans if s.name == "child")
+
+    grandparent_id = grandparent_span.context.span_id
+    parent_id = parent_span.context.span_id
+    child_id = child_span.context.span_id
+
+    # Test ancestor relationships
+    assert _span_registry.is_ancestor(grandparent_id, child_id), (
+        "Grandparent should be ancestor of child"
+    )
+    assert _span_registry.is_ancestor(parent_id, child_id), (
+        "Parent should be ancestor of child"
+    )
+    assert _span_registry.is_ancestor(grandparent_id, parent_id), (
+        "Grandparent should be ancestor of parent"
+    )
+
+    # Test negative cases
+    assert not _span_registry.is_ancestor(child_id, grandparent_id), (
+        "Child should not be ancestor of grandparent"
+    )
+    assert not _span_registry.is_ancestor(parent_id, grandparent_id), (
+        "Parent should not be ancestor of grandparent"
+    )
+
+    span_capture.print_hierarchy()
+
+
+def test_mixed_otel_and_external_spans(span_capture: SpanCapture):
+    """Test scenario where OTel spans and external spans are interleaved.
+
+    This mimics the real-world scenario from the screenshots where:
+    - LangGraph creates spans
+    - generate_report is traced
+    - Custom traced functions are called
+    - All should maintain proper hierarchy
+    """
+
+    external_spans: list[Span] = []
+
+    def mock_external_span_provider():
+        return external_spans[-1] if external_spans else None
+
+    def mock_ancestors_provider():
+        return external_spans[:-1] if len(external_spans) > 1 else []
+
+    UiPathSpanUtils.register_current_span_provider(mock_external_span_provider)
+    UiPathSpanUtils.register_current_span_ancestors_provider(mock_ancestors_provider)
+
+    @traced(name="langraph_simulation")
+    def langraph_simulation():
+        spans = span_capture.get_spans()
+        if spans:
+            external_spans.append(spans[-1])
+
+        result = generate_report()
+
+        if external_spans:
+            external_spans.pop()
+
+        return result
+
+    @traced(name="generate_report")
+    def generate_report():
+        spans = span_capture.get_spans()
+        if spans:
+            # Add generate_report to external spans
+            for s in spans:
+                if s.name == "generate_report" and s not in external_spans:
+                    external_spans.append(s)
+                    break
+
+        result = custom_function()
+
+        # Remove generate_report from external spans
+        if (
+            external_spans
+            and getattr(external_spans[-1], "name", None) == "generate_report"
+        ):
+            external_spans.pop()
+
+        return result
+
+    @traced(name="custom_function")
+    def custom_function():
+        return nested_function()
+
+    @traced(name="nested_function")
+    def nested_function():
+        return "result"
+
+    result = langraph_simulation()
+
+    assert result == "result"
+
+    spans = span_capture.get_spans()
+    assert len(spans) >= 4, f"Expected at least 4 spans, got {len(spans)}"
+
+    # Verify hierarchy
+    langraph_span = next(s for s in spans if s.name == "langraph_simulation")
+    report_span = next(s for s in spans if s.name == "generate_report")
+    custom_span = next(s for s in spans if s.name == "custom_function")
+    nested_span = next(s for s in spans if s.name == "nested_function")
+
+    # Check parent-child relationships
+    assert report_span.parent is not None
+    assert report_span.parent.span_id == langraph_span.context.span_id
+
+    assert custom_span.parent is not None
+    assert custom_span.parent.span_id == report_span.context.span_id
+
+    assert nested_span.parent is not None
+    assert nested_span.parent.span_id == custom_span.context.span_id
+
+    span_capture.print_hierarchy()
+
+    # Cleanup
+    UiPathSpanUtils.register_current_span_provider(None)
+    UiPathSpanUtils.register_current_span_ancestors_provider(None)
diff --git a/packages/uipath-core/tests/tracing/test_trace_manager.py b/packages/uipath-core/tests/tracing/test_trace_manager.py
new file mode 100644
index 000000000..b856b3918
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_trace_manager.py
@@ -0,0 +1,204 @@
+"""Tests for UiPathTraceManager"""
+
+from unittest.mock import MagicMock
+
+import pytest
+from opentelemetry import trace
+from opentelemetry.sdk.trace import SpanProcessor
+
+from uipath.core.tracing.trace_manager import (
+    UiPathTraceManager,
+    _DelegatingSpanProcessor,
+)
+
+
+@pytest.fixture(autouse=True)
+def _reset_delegating_singleton():
+    """Reset the singleton between tests so each test starts clean."""
+    _DelegatingSpanProcessor._instance = None
+    yield
+    _DelegatingSpanProcessor._instance = None
+
+
+@pytest.mark.asyncio
+async def test_multiple_factories_same_executor():
+    """Test two factories using same executor, verify spans are captured correctly."""
+    trace_manager = UiPathTraceManager()
+
+    # Create span
+    tracer = trace.get_tracer("uipath-runtime")
+    with trace_manager.start_execution_span("root-span", "test"):
+        with tracer.start_as_current_span(
+            "custom-child-span", attributes={"operation": "child", "step": "1"}
+        ):
+            pass
+
+    spans = trace_manager.get_execution_spans("test")
+    assert len(spans) == 2
+
+    assert spans[0].name == "custom-child-span"
+    assert spans[0].attributes == {
+        "operation": "child",
+        "step": "1",
+        "execution.id": "test",
+    }
+
+    assert spans[1].name == "root-span"
+    assert spans[1].attributes == {"execution.id": "test"}
+
+
+class TestDelegatingSpanProcessor:
+    """Tests for _DelegatingSpanProcessor."""
+
+    def test_add_and_clear(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        p2 = MagicMock(spec=SpanProcessor)
+
+        dp.add(p1)
+        dp.add(p2)
+        assert len(dp._processors) == 2
+
+        removed = dp.clear()
+        assert removed == [p1, p2]
+        assert dp._processors == []
+
+    def test_delegates_on_start_and_on_end(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        p2 = MagicMock(spec=SpanProcessor)
+        dp.add(p1)
+        dp.add(p2)
+
+        mock_span = MagicMock()
+        dp.on_start(mock_span, parent_context=None)
+        p1.on_start.assert_called_once_with(mock_span, None)
+        p2.on_start.assert_called_once_with(mock_span, None)
+
+        mock_readable_span = MagicMock()
+        dp.on_end(mock_readable_span)
+        p1.on_end.assert_called_once_with(mock_readable_span)
+        p2.on_end.assert_called_once_with(mock_readable_span)
+
+    def test_clear_stops_delegation(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        dp.add(p1)
+        dp.clear()
+
+        mock_span = MagicMock()
+        dp.on_start(mock_span, parent_context=None)
+        dp.on_end(mock_span)
+        p1.on_start.assert_not_called()
+        p1.on_end.assert_not_called()
+
+    def test_get_instance_returns_singleton(self) -> None:
+        provider = MagicMock()
+        inst1 = _DelegatingSpanProcessor.get_instance(provider)
+        inst2 = _DelegatingSpanProcessor.get_instance(provider)
+        assert inst1 is inst2
+        provider.add_span_processor.assert_called_once_with(inst1)
+
+    def test_force_flush_delegates(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        dp.add(p1)
+
+        result = dp.force_flush(timeout_millis=5000)
+        assert result is True
+        p1.force_flush.assert_called_once_with(5000)
+
+    def test_force_flush_returns_false_on_child_failure(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        p2 = MagicMock(spec=SpanProcessor)
+        p1.force_flush.return_value = True
+        p2.force_flush.return_value = False
+        dp.add(p1)
+        dp.add(p2)
+
+        assert dp.force_flush(timeout_millis=5000) is False
+
+    def test_shutdown_delegates_to_children(self) -> None:
+        dp = _DelegatingSpanProcessor()
+        p1 = MagicMock(spec=SpanProcessor)
+        p2 = MagicMock(spec=SpanProcessor)
+        dp.add(p1)
+        dp.add(p2)
+        dp.shutdown()
+        p1.shutdown.assert_called_once()
+        p2.shutdown.assert_called_once()
+        assert len(dp._processors) == 2
+
+
+class TestTraceManagerShutdown:
+    """Tests for the multi-job accumulation fix."""
+
+    def test_shutdown_clears_processors(self) -> None:
+        tm = UiPathTraceManager()
+        p1 = MagicMock(spec=SpanProcessor)
+        tm.add_span_processor(p1)
+
+        tm.shutdown()
+
+        assert tm.tracer_span_processors == []
+        assert tm._delegating._processors == []
+        p1.force_flush.assert_called_once()
+        p1.shutdown.assert_called_once()
+
+    def test_successive_managers_do_not_accumulate(self) -> None:
+        """Simulates multiple jobs on the same pod.
+
+        Each job creates a new UiPathTraceManager and adds a processor.
+        After shutdown, the next job's processors should not stack with
+        the previous ones.
+        """
+        processor_counts: list[int] = []
+
+        for _ in range(5):
+            tm = UiPathTraceManager()
+            mock_processor = MagicMock(spec=SpanProcessor)
+            tm.add_span_processor(mock_processor)
+
+            # Count processors visible to the delegator (minus the batch
+            # processor added by __init__ for execution_span_exporter)
+            processor_counts.append(len(tm._delegating._processors))
+            tm.shutdown()
+
+        # Every job should see the same number of processors (2: the
+        # execution batch processor from __init__ + the one we added),
+        # NOT a linearly growing count.
+        assert all(c == processor_counts[0] for c in processor_counts), (
+            f"Processor counts should be constant across jobs, got: {processor_counts}"
+        )
+
+    def test_shutdown_tolerates_processor_error(self) -> None:
+        tm = UiPathTraceManager()
+        bad_processor = MagicMock(spec=SpanProcessor)
+        bad_processor.force_flush.side_effect = RuntimeError("flush failed")
+        tm.add_span_processor(bad_processor)
+
+        # Should not raise
+        tm.shutdown()
+        assert tm.tracer_span_processors == []
+        assert tm._delegating._processors == []
+
+    def test_spans_not_sent_to_old_processors_after_shutdown(self) -> None:
+        """After shutdown, old processors must not receive new span events."""
+        tm1 = UiPathTraceManager()
+        old_processor = MagicMock(spec=SpanProcessor)
+        tm1.add_span_processor(old_processor)
+        tm1.shutdown()
+
+        # Simulate next job
+        tm2 = UiPathTraceManager()
+        new_processor = MagicMock(spec=SpanProcessor)
+        tm2.add_span_processor(new_processor)
+
+        mock_span = MagicMock()
+        tm2._delegating.on_start(mock_span, parent_context=None)
+
+        new_processor.on_start.assert_called_once()
+        old_processor.on_start.assert_not_called()
+
+        tm2.shutdown()
diff --git a/packages/uipath-core/tests/tracing/test_traced.py b/packages/uipath-core/tests/tracing/test_traced.py
new file mode 100644
index 000000000..ca2b2de6a
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_traced.py
@@ -0,0 +1,1096 @@
+import json
+from asyncio import sleep
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any, Sequence
+
+import pytest
+from opentelemetry import trace
+from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
+from opentelemetry.sdk.trace.export import (
+    SimpleSpanProcessor,
+    SpanExporter,
+    SpanExportResult,
+)
+
+from uipath.core.tracing import traced
+
+
+class InMemorySpanExporter(SpanExporter):
+    """An OpenTelemetry span exporter that stores spans in memory for testing."""
+
+    def __init__(self):
+        self.spans = []
+        self.is_shutdown = False
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        if self.is_shutdown:
+            return SpanExportResult.FAILURE
+
+        self.spans.extend(spans)
+        return SpanExportResult.SUCCESS
+
+    def get_exported_spans(self) -> list[ReadableSpan]:
+        return self.spans
+
+    def clear_exported_spans(self) -> None:
+        self.spans = []
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return not self.is_shutdown
+
+    def shutdown(self) -> None:
+        self.is_shutdown = True
+
+
+@pytest.fixture
+def setup_tracer():
+    # Setup InMemorySpanExporter and TracerProvider
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    trace.set_tracer_provider(provider)
+    trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(exporter))  # type: ignore
+
+    yield exporter, provider
+
+
+def test_traced_sync_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_function(x, y):
+        return x + y
+
+    result = sample_function(2, 3)
+    assert result == 5
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_function"
+    assert span.attributes["span_type"] == "function_call_sync"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "5"
+
+
+def test_traced_bare_sync_function(setup_tracer):
+    """Test @traced without parentheses on a sync function."""
+    exporter, provider = setup_tracer
+
+    @traced
+    def sample_function(x, y):
+        return x + y
+
+    result = sample_function(2, 3)
+    assert result == 5
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_function"
+    assert span.attributes["span_type"] == "function_call_sync"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "5"
+
+
+@pytest.mark.asyncio
+async def test_traced_async_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_async_function(x, y):
+        return x * y
+
+    result = await sample_async_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()  # Ensure spans are flushed
+
+    await sleep(1)
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_async_function"
+    assert span.attributes["span_type"] == "function_call_async"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "6"
+
+
+@pytest.mark.asyncio
+async def test_traced_bare_async_function(setup_tracer):
+    """Test @traced without parentheses on an async function."""
+    exporter, provider = setup_tracer
+
+    @traced
+    async def sample_async_function(x, y):
+        return x * y
+
+    result = await sample_async_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()
+
+    await sleep(1)
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_async_function"
+    assert span.attributes["span_type"] == "function_call_async"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "6"
+
+
+def test_traced_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_generator_function(n):
+        for i in range(n):
+            yield i
+
+    results = list(sample_generator_function(3))
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_generator_function"
+    assert span.attributes["span_type"] == "function_call_generator_sync"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
+
+
+@pytest.mark.asyncio
+async def test_traced_async_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_async_generator_function(n):
+        for i in range(n):
+            yield i
+
+    results = [item async for item in sample_async_generator_function(3)]
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_async_generator_function"
+    assert span.attributes["span_type"] == "function_call_generator_async"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
+
+
+def test_traced_bare_generator_function(setup_tracer):
+    """Test @traced without parentheses on a generator function."""
+    exporter, provider = setup_tracer
+
+    @traced
+    def sample_generator_function(n):
+        for i in range(n):
+            yield i
+
+    results = list(sample_generator_function(3))
+    assert results == [0, 1, 2]
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_generator_function"
+    assert span.attributes["span_type"] == "function_call_generator_sync"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
+
+
+@pytest.mark.asyncio
+async def test_traced_bare_async_generator_function(setup_tracer):
+    """Test @traced without parentheses on an async generator function."""
+    exporter, provider = setup_tracer
+
+    @traced
+    async def sample_async_generator_function(n):
+        for i in range(n):
+            yield i
+
+    results = [item async for item in sample_async_generator_function(3)]
+    assert results == [0, 1, 2]
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "sample_async_generator_function"
+    assert span.attributes["span_type"] == "function_call_generator_async"
+    assert "input.value" in span.attributes
+    assert "output.value" in span.attributes
+    assert span.attributes["output.value"] == "[0, 1, 2]"
+
+
+def test_traced_bare_preserves_type_hints(setup_tracer):
+    """Test that @traced without parentheses preserves function type hints and signature."""
+    exporter, provider = setup_tracer
+
+    @traced
+    def typed_function(x: int, y: str = "hello") -> bool:
+        return True
+
+    import inspect
+    from typing import get_type_hints
+
+    hints = get_type_hints(typed_function)
+    assert hints == {"x": int, "y": str, "return": bool}
+
+    sig = inspect.signature(typed_function)
+    assert list(sig.parameters.keys()) == ["x", "y"]
+    assert sig.parameters["x"].annotation is int
+    assert sig.parameters["y"].default == "hello"
+
+    provider.shutdown()
+
+
+def test_traced_with_basic_processors(setup_tracer):
+    """Test traced decorator with basic input and output processors."""
+    exporter, provider = setup_tracer
+
+    def double_input(inputs):
+        """Double numeric inputs."""
+        result = inputs.copy()
+        for key, value in result.items():
+            if isinstance(value, (int, float)):
+                result[key] = value * 2
+        return result
+
+    def format_output(output):
+        """Format the output as a string."""
+        return {"result": str(output)}
+
+    @traced(input_processor=double_input, output_processor=format_output)
+    def multiply(x, y):
+        return x * y
+
+    # Original function behavior should be unchanged
+    result = multiply(3, 4)
+    assert result == 12
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Check that input processor was applied (doubles the inputs)
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs["x"] == 6  # 3 doubled to 6
+    assert inputs["y"] == 8  # 4 doubled to 8
+
+    # Check that output processor was applied (formatted as string in dict)
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert output == {"result": "12"}  # Result wrapped in dict with string conversion
+
+
+@pytest.mark.asyncio
+async def test_traced_async_with_basic_processors(setup_tracer):
+    """Test traced decorator with basic processors for async functions."""
+    exporter, provider = setup_tracer
+
+    def add_context(inputs):
+        """Add context to inputs."""
+        result = inputs.copy()
+        result["context"] = "test"
+        return result
+
+    def add_timestamp(output):
+        """Add a timestamp to output."""
+        if isinstance(output, dict):
+            result = output.copy()
+            result["processed"] = True
+            return result
+        return {"value": output, "processed": True}
+
+    @traced(input_processor=add_context, output_processor=add_timestamp)
+    async def async_operation(message):
+        await sleep(0.1)
+        return {"status": "completed", "message": message}
+
+    # Original function behavior should be unchanged
+    result = await async_operation("hello")
+    assert result == {"status": "completed", "message": "hello"}
+
+    provider.shutdown()  # Ensure spans are flushed
+    await sleep(0.1)  # Give time for spans to be processed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Check that input processor was applied
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs["message"] == "hello"
+    assert inputs["context"] == "test"  # Added by processor
+
+    # Check that output processor was applied
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert output["status"] == "completed"
+    assert output["message"] == "hello"
+    assert output["processed"] is True  # Added by processor
+
+
+def mask_credit_card(inputs: dict[str, Any]) -> dict[str, Any]:
+    """Process inputs to mask credit card information."""
+    processed = inputs.copy()
+    if "card_number" in processed:
+        if len(processed["card_number"]) >= 4:
+            # Keep only the last 4 digits
+            processed["card_number"] = "**** **** **** " + processed["card_number"][-4:]
+        else:
+            processed["card_number"] = "****"
+    return processed
+
+
+def anonymize_single_user_data(output_dict: dict[str, Any]) -> dict[str, Any]:
+    """Process a single dictionary to anonymize user information."""
+    processed = output_dict.copy()
+    if "user_info" in processed and isinstance(processed["user_info"], dict):
+        user_info = processed["user_info"].copy()
+        if "name" in user_info:
+            user_info["name"] = "Anonymous User"
+        if "email" in user_info:
+            user_info["email"] = "anonymous@example.com"
+        processed["user_info"] = user_info
+    return processed
+
+
+def anonymize_user_data(output: Any) -> Any:
+    """Process outputs to anonymize user information."""
+    # Handle list of outputs (from generators)
+    if isinstance(output, list):
+        processed_outputs = []
+        for item in output:
+            if isinstance(item, dict):
+                processed_outputs.append(anonymize_single_user_data(item))
+            else:
+                processed_outputs.append(item)
+        return processed_outputs
+
+    # Handle single dictionary output
+    if not isinstance(output, dict):
+        return output
+
+    return anonymize_single_user_data(output)
+
+
+def dataclass_to_dict(obj):
+    """Convert a dataclass instance or list of dataclass instances to dict(s)."""
+    if isinstance(obj, list):
+        return [dataclass_to_dict(item) for item in obj]
+
+    # Check if object is a dataclass (has __dataclass_fields__ attribute)
+    if hasattr(obj, "__dataclass_fields__"):
+        return asdict(obj)
+
+    return obj
+
+
+# Example of a processor that handles dataclasses
+def process_dataclass_output(output):
+    """Process output that might be a dataclass or contain dataclasses."""
+    # First convert to dict if it's a dataclass
+    data = dataclass_to_dict(output)
+
+    # Now apply regular dict processing
+    if isinstance(data, dict):
+        # Apply your masking/anonymization logic
+        if "sensitive_field" in data:
+            data["sensitive_field"] = "***MASKED***"
+
+        # Check for direct email field (for UserProfile dataclass)
+        if "email" in data:
+            data["email"] = "anonymous@example.com"
+
+        # Process nested user_info if present
+        if "user_info" in data and isinstance(data["user_info"], dict):
+            if "email" in data["user_info"]:
+                data["user_info"]["email"] = "anonymous@example.com"
+
+    return data
+
+
+# Example of using with a dataclass
+@dataclass
+class UserProfile:
+    user_id: int
+    name: str
+    email: str
+    access_level: str
+
+
+def test_traced_with_input_processor(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(input_processor=mask_credit_card)
+    def process_payment(name, card_number, amount):
+        return {"transaction_id": "tx_12345", "amount": amount, "status": "approved"}
+
+    result = process_payment("John Doe", "4111111111111111", 99.99)
+    assert result["transaction_id"] == "tx_12345"
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "process_payment"
+
+    # Verify inputs were processed
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert "card_number" in inputs
+    assert inputs["card_number"] == "**** **** **** 1111"  # Should be masked
+    assert inputs["name"] == "John Doe"  # Should be unchanged
+
+    # Verify original function output is returned
+    assert result["transaction_id"] == "tx_12345"
+    assert result["amount"] == 99.99
+
+
+def test_traced_with_output_processor(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(output_processor=anonymize_user_data)
+    def get_user_profile(user_id):
+        # Return sensitive user data
+        return {
+            "user_id": user_id,
+            "user_info": {"name": "Jane Smith", "email": "jane@example.com", "age": 32},
+            "subscription": "premium",
+        }
+
+    result = get_user_profile(12345)
+
+    # Original function should return unmodified data
+    assert result["user_info"]["name"] == "Jane Smith"
+    assert result["user_info"]["email"] == "jane@example.com"
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Verify output was processed for tracing
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert output["user_info"]["name"] == "Anonymous User"
+    assert output["user_info"]["email"] == "anonymous@example.com"
+    assert output["user_info"]["age"] == 32  # Non-sensitive data preserved
+    assert output["subscription"] == "premium"  # Non-sensitive data preserved
+
+
+def test_traced_with_dataclass_output(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(output_processor=process_dataclass_output)
+    def get_user_profile(user_id):
+        # Return a dataclass with sensitive data
+        return UserProfile(
+            user_id=user_id,
+            name="John Doe",
+            email="john.doe@example.com",
+            access_level="admin",
+        )
+
+    result = get_user_profile(12345)
+
+    # Verify original result is unchanged
+    assert result.name == "John Doe"
+    assert result.email == "john.doe@example.com"
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+
+    # Verify the output was processed for tracing
+    output_json = spans[0].attributes["output.value"]
+    output = json.loads(output_json)
+    assert "email" in output
+    assert output["email"] == "anonymous@example.com"  # Masked in the trace
+
+
+@pytest.mark.asyncio
+async def test_traced_async_with_processors(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
+    async def async_payment_with_user_data(name, card_number, amount):
+        await sleep(0.1)  # Simulate async operation
+        return {
+            "transaction_id": "tx_async_12345",
+            "amount": amount,
+            "status": "approved",
+            "user_info": {
+                "name": name,
+                "email": f"{name.lower().replace(' ', '.')}@example.com",
+            },
+        }
+
+    result = await async_payment_with_user_data("John Doe", "5555555555554444", 199.99)
+
+    # Original function should return unmodified data
+    assert result["transaction_id"] == "tx_async_12345"
+    assert result["user_info"]["name"] == "John Doe"
+    assert result["user_info"]["email"] == "john.doe@example.com"
+
+    provider.shutdown()  # Ensure spans are flushed
+    await sleep(0.1)  # Give time for spans to be processed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Verify inputs were processed
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs["card_number"] == "**** **** **** 4444"
+
+    # Verify outputs were processed
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert output["user_info"]["name"] == "Anonymous User"
+    assert output["user_info"]["email"] == "anonymous@example.com"
+    assert output["amount"] == 199.99  # Non-sensitive data preserved
+
+
+def test_traced_generator_with_processors(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
+    def generate_user_transactions(card_number, count):
+        for i in range(count):
+            yield {
+                "transaction_id": f"tx_{i}",
+                "amount": 10.0 * (i + 1),
+                "user_info": {"name": "Jane Smith", "email": "jane@example.com"},
+            }
+
+    results = list(generate_user_transactions("4111111111111111", 3))
+
+    # Original function should return unmodified data
+    assert len(results) == 3
+    assert results[0]["user_info"]["name"] == "Jane Smith"
+    assert results[0]["user_info"]["email"] == "jane@example.com"
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Verify inputs were processed
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs["card_number"] == "**** **** **** 1111"
+
+    # Verify outputs were processed
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert len(output) == 3
+    for transaction in output:
+        assert transaction["user_info"]["name"] == "Anonymous User"
+        assert transaction["user_info"]["email"] == "anonymous@example.com"
+
+
+@pytest.mark.asyncio
+async def test_traced_async_generator_with_processors(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
+    async def generate_async_transactions(card_number, count):
+        for i in range(count):
+            await sleep(0.05)  # Simulate async operation
+            yield {
+                "transaction_id": f"tx_async_{i}",
+                "amount": 20.0 * (i + 1),
+                "user_info": {"name": "Bob Johnson", "email": "bob@example.com"},
+            }
+
+    results = [
+        item async for item in generate_async_transactions("5555555555554444", 2)
+    ]
+
+    # Original function should return unmodified data
+    assert len(results) == 2
+    assert results[0]["user_info"]["name"] == "Bob Johnson"
+    assert results[0]["user_info"]["email"] == "bob@example.com"
+
+    provider.shutdown()  # Ensure spans are flushed
+    await sleep(0.1)  # Give time for spans to be processed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Verify inputs were processed
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs["card_number"] == "**** **** **** 4444"
+
+    # Verify outputs were processed
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert len(output) == 2
+    for transaction in output:
+        assert transaction["user_info"]["name"] == "Anonymous User"
+        assert transaction["user_info"]["email"] == "anonymous@example.com"
+
+
+def test_traced_with_hide_input_outputs(setup_tracer):
+    """Test that hide_input=True and hide_output=True redacts all data."""
+    exporter, provider = setup_tracer
+
+    @traced(hide_input=True, hide_output=True)
+    def fully_private_function(sensitive_input):
+        return {"sensitive_output": f"Processed {sensitive_input}"}
+
+    result = fully_private_function("confidential_data")
+
+    # Original function should return unmodified data
+    assert result["sensitive_output"] == "Processed confidential_data"
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+
+    # Verify both inputs and outputs were redacted
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+    assert inputs == {"redacted": "Input data not logged for privacy/security"}
+
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+    assert output == {"redacted": "Output data not logged for privacy/security"}
+
+
+class Operator(Enum):
+    ADD = "+"
+    SUBTRACT = "-"
+    MULTIPLY = "*"
+    DIVIDE = "/"
+
+
+@dataclass
+class CalculatorInput:
+    a: float = 0.0
+    b: float = 0.0
+    operator: Operator = Operator.ADD
+
+
+@dataclass
+class CalculatorOutput:
+    result: float = 0.0
+    operator: Operator = Operator.ADD
+
+
+def test_traced_complex_input_serialization(setup_tracer):
+    """Test that traced decorator properly serializes complex inputs like dataclasses with enums."""
+    exporter, provider = setup_tracer
+
+    @traced()
+    def test_complex_input(input: CalculatorInput) -> CalculatorOutput:
+        assert isinstance(input.a, float)
+        assert isinstance(input.b, float)
+        assert isinstance(input.operator, Operator)
+        return CalculatorOutput(result=(input.a * input.b), operator=Operator.MULTIPLY)
+
+    # Create a complex input with dataclass and enum
+    calculator_input = CalculatorInput(a=10.5, b=5.2, operator=Operator.MULTIPLY)
+    test_complex_input(calculator_input)
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "test_complex_input"
+    assert span.attributes["span_type"] == "function_call_sync"
+
+    # Verify that inputs are properly serialized as JSON
+    assert "input.value" in span.attributes
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+
+    # Debug: Print the actual inputs structure
+    print(f"Inputs JSON: {inputs_json}")
+    print(f"Parsed inputs: {inputs}")
+
+    # Check that the dataclass is properly serialized
+    assert "input" in inputs
+    input_data = inputs["input"]
+
+    # Verify the dataclass fields are properly serialized
+    assert input_data["a"] == 10.5
+    assert input_data["b"] == 5.2
+    # Verify the enum is serialized as its value
+    assert input_data["operator"] == "*"
+
+    # Verify that outputs are properly serialized as JSON
+    assert "output.value" in span.attributes
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+
+    # Debug: Print the actual output structure
+    print(f"Output JSON: {output_json}")
+    print(f"Parsed output: {output}")
+
+    # Verify the output dataclass fields are properly serialized
+    assert output["result"] == 54.6  # 10.5 * 5.2 = 54.6
+    # Verify the enum is serialized as its value
+    assert output["operator"] == "*"
+
+
+@pytest.mark.asyncio
+async def test_traced_with_pydantic_basemodel_class(setup_tracer):
+    """Test that Pydantic BaseModel classes can be serialized in tracing.
+
+    This tests the fix for the issue where passing a Pydantic BaseModel class
+    as a parameter (like response_format=OutputFormat) would cause JSON
+    serialization errors in tracing.
+    """
+    from pydantic import BaseModel
+
+    exporter, provider = setup_tracer
+
+    class OutputFormat(BaseModel):
+        result: str
+        confidence: float = 0.95
+
+    @traced()
+    async def llm_chat_completions(messages: list[Any], response_format=None):
+        """Simulate LLM function with BaseModel class as response_format."""
+        if response_format:
+            mock_content = '{"result": "hi!", "confidence": 0.95}'
+            return {"choices": [{"message": {"content": mock_content}}]}
+        return {"choices": [{"message": {"content": "hi!"}}]}
+
+    # Test with tuple message format and BaseModel class as parameter
+    messages = [("human", "repeat this: hi!")]
+    result = await llm_chat_completions(messages, response_format=OutputFormat)
+
+    assert result is not None
+    assert "choices" in result
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 1
+    span = spans[0]
+    assert span.name == "llm_chat_completions"
+    assert span.attributes["span_type"] == "function_call_async"
+
+    # Verify inputs are properly serialized as JSON, including BaseModel class
+    assert "input.value" in span.attributes
+    inputs_json = span.attributes["input.value"]
+    inputs = json.loads(inputs_json)
+
+    # Check BaseModel class is properly serialized with schema representation
+    assert "response_format" in inputs
+    response_format_data = inputs["response_format"]
+
+    # Verify the BaseModel class is serialized as a schema representation
+    assert "__class__" in response_format_data
+    assert "__module__" in response_format_data
+    assert "schema" in response_format_data
+    assert response_format_data["__class__"] == "OutputFormat"
+
+    # Verify the schema contains expected structure
+    schema = response_format_data["schema"]
+    assert "properties" in schema
+    assert "result" in schema["properties"]
+    assert "confidence" in schema["properties"]
+    assert schema["properties"]["result"]["type"] == "string"
+    assert schema["properties"]["confidence"]["type"] == "number"
+
+    # Verify that tuple messages are also properly serialized
+    assert "messages" in inputs
+    messages_data = inputs["messages"]
+    assert isinstance(messages_data, list)
+    assert len(messages_data) == 1
+    assert messages_data[0] == ["human", "repeat this: hi!"]
+
+    # Verify that outputs are properly serialized as JSON
+    assert "output.value" in span.attributes
+    output_json = span.attributes["output.value"]
+    output = json.loads(output_json)
+
+    assert "choices" in output
+    assert len(output["choices"]) == 1
+
+
+@pytest.mark.asyncio
+async def test_non_recording_traced_async_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(recording=True)
+    async def child_sample_async_function(x, y):
+        return x * y
+
+    @traced(recording=False)
+    async def sample_async_function(x, y):
+        return await child_sample_async_function(x, y)
+
+    result = await sample_async_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()  # Ensure spans are flushed
+
+    await sleep(1)
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+def test_non_recording_traced_sync_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced(recording=True)
+    def child_sample_sync_function(x, y):
+        return x * y
+
+    @traced(recording=False)
+    def sample_sync_function(x, y):
+        return child_sample_sync_function(x, y)
+
+    result = sample_sync_function(2, 3)
+    assert result == 6
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+def test_non_recording_traced_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_child_generator_function(n):
+        for i in range(n):
+            yield i
+
+    @traced(recording=False)
+    def sample_generator_function(n):
+        for i in sample_child_generator_function(n):
+            yield i
+
+    results = list(sample_generator_function(3))
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+@pytest.mark.asyncio
+async def test_non_recording_traced_async_generator_function(setup_tracer):
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_child_async_generator_function(n):
+        for i in range(n):
+            yield i
+
+    @traced(recording=False)
+    async def sample_async_generator_function(n):
+        async for i in sample_child_async_generator_function(n):
+            yield i
+
+    results = [item async for item in sample_async_generator_function(3)]
+    assert results == [0, 1, 2]
+
+    provider.shutdown()  # Ensure spans are flushed
+    spans = exporter.get_exported_spans()
+
+    assert len(spans) == 0
+
+
+# --------- Suppress Instrumentation Tests ---------
+
+
+def test_suppress_instrumentation_sync_function(setup_tracer):
+    """Test that suppress_instrumentation prevents spans from being created for sync functions."""
+    from opentelemetry.instrumentation.utils import suppress_instrumentation
+
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_function(x, y):
+        return x + y
+
+    # Call without suppression - should create span
+    result = sample_function(2, 3)
+    assert result == 5
+
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 1
+
+    exporter.clear_exported_spans()
+
+    # Call with suppression - should NOT create span
+    with suppress_instrumentation():
+        result = sample_function(4, 5)
+        assert result == 9
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 0
+
+
+@pytest.mark.asyncio
+async def test_suppress_instrumentation_async_function(setup_tracer):
+    """Test that suppress_instrumentation prevents spans from being created for async functions."""
+    from opentelemetry.instrumentation.utils import suppress_instrumentation
+
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_async_function(x, y):
+        return x * y
+
+    # Call without suppression - should create span
+    result = await sample_async_function(2, 3)
+    assert result == 6
+
+    await sleep(0.1)
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 1
+
+    exporter.clear_exported_spans()
+
+    # Call with suppression - should NOT create span
+    with suppress_instrumentation():
+        result = await sample_async_function(4, 5)
+        assert result == 20
+
+    provider.shutdown()
+    await sleep(0.1)
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 0
+
+
+def test_suppress_instrumentation_generator_function(setup_tracer):
+    """Test that suppress_instrumentation prevents spans from being created for generator functions."""
+    from opentelemetry.instrumentation.utils import suppress_instrumentation
+
+    exporter, provider = setup_tracer
+
+    @traced()
+    def sample_generator_function(n):
+        for i in range(n):
+            yield i
+
+    # Call without suppression - should create span
+    results = list(sample_generator_function(3))
+    assert results == [0, 1, 2]
+
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 1
+
+    exporter.clear_exported_spans()
+
+    # Call with suppression - should NOT create span
+    with suppress_instrumentation():
+        results = list(sample_generator_function(4))
+        assert results == [0, 1, 2, 3]
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 0
+
+
+@pytest.mark.asyncio
+async def test_suppress_instrumentation_async_generator_function(setup_tracer):
+    """Test that suppress_instrumentation prevents spans from being created for async generator functions."""
+    from opentelemetry.instrumentation.utils import suppress_instrumentation
+
+    exporter, provider = setup_tracer
+
+    @traced()
+    async def sample_async_generator_function(n):
+        for i in range(n):
+            yield i
+
+    # Call without suppression - should create span
+    results = [item async for item in sample_async_generator_function(3)]
+    assert results == [0, 1, 2]
+
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 1
+
+    exporter.clear_exported_spans()
+
+    # Call with suppression - should NOT create span
+    with suppress_instrumentation():
+        results = [item async for item in sample_async_generator_function(4)]
+        assert results == [0, 1, 2, 3]
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 0
+
+
+def test_suppress_instrumentation_nested_functions(setup_tracer):
+    """Test that suppress_instrumentation prevents spans for nested traced function calls."""
+    from opentelemetry.instrumentation.utils import suppress_instrumentation
+
+    exporter, provider = setup_tracer
+
+    @traced()
+    def inner_function(x):
+        return x * 2
+
+    @traced()
+    def outer_function(x):
+        return inner_function(x) + 1
+
+    # Call without suppression - should create 2 spans
+    result = outer_function(5)
+    assert result == 11
+
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 2
+
+    exporter.clear_exported_spans()
+
+    # Call with suppression - should NOT create any spans
+    with suppress_instrumentation():
+        result = outer_function(10)
+        assert result == 21
+
+    provider.shutdown()
+    spans = exporter.get_exported_spans()
+    assert len(spans) == 0
diff --git a/packages/uipath-core/tests/tracing/test_tracing_utils.py b/packages/uipath-core/tests/tracing/test_tracing_utils.py
new file mode 100644
index 000000000..803f2b152
--- /dev/null
+++ b/packages/uipath-core/tests/tracing/test_tracing_utils.py
@@ -0,0 +1,90 @@
+import inspect
+import json
+
+from uipath.core.tracing._utils import format_args_for_trace, format_args_for_trace_json
+
+
+class TestSpanUtils:
+    def test_format_args_for_trace(self):
+        # Simple function signature
+        def func1(a, b, c=3):
+            pass
+
+        sig = inspect.signature(func1)
+        result = format_args_for_trace(sig, 1, 2)
+        assert result == {"a": 1, "b": 2, "c": 3}
+
+        # Test with kwargs
+        result = format_args_for_trace(sig, 1, c=4, b=5)
+        assert result == {"a": 1, "b": 5, "c": 4}
+
+        # Function with self parameter
+        class TestClass:
+            def method(self, x, y):
+                pass
+
+        sig = inspect.signature(TestClass.method)
+        result = format_args_for_trace(sig, TestClass(), 10, 20)
+        assert result == {"x": 10, "y": 20}
+
+        # Function with **kwargs
+        def func2(a, **kwargs):
+            pass
+
+        sig = inspect.signature(func2)
+        result = format_args_for_trace(sig, 1, b=2, c=3)
+        assert result == {"a": 1, "b": 2, "c": 3}
+
+    def test_format_args_for_trace_json(self):
+        def sample_func(a, b=None):
+            pass
+
+        sig = inspect.signature(sample_func)
+
+        # Test with simple args
+        json_result = format_args_for_trace_json(sig, 1, b="test")
+        parsed = json.loads(json_result)
+        assert parsed == {"a": 1, "b": "test"}
+
+        # Test with non-serializable object
+        class NonSerializable:
+            pass
+
+        json_result = format_args_for_trace_json(sig, 1, b=NonSerializable())
+        # Should not raise exception
+        parsed = json.loads(json_result)
+        assert parsed["a"] == 1
+        assert "b" in parsed  # The value will be a string representation
+
+    def test_format_args_for_trace_json_with_class_type(self):
+        """Test format_args_for_trace_json with a function that takes a class type as parameter."""
+        from pydantic import BaseModel
+
+        # Define a mock OutputFormat class (similar to the example)
+        class OutputFormat(BaseModel):
+            format_type: str = "json"
+            strict: bool = True
+
+        # Define a function that takes a class type parameter
+        def chat_completions(messages, response_format=None):
+            pass
+
+        sig = inspect.signature(chat_completions)
+
+        # Test with class type as parameter (not instance)
+        json_result = format_args_for_trace_json(
+            sig, [("human", "repeat this: hi!")], response_format=OutputFormat
+        )
+
+        # Should not raise exception and should serialize the class
+        parsed = json.loads(json_result)
+        # Note: tuples are serialized as lists in JSON
+        assert parsed["messages"] == [["human", "repeat this: hi!"]]
+        assert "response_format" in parsed
+
+        # When a class type is passed, it should be serialized with class info
+        response_format_data = parsed["response_format"]
+        assert "__class__" in response_format_data
+        assert response_format_data["__class__"] == "OutputFormat"
+        assert "__module__" in response_format_data
+        assert "schema" in response_format_data
diff --git a/packages/uipath-core/tests/workspace/__init__.py b/packages/uipath-core/tests/workspace/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-core/tests/workspace/test_protocols.py b/packages/uipath-core/tests/workspace/test_protocols.py
new file mode 100644
index 000000000..0c9cd11c4
--- /dev/null
+++ b/packages/uipath-core/tests/workspace/test_protocols.py
@@ -0,0 +1,68 @@
+"""Structural-conformance tests for the workspace hydration protocols."""
+
+from __future__ import annotations
+
+from uuid import UUID, uuid4
+
+from uipath.core.workspace import AttachmentsProtocol, JobsProtocol
+
+
+class _FakeAttachments:
+    async def download_async(
+        self,
+        *,
+        key: UUID,
+        destination_path: str,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> str:
+        return destination_path
+
+    async def upload_async(
+        self,
+        *,
+        name: str,
+        content: str | bytes | None = None,
+        source_path: str | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> UUID:
+        return uuid4()
+
+
+class _FakeJobs:
+    async def list_attachments_async(
+        self,
+        *,
+        job_key: UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> list[str]:
+        return []
+
+    async def link_attachment_async(
+        self,
+        *,
+        job_key: UUID,
+        attachment_key: UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> None:
+        return None
+
+
+class _NotAService:
+    pass
+
+
+def test_attachments_service_satisfies_protocol() -> None:
+    assert isinstance(_FakeAttachments(), AttachmentsProtocol)
+
+
+def test_jobs_service_satisfies_protocol() -> None:
+    assert isinstance(_FakeJobs(), JobsProtocol)
+
+
+def test_unrelated_object_does_not_satisfy_protocols() -> None:
+    assert not isinstance(_NotAService(), AttachmentsProtocol)
+    assert not isinstance(_NotAService(), JobsProtocol)
diff --git a/packages/uipath-core/uv.lock b/packages/uipath-core/uv.lock
new file mode 100644
index 000000000..cfb903454
--- /dev/null
+++ b/packages/uipath-core/uv.lock
@@ -0,0 +1,1139 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[options]
+exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
+exclude-newer-span = "P2D"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "bandit"
+version = "1.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "stevedore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/89/76/a7f3e639b78601118aaa4a394db2c66ae2597fbd8c39644c32874ed11e0c/bandit-1.9.3.tar.gz", hash = "sha256:ade4b9b7786f89ef6fc7344a52b34558caec5da74cb90373aed01de88472f774", size = 4242154, upload-time = "2026-01-19T04:05:22.802Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/0b/8bdc52111c83e2dc2f97403dc87c0830b8989d9ae45732b34b686326fb2c/bandit-1.9.3-py3-none-any.whl", hash = "sha256:4745917c88d2246def79748bde5e08b9d5e9b92f877863d43fab70cd8814ce6a", size = 134451, upload-time = "2026-01-19T04:05:20.938Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/ad/b59e5b451cf7172b8d1043dc0fa718f23aab379bc1521ee13d4bd9bfa960/coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053", size = 219278, upload-time = "2026-02-09T12:56:31.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/17/0cb7ca3de72e5f4ef2ec2fa0089beafbcaaaead1844e8b8a63d35173d77d/coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11", size = 219783, upload-time = "2026-02-09T12:56:33.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/63/325d8e5b11e0eaf6d0f6a44fad444ae58820929a9b0de943fa377fe73e85/coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa", size = 250200, upload-time = "2026-02-09T12:56:34.474Z" },
+    { url = "https://files.pythonhosted.org/packages/76/53/c16972708cbb79f2942922571a687c52bd109a7bd51175aeb7558dff2236/coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7", size = 252114, upload-time = "2026-02-09T12:56:35.749Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c2/7ab36d8b8cc412bec9ea2d07c83c48930eb4ba649634ba00cb7e4e0f9017/coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00", size = 254220, upload-time = "2026-02-09T12:56:37.796Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/4d/cf52c9a3322c89a0e6febdfbc83bb45c0ed3c64ad14081b9503adee702e7/coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef", size = 256164, upload-time = "2026-02-09T12:56:39.016Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/eb1dd17bd6de8289df3580e967e78294f352a5df8a57ff4671ee5fc3dcd0/coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903", size = 250325, upload-time = "2026-02-09T12:56:40.668Z" },
+    { url = "https://files.pythonhosted.org/packages/71/07/8c1542aa873728f72267c07278c5cc0ec91356daf974df21335ccdb46368/coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f", size = 251913, upload-time = "2026-02-09T12:56:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d7/c62e2c5e4483a748e27868e4c32ad3daa9bdddbba58e1bc7a15e252baa74/coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299", size = 249974, upload-time = "2026-02-09T12:56:43.323Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9f/4c5c015a6e98ced54efd0f5cf8d31b88e5504ecb6857585fc0161bb1e600/coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505", size = 253741, upload-time = "2026-02-09T12:56:45.155Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/59/0f4eef89b9f0fcd9633b5d350016f54126ab49426a70ff4c4e87446cabdc/coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6", size = 249695, upload-time = "2026-02-09T12:56:46.636Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/b7476f938deb07166f3eb281a385c262675d688ff4659ad56c6c6b8e2e70/coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9", size = 250599, upload-time = "2026-02-09T12:56:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/34/c3420709d9846ee3785b9f2831b4d94f276f38884032dca1457fa83f7476/coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9", size = 221780, upload-time = "2026-02-09T12:56:50.479Z" },
+    { url = "https://files.pythonhosted.org/packages/61/08/3d9c8613079d2b11c185b865de9a4c1a68850cfda2b357fae365cf609f29/coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f", size = 222715, upload-time = "2026-02-09T12:56:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1a/54c3c80b2f056164cc0a6cdcb040733760c7c4be9d780fe655f356f433e4/coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f", size = 221385, upload-time = "2026-02-09T12:56:53.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
+    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
+    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
+    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
+    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
+    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
+    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
+    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
+    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.20.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/65/ce7f1b70157833bf3cb851b556a37d4547ceafc158aa9b34b36782f23696/filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1", size = 19485, upload-time = "2026-01-09T17:55:05.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/8d/e8b97e6bd3fb6fb271346f7981362f1e04d6a7463abd0de79e1fda17c067/identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980", size = 99360, upload-time = "2026-01-12T18:58:58.201Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/58/40fbbcefeda82364720eba5cf2270f98496bdfa19ea75b4cccae79c698e6/identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0", size = 99202, upload-time = "2026-01-12T18:58:56.627Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.7.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/24/5f3646ff414285e0f7708fa4e946b9bf538345a41d1c375c439467721a5e/librt-0.7.8.tar.gz", hash = "sha256:1a4ede613941d9c3470b0368be851df6bb78ab218635512d0370b27a277a0862", size = 148323, upload-time = "2026-01-14T12:56:16.876Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/a3/87ea9c1049f2c781177496ebee29430e4631f439b8553a4969c88747d5d8/librt-0.7.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3e9c11aa260c31493d4b3197d1e28dd07768594a4f92bec4506849d736248f", size = 56507, upload-time = "2026-01-14T12:54:54.156Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/4a/23bcef149f37f771ad30203d561fcfd45b02bc54947b91f7a9ac34815747/librt-0.7.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ddb52499d0b3ed4aa88746aaf6f36a08314677d5c346234c3987ddc506404eac", size = 58455, upload-time = "2026-01-14T12:54:55.978Z" },
+    { url = "https://files.pythonhosted.org/packages/22/6e/46eb9b85c1b9761e0f42b6e6311e1cc544843ac897457062b9d5d0b21df4/librt-0.7.8-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e9c0afebbe6ce177ae8edba0c7c4d626f2a0fc12c33bb993d163817c41a7a05c", size = 164956, upload-time = "2026-01-14T12:54:57.311Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/3f/aa7c7f6829fb83989feb7ba9aa11c662b34b4bd4bd5b262f2876ba3db58d/librt-0.7.8-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:631599598e2c76ded400c0a8722dec09217c89ff64dc54b060f598ed68e7d2a8", size = 174364, upload-time = "2026-01-14T12:54:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/2d/d57d154b40b11f2cb851c4df0d4c4456bacd9b1ccc4ecb593ddec56c1a8b/librt-0.7.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c1ba843ae20db09b9d5c80475376168feb2640ce91cd9906414f23cc267a1ff", size = 188034, upload-time = "2026-01-14T12:55:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f9/36c4dad00925c16cd69d744b87f7001792691857d3b79187e7a673e812fb/librt-0.7.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b5b007bb22ea4b255d3ee39dfd06d12534de2fcc3438567d9f48cdaf67ae1ae3", size = 186295, upload-time = "2026-01-14T12:55:01.303Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9b/8a9889d3df5efb67695a67785028ccd58e661c3018237b73ad081691d0cb/librt-0.7.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:dbd79caaf77a3f590cbe32dc2447f718772d6eea59656a7dcb9311161b10fa75", size = 181470, upload-time = "2026-01-14T12:55:02.492Z" },
+    { url = "https://files.pythonhosted.org/packages/43/64/54d6ef11afca01fef8af78c230726a9394759f2addfbf7afc5e3cc032a45/librt-0.7.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:87808a8d1e0bd62a01cafc41f0fd6818b5a5d0ca0d8a55326a81643cdda8f873", size = 201713, upload-time = "2026-01-14T12:55:03.919Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/29/73e7ed2991330b28919387656f54109139b49e19cd72902f466bd44415fd/librt-0.7.8-cp311-cp311-win32.whl", hash = "sha256:31724b93baa91512bd0a376e7cf0b59d8b631ee17923b1218a65456fa9bda2e7", size = 43803, upload-time = "2026-01-14T12:55:04.996Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/de/66766ff48ed02b4d78deea30392ae200bcbd99ae61ba2418b49fd50a4831/librt-0.7.8-cp311-cp311-win_amd64.whl", hash = "sha256:978e8b5f13e52cf23a9e80f3286d7546baa70bc4ef35b51d97a709d0b28e537c", size = 50080, upload-time = "2026-01-14T12:55:06.489Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e3/33450438ff3a8c581d4ed7f798a70b07c3206d298cf0b87d3806e72e3ed8/librt-0.7.8-cp311-cp311-win_arm64.whl", hash = "sha256:20e3946863d872f7cabf7f77c6c9d370b8b3d74333d3a32471c50d3a86c0a232", size = 43383, upload-time = "2026-01-14T12:55:07.49Z" },
+    { url = "https://files.pythonhosted.org/packages/56/04/79d8fcb43cae376c7adbab7b2b9f65e48432c9eced62ac96703bcc16e09b/librt-0.7.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9b6943885b2d49c48d0cff23b16be830ba46b0152d98f62de49e735c6e655a63", size = 57472, upload-time = "2026-01-14T12:55:08.528Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ba/60b96e93043d3d659da91752689023a73981336446ae82078cddf706249e/librt-0.7.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46ef1f4b9b6cc364b11eea0ecc0897314447a66029ee1e55859acb3dd8757c93", size = 58986, upload-time = "2026-01-14T12:55:09.466Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/26/5215e4cdcc26e7be7eee21955a7e13cbf1f6d7d7311461a6014544596fac/librt-0.7.8-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:907ad09cfab21e3c86e8f1f87858f7049d1097f77196959c033612f532b4e592", size = 168422, upload-time = "2026-01-14T12:55:10.499Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/84/e8d1bc86fa0159bfc24f3d798d92cafd3897e84c7fea7fe61b3220915d76/librt-0.7.8-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2991b6c3775383752b3ca0204842743256f3ad3deeb1d0adc227d56b78a9a850", size = 177478, upload-time = "2026-01-14T12:55:11.577Z" },
+    { url = "https://files.pythonhosted.org/packages/57/11/d0268c4b94717a18aa91df1100e767b010f87b7ae444dafaa5a2d80f33a6/librt-0.7.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03679b9856932b8c8f674e87aa3c55ea11c9274301f76ae8dc4d281bda55cf62", size = 192439, upload-time = "2026-01-14T12:55:12.7Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/56/1e8e833b95fe684f80f8894ae4d8b7d36acc9203e60478fcae599120a975/librt-0.7.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3968762fec1b2ad34ce57458b6de25dbb4142713e9ca6279a0d352fa4e9f452b", size = 191483, upload-time = "2026-01-14T12:55:13.838Z" },
+    { url = "https://files.pythonhosted.org/packages/17/48/f11cf28a2cb6c31f282009e2208312aa84a5ee2732859f7856ee306176d5/librt-0.7.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bb7a7807523a31f03061288cc4ffc065d684c39db7644c676b47d89553c0d714", size = 185376, upload-time = "2026-01-14T12:55:15.017Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/6a/d7c116c6da561b9155b184354a60a3d5cdbf08fc7f3678d09c95679d13d9/librt-0.7.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad64a14b1e56e702e19b24aae108f18ad1bf7777f3af5fcd39f87d0c5a814449", size = 206234, upload-time = "2026-01-14T12:55:16.571Z" },
+    { url = "https://files.pythonhosted.org/packages/61/de/1975200bb0285fc921c5981d9978ce6ce11ae6d797df815add94a5a848a3/librt-0.7.8-cp312-cp312-win32.whl", hash = "sha256:0241a6ed65e6666236ea78203a73d800dbed896cf12ae25d026d75dc1fcd1dac", size = 44057, upload-time = "2026-01-14T12:55:18.077Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/cd/724f2d0b3461426730d4877754b65d39f06a41ac9d0a92d5c6840f72b9ae/librt-0.7.8-cp312-cp312-win_amd64.whl", hash = "sha256:6db5faf064b5bab9675c32a873436b31e01d66ca6984c6f7f92621656033a708", size = 50293, upload-time = "2026-01-14T12:55:19.179Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cf/7e899acd9ee5727ad8160fdcc9994954e79fab371c66535c60e13b968ffc/librt-0.7.8-cp312-cp312-win_arm64.whl", hash = "sha256:57175aa93f804d2c08d2edb7213e09276bd49097611aefc37e3fa38d1fb99ad0", size = 43574, upload-time = "2026-01-14T12:55:20.185Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fe/b1f9de2829cf7fc7649c1dcd202cfd873837c5cc2fc9e526b0e7f716c3d2/librt-0.7.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4c3995abbbb60b3c129490fa985dfe6cac11d88fc3c36eeb4fb1449efbbb04fc", size = 57500, upload-time = "2026-01-14T12:55:21.219Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/d4/4a60fbe2e53b825f5d9a77325071d61cd8af8506255067bf0c8527530745/librt-0.7.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:44e0c2cbc9bebd074cf2cdbe472ca185e824be4e74b1c63a8e934cea674bebf2", size = 59019, upload-time = "2026-01-14T12:55:22.256Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/37/61ff80341ba5159afa524445f2d984c30e2821f31f7c73cf166dcafa5564/librt-0.7.8-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4d2f1e492cae964b3463a03dc77a7fe8742f7855d7258c7643f0ee32b6651dd3", size = 169015, upload-time = "2026-01-14T12:55:23.24Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/86/13d4f2d6a93f181ebf2fc953868826653ede494559da8268023fe567fca3/librt-0.7.8-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:451e7ffcef8f785831fdb791bd69211f47e95dc4c6ddff68e589058806f044c6", size = 178161, upload-time = "2026-01-14T12:55:24.826Z" },
+    { url = "https://files.pythonhosted.org/packages/88/26/e24ef01305954fc4d771f1f09f3dd682f9eb610e1bec188ffb719374d26e/librt-0.7.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3469e1af9f1380e093ae06bedcbdd11e407ac0b303a56bbe9afb1d6824d4982d", size = 193015, upload-time = "2026-01-14T12:55:26.04Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a0/92b6bd060e720d7a31ed474d046a69bd55334ec05e9c446d228c4b806ae3/librt-0.7.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f11b300027ce19a34f6d24ebb0a25fd0e24a9d53353225a5c1e6cadbf2916b2e", size = 192038, upload-time = "2026-01-14T12:55:27.208Z" },
+    { url = "https://files.pythonhosted.org/packages/06/bb/6f4c650253704279c3a214dad188101d1b5ea23be0606628bc6739456624/librt-0.7.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4adc73614f0d3c97874f02f2c7fd2a27854e7e24ad532ea6b965459c5b757eca", size = 186006, upload-time = "2026-01-14T12:55:28.594Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/00/1c409618248d43240cadf45f3efb866837fa77e9a12a71481912135eb481/librt-0.7.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:60c299e555f87e4c01b2eca085dfccda1dde87f5a604bb45c2906b8305819a93", size = 206888, upload-time = "2026-01-14T12:55:30.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/83/b2cfe8e76ff5c1c77f8a53da3d5de62d04b5ebf7cf913e37f8bca43b5d07/librt-0.7.8-cp313-cp313-win32.whl", hash = "sha256:b09c52ed43a461994716082ee7d87618096851319bf695d57ec123f2ab708951", size = 44126, upload-time = "2026-01-14T12:55:31.44Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/0b/c59d45de56a51bd2d3a401fc63449c0ac163e4ef7f523ea8b0c0dee86ec5/librt-0.7.8-cp313-cp313-win_amd64.whl", hash = "sha256:f8f4a901a3fa28969d6e4519deceab56c55a09d691ea7b12ca830e2fa3461e34", size = 50262, upload-time = "2026-01-14T12:55:33.01Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b9/973455cec0a1ec592395250c474164c4a58ebf3e0651ee920fef1a2623f1/librt-0.7.8-cp313-cp313-win_arm64.whl", hash = "sha256:43d4e71b50763fcdcf64725ac680d8cfa1706c928b844794a7aa0fa9ac8e5f09", size = 43600, upload-time = "2026-01-14T12:55:34.054Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/73/fa8814c6ce2d49c3827829cadaa1589b0bf4391660bd4510899393a23ebc/librt-0.7.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:be927c3c94c74b05128089a955fba86501c3b544d1d300282cc1b4bd370cb418", size = 57049, upload-time = "2026-01-14T12:55:35.056Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fe/f6c70956da23ea235fd2e3cc16f4f0b4ebdfd72252b02d1164dd58b4e6c3/librt-0.7.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7b0803e9008c62a7ef79058233db7ff6f37a9933b8f2573c05b07ddafa226611", size = 58689, upload-time = "2026-01-14T12:55:36.078Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4d/7a2481444ac5fba63050d9abe823e6bc16896f575bfc9c1e5068d516cdce/librt-0.7.8-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:79feb4d00b2a4e0e05c9c56df707934f41fcb5fe53fd9efb7549068d0495b758", size = 166808, upload-time = "2026-01-14T12:55:37.595Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/3c/10901d9e18639f8953f57c8986796cfbf4c1c514844a41c9197cf87cb707/librt-0.7.8-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9122094e3f24aa759c38f46bd8863433820654927370250f460ae75488b66ea", size = 175614, upload-time = "2026-01-14T12:55:38.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/01/5cbdde0951a5090a80e5ba44e6357d375048123c572a23eecfb9326993a7/librt-0.7.8-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e03bea66af33c95ce3addf87a9bf1fcad8d33e757bc479957ddbc0e4f7207ac", size = 189955, upload-time = "2026-01-14T12:55:39.939Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b4/e80528d2f4b7eaf1d437fcbd6fc6ba4cbeb3e2a0cb9ed5a79f47c7318706/librt-0.7.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1ade7f31675db00b514b98f9ab9a7698c7282dad4be7492589109471852d398", size = 189370, upload-time = "2026-01-14T12:55:41.057Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/938368f8ce31a9787ecd4becb1e795954782e4312095daf8fd22420227c8/librt-0.7.8-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a14229ac62adcf1b90a15992f1ab9c69ae8b99ffb23cb64a90878a6e8a2f5b81", size = 183224, upload-time = "2026-01-14T12:55:42.328Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/10/559c310e7a6e4014ac44867d359ef8238465fb499e7eb31b6bfe3e3f86f5/librt-0.7.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5bcaaf624fd24e6a0cb14beac37677f90793a96864c67c064a91458611446e83", size = 203541, upload-time = "2026-01-14T12:55:43.501Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/db/a0db7acdb6290c215f343835c6efda5b491bb05c3ddc675af558f50fdba3/librt-0.7.8-cp314-cp314-win32.whl", hash = "sha256:7aa7d5457b6c542ecaed79cec4ad98534373c9757383973e638ccced0f11f46d", size = 40657, upload-time = "2026-01-14T12:55:44.668Z" },
+    { url = "https://files.pythonhosted.org/packages/72/e0/4f9bdc2a98a798511e81edcd6b54fe82767a715e05d1921115ac70717f6f/librt-0.7.8-cp314-cp314-win_amd64.whl", hash = "sha256:3d1322800771bee4a91f3b4bd4e49abc7d35e65166821086e5afd1e6c0d9be44", size = 46835, upload-time = "2026-01-14T12:55:45.655Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3d/59c6402e3dec2719655a41ad027a7371f8e2334aa794ed11533ad5f34969/librt-0.7.8-cp314-cp314-win_arm64.whl", hash = "sha256:5363427bc6a8c3b1719f8f3845ea53553d301382928a86e8fab7984426949bce", size = 39885, upload-time = "2026-01-14T12:55:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/9c/2481d80950b83085fb14ba3c595db56330d21bbc7d88a19f20165f3538db/librt-0.7.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ca916919793a77e4a98d4a1701e345d337ce53be4a16620f063191f7322ac80f", size = 59161, upload-time = "2026-01-14T12:55:48.45Z" },
+    { url = "https://files.pythonhosted.org/packages/96/79/108df2cfc4e672336765d54e3ff887294c1cc36ea4335c73588875775527/librt-0.7.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:54feb7b4f2f6706bb82325e836a01be805770443e2400f706e824e91f6441dde", size = 61008, upload-time = "2026-01-14T12:55:49.527Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f2/30179898f9994a5637459d6e169b6abdc982012c0a4b2d4c26f50c06f911/librt-0.7.8-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:39a4c76fee41007070f872b648cc2f711f9abf9a13d0c7162478043377b52c8e", size = 187199, upload-time = "2026-01-14T12:55:50.587Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/da/f7563db55cebdc884f518ba3791ad033becc25ff68eb70902b1747dc0d70/librt-0.7.8-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac9c8a458245c7de80bc1b9765b177055efff5803f08e548dd4bb9ab9a8d789b", size = 198317, upload-time = "2026-01-14T12:55:51.991Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/6c/4289acf076ad371471fa86718c30ae353e690d3de6167f7db36f429272f1/librt-0.7.8-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b67aa7eff150f075fda09d11f6bfb26edffd300f6ab1666759547581e8f666", size = 210334, upload-time = "2026-01-14T12:55:53.682Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/7f/377521ac25b78ac0a5ff44127a0360ee6d5ddd3ce7327949876a30533daa/librt-0.7.8-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:535929b6eff670c593c34ff435d5440c3096f20fa72d63444608a5aef64dd581", size = 211031, upload-time = "2026-01-14T12:55:54.827Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b1/e1e96c3e20b23d00cf90f4aad48f0deb4cdfec2f0ed8380d0d85acf98bbf/librt-0.7.8-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:63937bd0f4d1cb56653dc7ae900d6c52c41f0015e25aaf9902481ee79943b33a", size = 204581, upload-time = "2026-01-14T12:55:56.811Z" },
+    { url = "https://files.pythonhosted.org/packages/43/71/0f5d010e92ed9747e14bef35e91b6580533510f1e36a8a09eb79ee70b2f0/librt-0.7.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf243da9e42d914036fd362ac3fa77d80a41cadcd11ad789b1b5eec4daaf67ca", size = 224731, upload-time = "2026-01-14T12:55:58.175Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f0/07fb6ab5c39a4ca9af3e37554f9d42f25c464829254d72e4ebbd81da351c/librt-0.7.8-cp314-cp314t-win32.whl", hash = "sha256:171ca3a0a06c643bd0a2f62a8944e1902c94aa8e5da4db1ea9a8daf872685365", size = 41173, upload-time = "2026-01-14T12:55:59.315Z" },
+    { url = "https://files.pythonhosted.org/packages/24/d4/7e4be20993dc6a782639625bd2f97f3c66125c7aa80c82426956811cfccf/librt-0.7.8-cp314-cp314t-win_amd64.whl", hash = "sha256:445b7304145e24c60288a2f172b5ce2ca35c0f81605f5299f3fa567e189d2e32", size = 47668, upload-time = "2026-01-14T12:56:00.261Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" },
+    { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
+    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
+    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
+    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/0f/7e6b713ac117c1f5e4e3300748af699b9902a2e5e34c9cf443dde25a01fa/opentelemetry_instrumentation-0.60b1.tar.gz", hash = "sha256:57ddc7974c6eb35865af0426d1a17132b88b2ed8586897fee187fd5b8944bd6a", size = 31706, upload-time = "2025-12-11T13:36:42.515Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/d2/6788e83c5c86a2690101681aeef27eeb2a6bf22df52d3f263a22cee20915/opentelemetry_instrumentation-0.60b1-py3-none-any.whl", hash = "sha256:04480db952b48fb1ed0073f822f0ee26012b7be7c3eac1a3793122737c78632d", size = 33096, upload-time = "2025-12-11T13:35:33.067Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" },
+]
+
+[[package]]
+name = "outcome"
+version = "1.3.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060, upload-time = "2023-10-26T04:26:04.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692, upload-time = "2023-10-26T04:26:02.532Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
+[[package]]
+name = "pytest-httpx"
+version = "0.36.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/5574834da9499066fa1a5ea9c336f94dba2eae02298d36dab192fcf95c86/pytest_httpx-0.36.0.tar.gz", hash = "sha256:9edb66a5fd4388ce3c343189bc67e7e1cb50b07c2e3fc83b97d511975e8a831b", size = 56793, upload-time = "2025-12-02T16:34:57.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/d2/1eb1ea9c84f0d2033eb0b49675afdc71aa4ea801b74615f00f3c33b725e3/pytest_httpx-0.36.0-py3-none-any.whl", hash = "sha256:bd4c120bb80e142df856e825ec9f17981effb84d159f9fa29ed97e2357c3a9c8", size = 20229, upload-time = "2025-12-02T16:34:56.45Z" },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
+]
+
+[[package]]
+name = "pytest-trio"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "outcome" },
+    { name = "pytest" },
+    { name = "trio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/08/056279526554c6c6e6ad6d4a479a338d14dc785ac30be8bdc6ca0153c1be/pytest-trio-0.8.0.tar.gz", hash = "sha256:8363db6336a79e6c53375a2123a41ddbeccc4aa93f93788651641789a56fb52e", size = 46525, upload-time = "2022-11-01T17:24:29.352Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/22/71953f47e0da5852c899f58cd7a31e6100f37c632b7b9ee52d067613a844/pytest_trio-0.8.0-py3-none-any.whl", hash = "sha256:e6a7e7351ae3e8ec3f4564d30ee77d1ec66e1df611226e5618dbb32f9545c841", size = 27221, upload-time = "2022-11-01T17:24:27.501Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/99/a4cab2acbb884f80e558b0771e97e21e939c5dfb460f488d19df485e8298/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8", size = 230143, upload-time = "2026-02-01T16:20:47.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/39/5cee96809fbca590abea6b46c6d1c586b49663d1d2830a751cc8fc42c666/ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a", size = 4524893, upload-time = "2026-02-03T17:53:35.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/88/3fd1b0aa4b6330d6aaa63a285bc96c9f71970351579152d231ed90914586/ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455", size = 10354332, upload-time = "2026-02-03T17:52:54.892Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f6/62e173fbb7eb75cc29fe2576a1e20f0a46f671a2587b5f604bfb0eaf5f6f/ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d", size = 10767189, upload-time = "2026-02-03T17:53:19.778Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/968ae17b676d1d2ff101d56dc69cf333e3a4c985e1ec23803df84fc7bf9e/ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce", size = 10075384, upload-time = "2026-02-03T17:53:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/bf/9843c6044ab9e20af879c751487e61333ca79a2c8c3058b15722386b8cae/ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621", size = 10481363, upload-time = "2026-02-03T17:52:43.332Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d9/4ada5ccf4cd1f532db1c8d44b6f664f2208d3d93acbeec18f82315e15193/ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9", size = 10187736, upload-time = "2026-02-03T17:53:00.522Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e2/f25eaecd446af7bb132af0a1d5b135a62971a41f5366ff41d06d25e77a91/ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179", size = 10968415, upload-time = "2026-02-03T17:53:15.705Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/dc/f06a8558d06333bf79b497d29a50c3a673d9251214e0d7ec78f90b30aa79/ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d", size = 11809643, upload-time = "2026-02-03T17:53:23.031Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/45/0ece8db2c474ad7df13af3a6d50f76e22a09d078af63078f005057ca59eb/ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78", size = 11234787, upload-time = "2026-02-03T17:52:46.432Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/d9/0e3a81467a120fd265658d127db648e4d3acfe3e4f6f5d4ea79fac47e587/ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4", size = 11112797, upload-time = "2026-02-03T17:52:49.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cb/8c0b3b0c692683f8ff31351dfb6241047fa873a4481a76df4335a8bff716/ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e", size = 11033133, upload-time = "2026-02-03T17:53:33.105Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5e/23b87370cf0f9081a8c89a753e69a4e8778805b8802ccfe175cc410e50b9/ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662", size = 10442646, upload-time = "2026-02-03T17:53:06.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9a/3c94de5ce642830167e6d00b5c75aacd73e6347b4c7fc6828699b150a5ee/ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1", size = 10195750, upload-time = "2026-02-03T17:53:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/30/15/e396325080d600b436acc970848d69df9c13977942fb62bb8722d729bee8/ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16", size = 10676120, upload-time = "2026-02-03T17:53:09.363Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/229a23d52a2983de1ad0fb0ee37d36e0257e6f28bfd6b498ee2c76361874/ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3", size = 11201636, upload-time = "2026-02-03T17:52:57.281Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/b0/69adf22f4e24f3677208adb715c578266842e6e6a3cc77483f48dd999ede/ruff-0.15.0-py3-none-win32.whl", hash = "sha256:238a717ef803e501b6d51e0bdd0d2c6e8513fe9eec14002445134d3907cd46c3", size = 10465945, upload-time = "2026-02-03T17:53:12.591Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ad/f813b6e2c97e9b4598be25e94a9147b9af7e60523b0cb5d94d307c15229d/ruff-0.15.0-py3-none-win_amd64.whl", hash = "sha256:dd5e4d3301dc01de614da3cdffc33d4b1b96fb89e45721f1598e5532ccf78b18", size = 11564657, upload-time = "2026-02-03T17:52:51.893Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b0/2d823f6e77ebe560f4e397d078487e8d52c1516b331e3521bc75db4272ca/ruff-0.15.0-py3-none-win_arm64.whl", hash = "sha256:c480d632cc0ca3f0727acac8b7d053542d9e114a462a145d0b00e7cd658c515a", size = 10865753, upload-time = "2026-02-03T17:53:03.014Z" },
+]
+
+[[package]]
+name = "rust-just"
+version = "1.46.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/50/3828817f76e19977a4048c2c8b39a7f48babc21dd9dbed4af2f3c18d4570/rust_just-1.46.0.tar.gz", hash = "sha256:84437481c814577529835132e2cc5fcc35a981c1712e4877cb20fc2f5ec5b2d6", size = 1447346, upload-time = "2026-01-03T02:03:17.948Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/0b/a5bf2707b02a484d91f8275efa39f76fe19304f5bfba82293fa4b18608d2/rust_just-1.46.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7d6d4c67a443f1acb1f78f9ba4b3349fa04f17e8be2d4448b771cdc93a382812", size = 1739556, upload-time = "2026-01-03T02:02:42.835Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ae/40bcd996ccb2fcb0152b5bfde7beaf3840877a8837611421c495b45c82da/rust_just-1.46.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0caf9b77d30455558d017c9e625ce94c373f88d81656477127727604fa5d36ab", size = 1620974, upload-time = "2026-01-03T02:02:45.341Z" },
+    { url = "https://files.pythonhosted.org/packages/62/36/7067e0eaf674ed7c98b35ed50d713c0c885f2d2b57847a627e11502da1b8/rust_just-1.46.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b63521acd91c65164c202ded3ae730130c7fb4377f59cd2f9847b45161c94fd", size = 1703423, upload-time = "2026-01-03T02:02:47.681Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/47/3e98182f5e03c48880d647651385863552a3e24cfec5c51d116c06e6f180/rust_just-1.46.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46a35110c7acf27bdded79cf3bbfea9eb80a53f6f81f374248fe3340584c92e5", size = 1666645, upload-time = "2026-01-03T02:02:50.38Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5e/b9badf6e6982e5744f076d12ab911e5ac8b4b03a0674bab4f498ed9d0b4c/rust_just-1.46.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a2407cefc2e5ed4527297747bd5bcb61a885776021cb2438c3a7b118b2cabc2", size = 1847430, upload-time = "2026-01-03T02:02:52.716Z" },
+    { url = "https://files.pythonhosted.org/packages/98/10/6916d7c862b99de600a1fd3739d13353c220dfbc0229a0b2c5012c2f801d/rust_just-1.46.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0dab319619f600561b993242312a344953b1ea44637b30257af905a70ce6f568", size = 1926224, upload-time = "2026-01-03T02:02:55.194Z" },
+    { url = "https://files.pythonhosted.org/packages/24/93/18bc615e68a80f43105d5e7cc3571e85776aec829ac40faae4de5d5dc2f3/rust_just-1.46.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3b4c26dd86e5d96047fc0935967f22cb9f49c687767d78b7d3fe511eba39ffa", size = 1902165, upload-time = "2026-01-03T02:02:57.636Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/e3c19a24ff64e78a04df0bdf4c61e15c28dcac8b7b5c3a5505eb5749d40a/rust_just-1.46.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdb496ca26efc508be0e625309b74b1f6316b4f7295d13247c3b791dfa77eb1", size = 1835209, upload-time = "2026-01-03T02:03:00.256Z" },
+    { url = "https://files.pythonhosted.org/packages/26/75/0850c38e41025794826165329a097f657152902a785c0579f213b7d61ae6/rust_just-1.46.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3cf1c32a258f8ee44af877ec271e2eea257923a3303a6d2610b0b5f1523daaab", size = 1719519, upload-time = "2026-01-03T02:03:02.774Z" },
+    { url = "https://files.pythonhosted.org/packages/48/85/53c6ee2b9cdbbe1bd43cd0f8096036c29e9e6ba2d3d6344206c490e2ce18/rust_just-1.46.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:657ab85882c124b0fbcd75763035d0dbd20b06c582cc6d4f55017d7b517d5a89", size = 1685664, upload-time = "2026-01-03T02:03:05.514Z" },
+    { url = "https://files.pythonhosted.org/packages/33/04/1ad3a66bef0d0f554f0f9971b048bbaf7b3955458f3fda47b48fbf8ff009/rust_just-1.46.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:644b71bfe68863b71ee2618a88dbfd446ea70e2dcfa7b0e5eaec7b6dc4faceca", size = 1838231, upload-time = "2026-01-03T02:03:07.618Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/75/33c2e887a68e57b356cda74d325d6ebe406bb72ad8c4e2d067d4fa9b697b/rust_just-1.46.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e9d8a879fb86eb1c7f7f83953999ae4ce53ea4e5c0ca531cf6ff09e1e9335ff7", size = 1900319, upload-time = "2026-01-03T02:03:09.873Z" },
+    { url = "https://files.pythonhosted.org/packages/44/30/6b1677aa64a4f69f3ec174b5e2a9a49e0ffd06946d4b4dc8295366fbd9dd/rust_just-1.46.0-py3-none-win32.whl", hash = "sha256:100701de91bded3f6f2bf564d09c2f8e483b8dfb490d1c74008ce3c01ff0ff67", size = 1623463, upload-time = "2026-01-03T02:03:12.343Z" },
+    { url = "https://files.pythonhosted.org/packages/64/61/97ad7a1ea67b9485404b18150c258015842cf116a1ce626421863fd8f0e1/rust_just-1.46.0-py3-none-win_amd64.whl", hash = "sha256:ccaf8e473f64f5c815b0039e883a1feaf5634b9cdffd1dbff9e5fde77b5926f4", size = 1801103, upload-time = "2026-01-03T02:03:15.256Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
+[[package]]
+name = "stevedore"
+version = "5.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/5b/496f8abebd10c3301129abba7ddafd46c71d799a70c44ab080323987c4c9/stevedore-5.6.0.tar.gz", hash = "sha256:f22d15c6ead40c5bbfa9ca54aa7e7b4a07d59b36ae03ed12ced1a54cf0b51945", size = 516074, upload-time = "2025-11-20T10:06:07.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/40/8561ce06dc46fd17242c7724ab25b257a2ac1b35f4ebf551b40ce6105cfa/stevedore-5.6.0-py3-none-any.whl", hash = "sha256:4a36dccefd7aeea0c70135526cecb7766c4c84c473b1af68db23d541b6dc1820", size = 54428, upload-time = "2025-11-20T10:06:05.946Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
+]
+
+[[package]]
+name = "trio"
+version = "0.32.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
+    { name = "idna" },
+    { name = "outcome" },
+    { name = "sniffio" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d8/ce/0041ddd9160aac0031bcf5ab786c7640d795c797e67c438e15cfedf815c8/trio-0.32.0.tar.gz", hash = "sha256:150f29ec923bcd51231e1d4c71c7006e65247d68759dd1c19af4ea815a25806b", size = 605323, upload-time = "2025-10-31T07:18:17.466Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/bf/945d527ff706233636c73880b22c7c953f3faeb9d6c7e2e85bfbfd0134a0/trio-0.32.0-py3-none-any.whl", hash = "sha256:4ab65984ef8370b79a76659ec87aa3a30c5c7c83ff250b4de88c29a8ab6123c5", size = 512030, upload-time = "2025-10-31T07:18:15.885Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.22"
+source = { editable = "." }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "bandit" },
+    { name = "mypy" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "pytest-httpx" },
+    { name = "pytest-mock" },
+    { name = "pytest-trio" },
+    { name = "ruff" },
+    { name = "rust-just" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.36.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath-platform/.python-version b/packages/uipath-platform/.python-version
new file mode 100644
index 000000000..2c0733315
--- /dev/null
+++ b/packages/uipath-platform/.python-version
@@ -0,0 +1 @@
+3.11
diff --git a/packages/uipath-platform/CLAUDE.md b/packages/uipath-platform/CLAUDE.md
new file mode 100644
index 000000000..21896676f
--- /dev/null
+++ b/packages/uipath-platform/CLAUDE.md
@@ -0,0 +1,119 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the `uipath-platform` package.
+
+## Package Purpose
+
+HTTP client layer for UiPath Platform APIs. Provides typed service classes for all orchestrator and platform resources. Depends on `uipath-core`, httpx, tenacity, and pydantic.
+
+## Development Commands
+
+```bash
+cd packages/uipath-platform
+
+uv sync --all-extras          # Install dependencies
+pytest                        # Run all tests
+pytest tests/services/test_assets_service.py  # Single test file
+ruff check .                  # Lint
+ruff format --check .         # Format check
+mypy src tests                # Type check
+```
+
+No justfile exists for this package — run commands directly.
+
+## Entry Point: `UiPath` Class
+
+`_uipath.py` defines the main `UiPath` class that exposes all services as properties:
+
+```python
+from uipath.platform import UiPath
+sdk = UiPath()
+sdk.assets              # AssetsService
+sdk.attachments         # AttachmentsService
+sdk.processes           # ProcessesService
+sdk.buckets             # BucketsService
+sdk.queues              # QueuesService
+sdk.jobs                # JobsService
+sdk.folders             # FolderService
+sdk.tasks               # TasksService (Action Center)
+sdk.connections         # ConnectionsService
+sdk.context_grounding   # ContextGroundingService
+sdk.documents           # DocumentsService
+sdk.entities            # EntitiesService
+sdk.llm                 # UiPathLlmChatService
+sdk.llm_openai          # UiPathOpenAIService
+sdk.conversational      # ConversationsService
+sdk.guardrails          # GuardrailsService
+sdk.agenthub            # AgentHubService
+sdk.mcp                 # McpService
+sdk.resource_catalog    # ResourceCatalogService
+sdk.automation_tracker  # AutomationTrackerService
+```
+
+### Authentication
+
+Credentials can be provided via constructor parameters or environment variables (`UIPATH_URL`, `UIPATH_ACCESS_TOKEN`). Two auth modes are supported:
+
+- **User authentication** — provide `base_url` and `secret` (access token), or set them via env vars
+- **S2S (service-to-service)** — provide `client_id` and `client_secret` (both required together), optionally with `scope`; uses `ExternalApplicationService` internally to exchange for an access token
+
+Configuration is validated with Pydantic; missing `base_url` raises `BaseUrlMissingError`, missing `secret` raises `SecretMissingError`.
+
+## Service Architecture
+
+### Two-File Pattern (orchestrator/)
+
+Each orchestrator resource uses two files:
+- **`_<resource>_service.py`** — Internal service class extending `BaseService` and `FolderContext`. Contains HTTP logic (httpx calls, URL construction, retry, error handling). Methods decorated with `@traced` and `@resource_override`.
+- **`<resource>.py`** — Public Pydantic models for the resource.
+
+### BaseService (`common/_base_service.py`)
+
+All services inherit from `BaseService` which provides:
+- `request()` / `request_async()` — HTTP methods with tenacity-based retry (exponential backoff)
+- Automatic exception enrichment via `EnrichedException`
+- User-agent tracking and span utilities
+
+### FolderContext (`common/_folder_context.py`)
+
+Manages folder scoping (by `folder_key` or `folder_path`) for orchestrator operations.
+
+### Method Naming Convention
+
+- `retrieve` — get single resource by key
+- `retrieve_by_[field]` — get by alternate field
+- `list` — get multiple resources
+
+### Sync + Async
+
+Services provide both sync and async variants (e.g., `.invoke()` and `.invoke_async()`).
+
+## Modules Beyond Orchestrator
+
+| Module | Purpose |
+|--------|---------|
+| `action_center/` | Task management for human-in-the-loop workflows |
+| `agenthub/` | System agents and LLM model discovery |
+| `automation_tracker/` | Business Transaction Service (BTS) for Process Mining |
+| `chat/` | LLM gateway, conversations, throttling |
+| `connections/` | External connection management |
+| `context_grounding/` | RAG services (DeepRAG, batch RAG, ephemeral indexes) |
+| `documents/` | Document Understanding (IXP) |
+| `entities/` | Data Service entity management |
+| `guardrails/` | LLM output guardrails |
+| `resource_catalog/` | Resource discovery and metadata |
+| `resume_triggers/` | HITL trigger creation/reading protocols |
+| `common/` | Shared base classes, config, auth, retry, paging, validation |
+| `errors/` | Custom exceptions (`EnrichedException`, `FolderNotFoundException`, `BaseUrlMissingError`, etc.) |
+
+## Test Structure
+
+All tests are under `tests/services/` with one test file per service. Tests use `pytest-httpx` for HTTP mocking.
+
+### Key Test Fixtures (`tests/services/conftest.py`)
+
+- `base_url` — returns `"https://test.uipath.com"`
+- `config` — `UiPathApiConfig` instance
+- `execution_context` — `UiPathExecutionContext` with mocked `UIPATH_ROBOT_KEY`
+- `mock_env_vars` — standard mock env vars (URL, tokens, IDs)
+- Service-specific fixtures (e.g., `jobs_service`) built from config + execution_context
diff --git a/packages/uipath-platform/CONTRIBUTING.md b/packages/uipath-platform/CONTRIBUTING.md
new file mode 100644
index 000000000..d47717b3d
--- /dev/null
+++ b/packages/uipath-platform/CONTRIBUTING.md
@@ -0,0 +1,115 @@
+# Contributing to UiPath Runtime SDK
+
+## Local Development Setup
+
+### Prerequisites
+
+1. **Install Python ≥ 3.11**:
+    - Download and install Python 3.11 from the official [Python website](https://www.python.org/downloads/)
+    - Verify the installation by running:
+        ```sh
+        python3.11 --version
+        ```
+
+    Alternative: [mise](https://mise.jdx.dev/lang/python.html)
+
+2. **Install [uv](https://docs.astral.sh/uv/)**:
+    Follow the official installation instructions for your operating system.
+
+3. **Create a virtual environment in the current working directory**:
+    ```sh
+    uv venv
+    ```
+
+4. **Activate the virtual environment**:
+    - Linux/Mac
+    ```sh
+    source .venv/bin/activate
+    ```
+    - Windows Powershell
+    ```sh
+    .venv\Scripts\Activate.ps1
+    ```
+    - Windows Bash
+    ```sh
+    source .venv/Scripts/activate
+    ```
+
+5. **Install dependencies**:
+    ```sh
+    uv sync --all-extras --no-cache
+    ```
+
+For additional commands related to linting, formatting, and building, run `just --list`.
+
+### Using the SDK Locally
+
+1. Create a project directory:
+    ```sh
+    mkdir project
+    cd project
+    ```
+
+2. Initialize the Python project:
+    ```sh
+    uv init . --python 3.11
+    ```
+
+3. Set the SDK path:
+    ```sh
+    PATH_TO_SDK=/Users/YOUR_USERNAME/uipath-platform-python
+    ```
+
+4. Install the SDK in editable mode:
+    ```sh
+    uv add --editable ${PATH_TO_SDK}
+    ```
+
+> **Note:** Instead of cloning the project into `.venv/lib/python3.11/site-packages/uipath-platform`, this mode creates a file named `_uipath-platform.pth` inside `.venv/lib/python3.11/site-packages`. This file contains the value of `PATH_TO_SDK`, which is added to `sys.path`—the list of directories where Python searches for packages. To view the entries, run `python -c 'import sys; print(sys.path)'`.
+
+## Service URL Overrides
+
+When developing a UiPath service locally, you can redirect SDK requests to your local server using environment variables:
+
+```bash
+UIPATH_SERVICE_URL_<SERVICE>=http://localhost:<port>
+```
+
+The service name maps from the endpoint prefix — strip the trailing underscore and uppercase it:
+
+| Prefix              | Env var                              |
+|---------------------|--------------------------------------|
+| `agenthub_/`        | `UIPATH_SERVICE_URL_AGENTHUB`        |
+| `orchestrator_/`    | `UIPATH_SERVICE_URL_ORCHESTRATOR`    |
+| `agentsruntime_/`   | `UIPATH_SERVICE_URL_AGENTSRUNTIME`   |
+| `du_/`              | `UIPATH_SERVICE_URL_DU`              |
+| `ecs_/`             | `UIPATH_SERVICE_URL_ECS`             |
+| `connections_/`     | `UIPATH_SERVICE_URL_CONNECTIONS`     |
+| `identity_/`        | `UIPATH_SERVICE_URL_IDENTITY`        |
+| `apps_/`            | `UIPATH_SERVICE_URL_APPS`            |
+| `datafabric_/`      | `UIPATH_SERVICE_URL_DATAFABRIC`      |
+| `resourcecatalog_/` | `UIPATH_SERVICE_URL_RESOURCECATALOG` |
+
+### What happens
+
+1. The org/tenant prefix and service prefix are stripped — your local server receives only the API path:
+
+   ```
+   agenthub_/llm/api/chat/completions → http://localhost:5200/llm/api/chat/completions
+   orchestrator_/odata/Processes      → http://localhost:5300/odata/Processes
+   ```
+
+2. Routing headers (`X-UiPath-Internal-TenantId`, `X-UiPath-Internal-AccountId`) are injected automatically since the platform routing layer is bypassed.
+
+### Example `.env`
+
+```bash
+UIPATH_URL=https://alpha.uipath.com/org/tenant
+UIPATH_ACCESS_TOKEN=your-token
+UIPATH_ORGANIZATION_ID=your-org-id
+UIPATH_TENANT_ID=your-tenant-id
+
+# Override agenthub and orchestrator to local servers
+UIPATH_SERVICE_URL_AGENTHUB=http://localhost:5200
+UIPATH_SERVICE_URL_ORCHESTRATOR=http://localhost:5300
+```
diff --git a/packages/uipath-platform/README.md b/packages/uipath-platform/README.md
new file mode 100644
index 000000000..a910e3f54
--- /dev/null
+++ b/packages/uipath-platform/README.md
@@ -0,0 +1,3 @@
+# UiPath Platform
+
+Python SDK for interacting programmatically with UiPath services.
diff --git a/pyproject.toml b/packages/uipath-platform/pyproject.toml
similarity index 65%
rename from pyproject.toml
rename to packages/uipath-platform/pyproject.toml
index f97977d2b..cfe85a61e 100644
--- a/pyproject.toml
+++ b/packages/uipath-platform/pyproject.toml
@@ -1,29 +1,24 @@
 [project]
-name = "uipath"
-version = "2.1.2"
-description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
+name = "uipath-platform"
+version = "0.1.76"
+description = "HTTP client library for programmatic access to UiPath Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
-  "click>=8.1.8",
   "httpx>=0.28.1",
-  "opentelemetry-sdk>=1.31.1",
-  "pydantic>=2.11.1",
-  "python-dotenv>=1.0.1",
   "tenacity>=9.0.0",
-  "tomli>=2.2.1",
-  "pathlib>=1.0.1",
-  "rich>=13.0.0",
-  "azure-monitor-opentelemetry>=1.6.8",
-  "truststore>=0.10.1"
+  "truststore>=0.10.1",
+  "uipath-core>=0.5.21, <0.6.0",
+  "pydantic-function-models>=0.1.11",
+  "sqlparse>=0.5.5",
 ]
 classifiers = [
-  "Development Status :: 3 - Alpha",
   "Intended Audience :: Developers",
   "Topic :: Software Development :: Build Tools",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+
 ]
 maintainers = [
   { name = "Marius Cosareanu", email = "marius.cosareanu@uipath.com" },
@@ -35,9 +30,6 @@ Homepage = "https://uipath.com"
 Repository = "https://github.com/UiPath/uipath-python"
 Documentation = "https://uipath.github.io/uipath-python/"
 
-[project.scripts]
-uipath = "uipath._cli:cli"
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -45,7 +37,7 @@ build-backend = "hatchling.build"
 [dependency-groups]
 dev = [
   "bandit>=1.8.2",
-  "mypy>=1.14.1",
+  "mypy>=1.19.0",
   "ruff>=0.9.4",
   "rust-just>=1.39.0",
   "pytest>=7.4.0",
@@ -55,16 +47,6 @@ dev = [
   "pytest-cov>=4.1.0",
   "pytest-mock>=3.11.1",
   "pre-commit>=4.1.0",
-  "mkdocs>=1.6.1",
-  "mkdocs-material[imaging]>=9.6.7",
-  "mkdocstrings[python]>=0.18",
-  "termynal>=0.13.0",
-  "mkdocs-simple-hooks>=0.1.5",
-  "mkdocs-click>=0.9.0",
-  "mkdocs-open-in-new-tab>=1.0.8",
-  "toml>=0.10.2",
-  "inflection>=0.5.1",
-  "types-toml>=0.10.8",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -73,7 +55,7 @@ packages = ["src/uipath"]
 [tool.ruff]
 line-length = 88
 indent-width = 4
-exclude = ["samples/**"]
+exclude = ["samples/**", "testcases/**"]
 
 [tool.ruff.lint]
 select = ["E", "F", "B", "I", "D"]
@@ -87,11 +69,6 @@ ignore-decorators = []
 "*" = ["E501"]
 "tests/**" = ["D"]
 "*_test.py" = ["D"]
-"docs/**" = ["D"]
-# TODO: Remove this once the documentation for CLI is updated
-"uipath/_cli/**" = ["D"]
-# TODO: Remove this once model documentation is added
-"src/uipath/models/**" = ["D101", "D100", "D104", "D102", "D107"]
 
 [tool.ruff.format]
 quote-style = "double"
@@ -101,9 +78,9 @@ line-ending = "auto"
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]
-exclude = ["samples/.*"]
-
-
+mypy_path = "src"
+explicit_package_bases = true
+namespace_packages = true
 follow_imports = "silent"
 warn_redundant_casts = true
 warn_unused_ignores = true
@@ -121,15 +98,42 @@ warn_required_dynamic_aliases = true
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"
-addopts = "-ra -q --cov"
+addopts = "-ra -q --cov=src --cov-report=term-missing -m 'not e2e'"
 asyncio_default_fixture_loop_scope = "function"
 asyncio_mode = "auto"
+markers = [
+    "e2e: end-to-end tests against real ECS/LLMOps (requires UIPATH_URL, UIPATH_ACCESS_TOKEN, UIPATH_FOLDER_KEY)",
+]
+
+[tool.coverage.run]
+source = ["src"]
+relative_files = true
+omit = [
+  "*/tests/*",
+  "*/__pycache__/*",
+  "*/site-packages/*",
+  "*/conftest.py",
+]
 
 [tool.coverage.report]
 show_missing = true
+precision = 2
+exclude_lines = [
+  "pragma: no cover",
+  "def __repr__",
+  "raise NotImplementedError",
+  "if TYPE_CHECKING:",
+  "@(abc\\.)?abstractmethod",
+]
 
-[tool.coverage.run]
-source = ["src"]
+[tool.uv]
+exclude-newer = "2 days"
+
+[tool.uv.exclude-newer-package]
+uipath-core = false
+
+[tool.uv.sources]
+uipath-core = { path = "../uipath-core", editable = true }
 
 [[tool.uv.index]]
 name = "testpypi"
diff --git a/src/uipath/__init__.py b/packages/uipath-platform/src/uipath/platform/__init__.py
similarity index 52%
rename from src/uipath/__init__.py
rename to packages/uipath-platform/src/uipath/platform/__init__.py
index 39be65295..61abb103c 100644
--- a/src/uipath/__init__.py
+++ b/packages/uipath-platform/src/uipath/platform/__init__.py
@@ -12,13 +12,29 @@
     # export UIPATH_ACCESS_TOKEN="your_**_token"
     # export UIPATH_FOLDER_PATH="your/folder/path"
 
-    from uipath import UiPath
+    from uipath.platform import UiPath
     sdk = UiPath()
     # Invoke a process by name
     sdk.processes.invoke("MyProcess")
 ```
+
+## Error Handling
+
+Exception classes are available in the `errors` module and should be imported explicitly:
+
+```python
+    from uipath.platform.errors import (
+        BaseUrlMissingError,
+        SecretMissingError,
+        EnrichedException,
+        IngestionInProgressException,
+        FolderNotFoundException,
+        UnsupportedDataSourceException,
+    )
+```
 """
 
 from ._uipath import UiPath
+from .common import UiPathApiConfig, UiPathExecutionContext
 
-__all__ = ["UiPath"]
+__all__ = ["UiPathApiConfig", "UiPath", "UiPathExecutionContext"]
diff --git a/packages/uipath-platform/src/uipath/platform/_uipath.py b/packages/uipath-platform/src/uipath/platform/_uipath.py
new file mode 100644
index 000000000..0083388db
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/_uipath.py
@@ -0,0 +1,203 @@
+from functools import cached_property
+from typing import Optional
+
+from pydantic import ValidationError
+
+from uipath.platform.automation_tracker import AutomationTrackerService
+
+from .action_center import TasksService
+from .agenthub._agenthub_service import AgentHubService
+from .agenthub._remote_a2a_service import RemoteA2aService
+from .automation_ops import AutomationOpsService
+from .chat import ConversationsService, UiPathLlmChatService, UiPathOpenAIService
+from .common import (
+    ApiClient,
+    ExternalApplicationService,
+    UiPathApiConfig,
+    UiPathExecutionContext,
+)
+from .common.auth import resolve_config_from_env
+from .connections import ConnectionsService
+from .context_grounding import ContextGroundingService
+from .documents import DocumentsService
+from .entities import EntitiesService
+from .errors import BaseUrlMissingError, SecretMissingError
+from .governance import GovernanceService
+from .guardrails import GuardrailsService
+from .memory import MemoryService
+from .orchestrator import (
+    AssetsService,
+    AttachmentsService,
+    BucketsService,
+    FolderService,
+    JobsService,
+    McpService,
+    OrchestratorSetupService,
+    ProcessesService,
+    QueuesService,
+)
+from .pii_detection import PiiDetectionService
+from .resource_catalog import ResourceCatalogService
+from .semantic_proxy import SemanticProxyService
+
+
+def _has_valid_client_credentials(
+    client_id: Optional[str], client_secret: Optional[str]
+) -> bool:
+    if bool(client_id) != bool(client_secret):
+        raise ValueError("Both client_id and client_secret must be provided together.")
+    return bool(client_id and client_secret)
+
+
+class UiPath:
+    def __init__(
+        self,
+        *,
+        base_url: Optional[str] = None,
+        secret: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        scope: Optional[str] = None,
+        debug: bool = False,
+    ) -> None:
+        try:
+            if _has_valid_client_credentials(client_id, client_secret):
+                assert client_id and client_secret
+                service = ExternalApplicationService(base_url)
+                token_data = service.get_token_data(client_id, client_secret, scope)
+                base_url, secret = service._base_url, token_data.access_token
+            else:
+                base_url, secret = resolve_config_from_env(base_url, secret)
+
+            self._config = UiPathApiConfig(
+                base_url=base_url,
+                secret=secret,
+            )
+        except ValidationError as e:
+            for error in e.errors():
+                if error["loc"][0] == "base_url":
+                    raise BaseUrlMissingError() from e
+                elif error["loc"][0] == "secret":
+                    raise SecretMissingError() from e
+        self._execution_context = UiPathExecutionContext()
+
+    @property
+    def api_client(self) -> ApiClient:
+        return ApiClient(self._config, self._execution_context)
+
+    @property
+    def assets(self) -> AssetsService:
+        return AssetsService(self._config, self._execution_context)
+
+    @cached_property
+    def attachments(self) -> AttachmentsService:
+        return AttachmentsService(self._config, self._execution_context)
+
+    @property
+    def processes(self) -> ProcessesService:
+        return ProcessesService(self._config, self._execution_context, self.attachments)
+
+    @property
+    def tasks(self) -> TasksService:
+        return TasksService(self._config, self._execution_context)
+
+    @cached_property
+    def buckets(self) -> BucketsService:
+        return BucketsService(self._config, self._execution_context)
+
+    @cached_property
+    def connections(self) -> ConnectionsService:
+        return ConnectionsService(self._config, self._execution_context, self.folders)
+
+    @property
+    def context_grounding(self) -> ContextGroundingService:
+        return ContextGroundingService(
+            self._config,
+            self._execution_context,
+            self.folders,
+            self.buckets,
+        )
+
+    @property
+    def memory(self) -> MemoryService:
+        return MemoryService(self._config, self._execution_context, self.folders)
+
+    @property
+    def documents(self) -> DocumentsService:
+        return DocumentsService(self._config, self._execution_context)
+
+    @property
+    def queues(self) -> QueuesService:
+        return QueuesService(self._config, self._execution_context)
+
+    @property
+    def jobs(self) -> JobsService:
+        return JobsService(self._config, self._execution_context)
+
+    @cached_property
+    def folders(self) -> FolderService:
+        return FolderService(self._config, self._execution_context)
+
+    @property
+    def llm_openai(self) -> UiPathOpenAIService:
+        return UiPathOpenAIService(self._config, self._execution_context)
+
+    @property
+    def llm(self) -> UiPathLlmChatService:
+        return UiPathLlmChatService(self._config, self._execution_context)
+
+    @property
+    def entities(self) -> EntitiesService:
+        return EntitiesService(
+            self._config, self._execution_context, folders_service=self.folders
+        )
+
+    @cached_property
+    def resource_catalog(self) -> ResourceCatalogService:
+        return ResourceCatalogService(
+            self._config, self._execution_context, self.folders
+        )
+
+    @property
+    def conversational(self) -> ConversationsService:
+        return ConversationsService(self._config, self._execution_context)
+
+    @property
+    def mcp(self) -> McpService:
+        return McpService(self._config, self._execution_context, self.folders)
+
+    @property
+    def guardrails(self) -> GuardrailsService:
+        return GuardrailsService(self._config, self._execution_context)
+
+    @cached_property
+    def governance(self) -> GovernanceService:
+        return GovernanceService(self._config, self._execution_context)
+
+    @property
+    def agenthub(self) -> AgentHubService:
+        return AgentHubService(self._config, self._execution_context, self.folders)
+
+    @property
+    def remote_a2a(self) -> RemoteA2aService:
+        return RemoteA2aService(self._config, self._execution_context, self.folders)
+
+    @property
+    def orchestrator_setup(self) -> OrchestratorSetupService:
+        return OrchestratorSetupService(self._config, self._execution_context)
+
+    @property
+    def automation_ops(self) -> AutomationOpsService:
+        return AutomationOpsService(self._config, self._execution_context)
+
+    @property
+    def pii_detection(self) -> PiiDetectionService:
+        return PiiDetectionService(self._config, self._execution_context)
+
+    @property
+    def semantic_proxy(self) -> SemanticProxyService:
+        return SemanticProxyService(self._config, self._execution_context)
+
+    @property
+    def automation_tracker(self) -> AutomationTrackerService:
+        return AutomationTrackerService(self._config, self._execution_context)
diff --git a/packages/uipath-platform/src/uipath/platform/action_center/__init__.py b/packages/uipath-platform/src/uipath/platform/action_center/__init__.py
new file mode 100644
index 000000000..675f50eb6
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/action_center/__init__.py
@@ -0,0 +1,14 @@
+"""UiPath Action Center Models.
+
+This module contains models related to UiPath Action Center service.
+"""
+
+from ._tasks_service import TasksService
+from .task_schema import TaskSchema
+from .tasks import Task
+
+__all__ = [
+    "TasksService",
+    "Task",
+    "TaskSchema",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/action_center/_tasks_service.py b/packages/uipath-platform/src/uipath/platform/action_center/_tasks_service.py
new file mode 100644
index 000000000..2c4a4bde7
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/action_center/_tasks_service.py
@@ -0,0 +1,947 @@
+import asyncio
+import os
+import uuid
+from typing import Any, Dict, List, Optional
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig, UiPathConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..common.constants import (
+    ENV_TENANT_ID,
+    HEADER_TENANT_ID,
+)
+from .task_schema import TaskSchema
+from .tasks import Task, TaskRecipient, TaskRecipientType
+
+
+def _ensure_string_value(value: Any) -> str:
+    """Convert any value to a string for use in field Value."""
+    if isinstance(value, str):
+        return value
+    return str(value) if value else ""
+
+
+def _create_spec(
+    data: Optional[Dict[str, Any]],
+    action_schema: Optional[TaskSchema],
+    title: str,
+    app_key: Optional[str] = None,
+    app_folder_key: Optional[str] = None,
+    app_folder_path: Optional[str] = None,
+    priority: Optional[str] = None,
+    labels: Optional[List[str]] = None,
+    is_actionable_message_enabled: Optional[bool] = None,
+    actionable_message_metadata: Optional[Dict[str, Any]] = None,
+    source_name: str = "Agent",
+) -> RequestSpec:
+    field_list = []
+    outcome_list = []
+    if action_schema:
+        if action_schema.inputs:
+            for input_field in action_schema.inputs:
+                field_name = input_field.name
+                field_value = data.get(field_name, "") if data is not None else ""
+                field_list.append(
+                    {
+                        "Id": input_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": _ensure_string_value(field_value),
+                    }
+                )
+        if action_schema.outputs:
+            for output_field in action_schema.outputs:
+                field_name = output_field.name
+                field_list.append(
+                    {
+                        "Id": output_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": "",
+                    }
+                )
+        if action_schema.in_outs:
+            for inout_field in action_schema.in_outs:
+                field_name = inout_field.name
+                field_value = data.get(field_name, "") if data is not None else ""
+                field_list.append(
+                    {
+                        "Id": inout_field.key,
+                        "Name": field_name,
+                        "Title": field_name,
+                        "Type": "Fact",
+                        "Value": _ensure_string_value(field_value),
+                    }
+                )
+        if action_schema.outcomes:
+            for outcome in action_schema.outcomes:
+                outcome_list.append(
+                    {
+                        "Id": action_schema.key,
+                        "Name": outcome.name,
+                        "Title": outcome.name,
+                        "Type": "Action.Http",
+                        "IsPrimary": True,
+                    }
+                )
+
+    json_payload: Dict[str, Any] = {
+        "appId": app_key,
+        "title": title,
+        "data": data if data is not None else {},
+        "actionableMessageMetaData": actionable_message_metadata
+        if actionable_message_metadata is not None
+        else (
+            {
+                "fieldSet": {
+                    "id": str(uuid.uuid4()),
+                    "fields": field_list,
+                }
+                if len(field_list) != 0
+                else {},
+                "actionSet": {
+                    "id": str(uuid.uuid4()),
+                    "actions": outcome_list,
+                }
+                if len(outcome_list) != 0
+                else {},
+            }
+            if action_schema is not None
+            else {}
+        ),
+    }
+
+    _apply_priority_labels_and_actionable_toggle(
+        json_payload, priority, labels, is_actionable_message_enabled
+    )
+    _apply_task_source(json_payload, source_name)
+
+    return RequestSpec(
+        method="POST",
+        endpoint=Endpoint("/orchestrator_/tasks/AppTasks/CreateAppTask"),
+        json=json_payload,
+        headers=header_folder(app_folder_key, app_folder_path),
+    )
+
+
+def _apply_priority_labels_and_actionable_toggle(
+    payload: Dict[str, Any],
+    priority: Optional[str],
+    labels: Optional[List[str]],
+    is_actionable_message_enabled: Optional[bool],
+) -> None:
+    """Apply priority / tags / isActionableMessageEnabled to ``payload`` in-place.
+
+    Shared between AppTask and QuickForm spec builders — they handle these three
+    optional fields identically.
+    """
+    if priority and (normalized_priority := _normalize_priority(priority)):
+        payload["priority"] = normalized_priority
+    if labels is not None:
+        payload["tags"] = [
+            {
+                "name": label,
+                "displayName": label,
+                "value": label,
+                "displayValue": label,
+            }
+            for label in labels
+        ]
+    if is_actionable_message_enabled is not None:
+        payload["isActionableMessageEnabled"] = is_actionable_message_enabled
+
+
+def _apply_task_source(payload: Dict[str, Any], source_name: str) -> None:
+    """Populate ``payload["taskSource"]`` when UiPathConfig has project_id + trace_id.
+
+    Shared between AppTask and QuickForm spec builders — the taskSource block is
+    identical for both task types.
+    """
+    project_id = UiPathConfig.project_id
+    trace_id = UiPathConfig.trace_id
+    if not (project_id and trace_id):
+        return
+    payload["taskSource"] = {
+        "sourceName": source_name,
+        "sourceId": project_id,
+        "taskSourceMetadata": {
+            "InstanceId": trace_id,
+            "FolderKey": UiPathConfig.folder_key,
+            "JobKey": UiPathConfig.job_key,
+            "ProcessKey": UiPathConfig.process_uuid,
+        },
+    }
+
+
+def _normalize_priority(priority: str | None) -> str | None:
+    """Normalize priority string to match API expectations.
+
+    Converts case-insensitive priority strings to the proper capitalized format
+    expected by the Orchestrator API.
+
+    Args:
+        priority: Priority string (case-insensitive: "low", "HIGH", "MeDiUm", etc.)
+
+    Returns:
+        Normalized priority string ("Low", "Medium", "High", "Critical") or None
+    """
+    if priority is None or not priority.strip():
+        return None
+
+    priority_map = {
+        "low": "Low",
+        "medium": "Medium",
+        "high": "High",
+        "critical": "Critical",
+    }
+
+    normalized = priority_map.get(priority.lower())
+    if normalized is None:
+        raise ValueError(
+            f"Invalid priority value: '{priority}'. "
+            f"Must be one of: Low, Medium, High, Critical (case-insensitive)"
+        )
+
+    return normalized
+
+
+_TASK_TYPE_QUICKFORM = 6
+
+
+def _create_quickform_spec(
+    data: Optional[Dict[str, Any]],
+    title: str,
+    task_schema_key: str,
+    schema: Dict[str, Any],
+    creator_job_key: Optional[str] = None,
+    folder_key: Optional[str] = None,
+    folder_path: Optional[str] = None,
+    priority: Optional[str] = None,
+    labels: Optional[List[str]] = None,
+    is_actionable_message_enabled: Optional[bool] = None,
+    actionable_message_metadata: Optional[Dict[str, Any]] = None,
+    source_name: str = "Agent",
+) -> RequestSpec:
+    """Build the RequestSpec for Orchestrator's GenericTasks/CreateTask endpoint.
+
+    Sets TaskType=QuickFormTask. Mirrors _create_spec but skips the AppTask-specific
+    shape (no appId, no action-schema-derived fieldSet/actionSet) and instead sends
+    taskSchemaKey + inline schema together.
+
+    Both taskSchemaKey AND schema are sent on every call: the Agents runtime has no
+    Action Center package.uploaded subscriber populating the TaskSchemas table, so
+    Orchestrator upserts the schema (keyed by taskSchemaKey) and then creates the task
+    in the same call.
+
+    Wire contract: UiPath/Orchestrator/src/Core/Application/Dto/Tasks/TaskCreateRequest.cs.
+    """
+    json_payload: Dict[str, Any] = {
+        "type": _TASK_TYPE_QUICKFORM,
+        "taskSchemaKey": task_schema_key,
+        "schema": schema,
+        "title": title,
+        "data": data if data is not None else {},
+    }
+
+    if creator_job_key is not None:
+        json_payload["creatorJobKey"] = creator_job_key
+
+    _apply_priority_labels_and_actionable_toggle(
+        json_payload, priority, labels, is_actionable_message_enabled
+    )
+    if actionable_message_metadata is not None:
+        json_payload["actionableMessageMetaData"] = actionable_message_metadata
+    _apply_task_source(json_payload, source_name)
+
+    return RequestSpec(
+        method="POST",
+        endpoint=Endpoint("/orchestrator_/tasks/GenericTasks/CreateTask"),
+        json=json_payload,
+        headers=header_folder(folder_key, folder_path),
+    )
+
+
+def _retrieve_action_spec(
+    action_key: str,
+    app_folder_key: Optional[str],
+    app_folder_path: Optional[str],
+) -> RequestSpec:
+    return RequestSpec(
+        method="GET",
+        endpoint=Endpoint("/orchestrator_/tasks/GenericTasks/GetTaskDataByKey"),
+        params={"taskKey": action_key},
+        headers=header_folder(app_folder_key, app_folder_path),
+    )
+
+
+async def _assign_task_spec(
+    self, task_key: str, assignee: str | None, task_recipient: TaskRecipient | None
+) -> RequestSpec:
+    request_spec = RequestSpec(
+        method="POST",
+        endpoint=Endpoint(
+            "/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks"
+        ),
+    )
+    if task_recipient:
+        recipient_value = await _resolve_recipient(self, task_recipient)
+        if (
+            task_recipient.type == TaskRecipientType.USER_ID
+            or task_recipient.type == TaskRecipientType.EMAIL
+        ):
+            request_spec.json = {
+                "taskAssignments": [
+                    {
+                        "taskId": task_key,
+                        "assignmentCriteria": "SingleUser",
+                        "userNameOrEmail": recipient_value,
+                    }
+                ]
+            }
+        elif task_recipient.type == TaskRecipientType.WORKLOAD:
+            # This branch covers BOTH agent-side Workload criteria (single
+            # group, distributed by workload) AND agent-side CustomAssignees
+            # criteria (explicit email list — already resolved into
+            # `task_recipient.values` upstream). Both submit to the Action
+            # Center API as a "Workload" assignment; the difference is whether
+            # `values` carries one group or N emails.
+            request_spec.json = {
+                "taskAssignments": [
+                    {
+                        "taskId": task_key,
+                        "assignmentCriteria": "Workload",
+                        "assigneeNamesOrEmails": task_recipient.values
+                        or [recipient_value],
+                    }
+                ]
+            }
+        elif task_recipient.type == TaskRecipientType.ROUND_ROBIN:
+            request_spec.json = {
+                "taskAssignments": [
+                    {
+                        "taskId": task_key,
+                        "assignmentCriteria": "RoundRobin",
+                        "assigneeNamesOrEmails": task_recipient.values
+                        or [recipient_value],
+                    }
+                ]
+            }
+        else:
+            request_spec.json = {
+                "taskAssignments": [
+                    {
+                        "taskId": task_key,
+                        "assignmentCriteria": "AllUsers",
+                        "assigneeNamesOrEmails": [recipient_value],
+                    }
+                ]
+            }
+    elif assignee:
+        request_spec.json = {
+            "taskAssignments": [{"taskId": task_key, "UserNameOrEmail": assignee}]
+        }
+    return request_spec
+
+
+async def _resolve_recipient(self, task_recipient: TaskRecipient) -> str:
+    recipient_value = task_recipient.value
+
+    if task_recipient.type == TaskRecipientType.USER_ID:
+        spec = _resolve_user(task_recipient.value)
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+            scoped="org",
+        )
+        recipient_value = response.json().get("email")
+        task_recipient.display_name = recipient_value
+
+    if task_recipient.type == TaskRecipientType.GROUP_ID:
+        spec = _resolve_group(task_recipient.value)
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+            scoped="org",
+        )
+        recipient_value = response.json().get("displayName")
+        task_recipient.display_name = recipient_value
+
+    return recipient_value
+
+
+def _resolve_user(entity_id: str) -> RequestSpec:
+    org_id = UiPathConfig.organization_id
+    return RequestSpec(
+        method="POST",
+        endpoint=Endpoint(
+            "/identity_/api/Directory/Resolve/{org_id}".format(org_id=org_id)
+        ),
+        json={"entityId": entity_id, "entityType": "User"},
+    )
+
+
+def _resolve_group(entity_id: str) -> RequestSpec:
+    org_id = UiPathConfig.organization_id
+    return RequestSpec(
+        method="GET",
+        endpoint=Endpoint(
+            "/identity_/api/Group/{org_id}/{entity_id}".format(
+                org_id=org_id, entity_id=entity_id
+            )
+        ),
+    )
+
+
+def _retrieve_app_key_spec(app_name: str) -> RequestSpec:
+    tenant_id = os.getenv(ENV_TENANT_ID, None)
+    if not tenant_id:
+        raise Exception(f"{ENV_TENANT_ID} env var is not set")
+    return RequestSpec(
+        method="GET",
+        endpoint=Endpoint("/apps_/default/api/v1/default/deployed-action-apps-schemas"),
+        params={"search": app_name, "filterByDeploymentTitle": "true"},
+        headers={HEADER_TENANT_ID: tenant_id},
+    )
+
+
+class TasksService(FolderContext, BaseService):
+    """Service for managing UiPath Action Center tasks.
+
+    Tasks are task-based automation components that can be integrated into
+    applications and processes. They represent discrete units of work that can
+    be triggered and monitored through the UiPath API.
+
+    This service provides methods to create and retrieve tasks, supporting
+    both app-specific and generic tasks. It inherits folder context management
+    capabilities from FolderContext.
+
+    Reference: https://docs.uipath.com/automation-cloud/docs/actions
+    """
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @resource_override(
+        resource_type="app",
+        resource_identifier="app_name",
+        folder_identifier="app_folder_path",
+    )
+    @traced(name="tasks_create", run_type="uipath")
+    async def create_async(
+        self,
+        title: str,
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        app_name: Optional[str] = None,
+        app_key: Optional[str] = None,
+        app_folder_path: Optional[str] = None,
+        app_folder_key: Optional[str] = None,
+        assignee: Optional[str] = None,
+        recipient: Optional[TaskRecipient] = None,
+        priority: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        is_actionable_message_enabled: Optional[bool] = None,
+        actionable_message_metadata: Optional[Dict[str, Any]] = None,
+        source_name: str = "Agent",
+    ) -> Task:
+        """Creates a new action asynchronously.
+
+        This method creates a new action task in UiPath Orchestrator. The action can be
+        either app-specific (using app_name or app_key) or a generic action.
+
+        Args:
+            title: The title of the action
+            data: Optional dictionary containing input data for the action
+            app_name: The name of the application (if creating an app-specific action)
+            app_key: The key of the application (if creating an app-specific action)
+            app_folder_path: Optional folder path for the action
+            app_folder_key: Optional folder key for the action
+            assignee: Optional username or email to assign the task to
+            priority: Optional priority of the task
+            labels: Optional list of labels for the task
+            is_actionable_message_enabled: Optional boolean indicating whether actionable notifications are enabled for this task
+            actionable_message_metadata: Optional metadata for the action
+            source_name: The name of the source that created the task. Defaults to 'Agent'.
+
+        Returns:
+            Action: The created action object
+
+        Raises:
+            Exception: If neither app_name nor app_key is provided for app-specific actions
+        """
+        (key, action_schema) = (
+            (app_key, None)
+            if app_key
+            else await self._get_app_key_and_schema_async(
+                app_name, app_folder_path, app_folder_key
+            )
+        )
+        spec = _create_spec(
+            title=title,
+            data=data,
+            app_key=key,
+            action_schema=action_schema,
+            app_folder_key=app_folder_key,
+            app_folder_path=app_folder_path,
+            priority=priority,
+            labels=labels,
+            is_actionable_message_enabled=is_actionable_message_enabled,
+            actionable_message_metadata=actionable_message_metadata,
+            source_name=source_name,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        json_response = response.json()
+        if assignee or recipient:
+            spec = await _assign_task_spec(
+                self, json_response["id"], assignee, recipient
+            )
+            await self.request_async(
+                spec.method, spec.endpoint, json=spec.json, content=spec.content
+            )
+        return Task.model_validate(json_response)
+
+    @resource_override(
+        resource_type="app",
+        resource_identifier="app_name",
+        folder_identifier="app_folder_path",
+    )
+    @traced(name="tasks_create", run_type="uipath")
+    def create(
+        self,
+        title: str,
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        app_name: Optional[str] = None,
+        app_key: Optional[str] = None,
+        app_folder_path: Optional[str] = None,
+        app_folder_key: Optional[str] = None,
+        assignee: Optional[str] = None,
+        recipient: Optional[TaskRecipient] = None,
+        priority: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        is_actionable_message_enabled: Optional[bool] = None,
+        actionable_message_metadata: Optional[Dict[str, Any]] = None,
+        source_name: str = "Agent",
+    ) -> Task:
+        """Creates a new task synchronously.
+
+        This method creates a new action task in UiPath Orchestrator. The action can be
+        either app-specific (using app_name or app_key) or a generic action.
+
+        Args:
+            title: The title of the action
+            data: Optional dictionary containing input data for the action
+            app_name: The name of the application (if creating an app-specific action)
+            app_key: The key of the application (if creating an app-specific action)
+            app_folder_path: Optional folder path for the action
+            app_folder_key: Optional folder key for the action
+            assignee: Optional username or email to assign the task to
+            priority: Optional priority of the task
+            labels: Optional list of labels for the task
+            is_actionable_message_enabled: Optional boolean indicating  whether actionable notifications are enabled for this task
+            actionable_message_metadata: Optional metadata for the action
+            source_name: The name of the source that created the task. Defaults to 'Agent'.
+
+        Returns:
+            Action: The created action object
+
+        Raises:
+            Exception: If neither app_name nor app_key is provided for app-specific actions
+        """
+        (key, action_schema) = (
+            (app_key, None)
+            if app_key
+            else self._get_app_key_and_schema(app_name, app_folder_path, app_folder_key)
+        )
+        spec = _create_spec(
+            title=title,
+            data=data,
+            app_key=key,
+            action_schema=action_schema,
+            app_folder_key=app_folder_key,
+            app_folder_path=app_folder_path,
+            priority=priority,
+            labels=labels,
+            is_actionable_message_enabled=is_actionable_message_enabled,
+            actionable_message_metadata=actionable_message_metadata,
+            source_name=source_name,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        json_response = response.json()
+        if assignee or recipient:
+            spec = asyncio.run(
+                _assign_task_spec(self, json_response["id"], assignee, recipient)
+            )
+            self.request(
+                spec.method, spec.endpoint, json=spec.json, content=spec.content
+            )
+        return Task.model_validate(json_response)
+
+    @traced(name="tasks_create_quickform", run_type="uipath")
+    async def create_quickform_async(
+        self,
+        title: str,
+        task_schema_key: str,
+        schema: Dict[str, Any],
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        assignee: Optional[str] = None,
+        recipient: Optional[TaskRecipient] = None,
+        priority: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        is_actionable_message_enabled: Optional[bool] = None,
+        actionable_message_metadata: Optional[Dict[str, Any]] = None,
+        creator_job_key: Optional[str] = None,
+        source_name: str = "Agent",
+    ) -> Task:
+        """Creates a new QuickForm task asynchronously.
+
+        QuickForm tasks are schema-first HITL tasks rendered by FormLib in Action
+        Center. Both task_schema_key AND schema are required: the Agents runtime
+        does not pre-populate TaskSchemas via a package.uploaded subscriber, so
+        Orchestrator upserts the schema (keyed by task_schema_key) and creates
+        the task in the same call.
+
+        Args:
+            title: The title of the task.
+            task_schema_key: UUID key of the schema. Used as the key under which
+                Orchestrator stores/looks up the schema in TaskSchemas.
+            schema: The HITL schema body to register/upsert. Sent inline on every
+                call.
+            data: Optional dictionary containing input data for the task.
+            folder_path: Optional folder path for the task. Required by the
+                Orchestrator controller (RequireOrganizationUnit) unless
+                folder_key is provided.
+            folder_key: Optional folder key, alternative to folder_path.
+            assignee: Optional username or email to assign the task to.
+            recipient: Optional structured recipient (user id / group id /
+                email). Resolved via identity service before assignment.
+            priority: Optional priority. Low / Medium / High / Critical.
+            labels: Optional list of labels for the task.
+            is_actionable_message_enabled: Whether actionable notifications are
+                enabled for this task.
+            actionable_message_metadata: Optional metadata override. For
+                QuickForm, when null, Orchestrator derives it from the
+                referenced TaskSchema.
+            creator_job_key: Optional. Identifies the job that triggered the
+                inline schema creation/upsert.
+            source_name: Source name on TaskSource. Defaults to 'Agent'.
+
+        Returns:
+            Task: The created task object.
+        """
+        spec = _create_quickform_spec(
+            title=title,
+            data=data,
+            task_schema_key=task_schema_key,
+            schema=schema,
+            creator_job_key=creator_job_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            priority=priority,
+            labels=labels,
+            is_actionable_message_enabled=is_actionable_message_enabled,
+            actionable_message_metadata=actionable_message_metadata,
+            source_name=source_name,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        json_response = response.json()
+        if assignee or recipient:
+            assign_spec = await _assign_task_spec(
+                self, json_response["id"], assignee, recipient
+            )
+            await self.request_async(
+                assign_spec.method,
+                assign_spec.endpoint,
+                json=assign_spec.json,
+                content=assign_spec.content,
+            )
+        return Task.model_validate(json_response)
+
+    @traced(name="tasks_create_quickform", run_type="uipath")
+    def create_quickform(
+        self,
+        title: str,
+        task_schema_key: str,
+        schema: Dict[str, Any],
+        data: Optional[Dict[str, Any]] = None,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        assignee: Optional[str] = None,
+        recipient: Optional[TaskRecipient] = None,
+        priority: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        is_actionable_message_enabled: Optional[bool] = None,
+        actionable_message_metadata: Optional[Dict[str, Any]] = None,
+        creator_job_key: Optional[str] = None,
+        source_name: str = "Agent",
+    ) -> Task:
+        """Create a new QuickForm task synchronously.
+
+        See :meth:`create_quickform_async` for parameter docs.
+        """
+        spec = _create_quickform_spec(
+            title=title,
+            data=data,
+            task_schema_key=task_schema_key,
+            schema=schema,
+            creator_job_key=creator_job_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            priority=priority,
+            labels=labels,
+            is_actionable_message_enabled=is_actionable_message_enabled,
+            actionable_message_metadata=actionable_message_metadata,
+            source_name=source_name,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        json_response = response.json()
+        if assignee or recipient:
+            assign_spec = asyncio.run(
+                _assign_task_spec(self, json_response["id"], assignee, recipient)
+            )
+            self.request(
+                assign_spec.method,
+                assign_spec.endpoint,
+                json=assign_spec.json,
+                content=assign_spec.content,
+            )
+        return Task.model_validate(json_response)
+
+    @resource_override(
+        resource_type="app",
+        resource_identifier="app_name",
+        folder_identifier="app_folder_path",
+    )
+    @traced(name="tasks_retrieve", run_type="uipath")
+    def retrieve(
+        self,
+        action_key: str,
+        app_folder_path: Optional[str] = None,
+        app_folder_key: Optional[str] = None,
+        app_name: str | None = None,
+    ) -> Task:
+        """Retrieves a task by its key synchronously.
+
+        Args:
+            action_key: The unique identifier of the task to retrieve
+            app_folder_path: Optional folder path for the task
+            app_folder_key: Optional folder key for the task
+            app_name: app name hint for resource override
+        Returns:
+            Task: The retrieved task object
+        """
+        spec = _retrieve_action_spec(
+            action_key=action_key,
+            app_folder_key=app_folder_key,
+            app_folder_path=app_folder_path,
+        )
+        response = self.request(
+            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return Task.model_validate(response.json())
+
+    @resource_override(
+        resource_type="app",
+        resource_identifier="app_name",
+        folder_identifier="app_folder_path",
+    )
+    @traced(name="tasks_retrieve", run_type="uipath")
+    async def retrieve_async(
+        self,
+        action_key: str,
+        app_folder_path: Optional[str] = None,
+        app_folder_key: Optional[str] = None,
+        app_name: str | None = None,
+    ) -> Task:
+        """Retrieves a task by its key asynchronously.
+
+        Args:
+            action_key: The unique identifier of the task to retrieve
+            app_folder_path: Optional folder path for the task
+            app_folder_key: Optional folder key for the task
+            app_name: app name hint for resource override
+        Returns:
+            Task: The retrieved task object
+        """
+        spec = _retrieve_action_spec(
+            action_key=action_key,
+            app_folder_key=app_folder_key,
+            app_folder_path=app_folder_path,
+        )
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return Task.model_validate(response.json())
+
+    async def _get_app_key_and_schema_async(
+        self,
+        app_name: str | None,
+        app_folder_path: str | None,
+        app_folder_key: str | None,
+    ) -> tuple[str, TaskSchema | None]:
+        if not app_name:
+            raise Exception("appName or appKey is required")
+        spec = _retrieve_app_key_spec(app_name=app_name)
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org",
+        )
+        try:
+            deployed_app = self._extract_deployed_app(
+                response.json()["deployed"], app_name, app_folder_path, app_folder_key
+            )
+            action_schema = deployed_app["actionSchema"]
+            deployed_app_key = deployed_app["systemName"]
+        except (KeyError, IndexError):
+            raise Exception("Action app not found") from None
+        try:
+            return (
+                deployed_app_key,
+                TaskSchema(
+                    key=action_schema["key"],
+                    in_outs=action_schema["inOuts"],
+                    inputs=action_schema["inputs"],
+                    outputs=action_schema["outputs"],
+                    outcomes=action_schema["outcomes"],
+                ),
+            )
+        except KeyError:
+            raise Exception("Failed to deserialize action schema") from KeyError
+
+    def _get_app_key_and_schema(
+        self,
+        app_name: str | None,
+        app_folder_path: str | None,
+        app_folder_key: str | None,
+    ) -> tuple[str, TaskSchema | None]:
+        if not app_name:
+            raise Exception("appName or appKey is required")
+
+        spec = _retrieve_app_key_spec(app_name=app_name)
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org",
+        )
+
+        try:
+            deployed_app = self._extract_deployed_app(
+                response.json()["deployed"], app_name, app_folder_path, app_folder_key
+            )
+            action_schema = deployed_app["actionSchema"]
+            deployed_app_key = deployed_app["systemName"]
+        except (KeyError, IndexError):
+            raise Exception("Action app not found") from None
+        try:
+            return (
+                deployed_app_key,
+                TaskSchema(
+                    key=action_schema["key"],
+                    in_outs=action_schema["inOuts"],
+                    inputs=action_schema["inputs"],
+                    outputs=action_schema["outputs"],
+                    outcomes=action_schema["outcomes"],
+                ),
+            )
+        except KeyError:
+            raise Exception("Failed to deserialize action schema") from KeyError
+
+    def _extract_deployed_app(
+        self,
+        deployed_apps: list[dict[str, Any]],
+        app_name: str,
+        app_folder_path: str | None,
+        app_folder_key: str | None,
+    ) -> dict[str, Any]:
+        # try extracting the requested app schema. folder path has priority over folder key
+        filtered_apps_by_name = [
+            app for app in deployed_apps if app["deploymentTitle"] == app_name
+        ]
+        if len(filtered_apps_by_name) < 1:
+            raise Exception(f"App '{app_name}' was not found in the current tenant")
+
+        # priority: app_folder_path -> app_folder_key -> self._folder_path -> self._folder_key
+        candidates = [
+            (app_folder_path, "fullyQualifiedName", "fully qualified name"),
+            (app_folder_key, "key", "identifier"),
+            (self._folder_path, "fullyQualifiedName", "fully qualified name"),
+            (self._folder_key, "key", "identifier"),
+        ]
+
+        for value, field, label in candidates:
+            if not value:
+                continue
+            try:
+                return next(
+                    app
+                    for app in filtered_apps_by_name
+                    if app["deploymentFolder"][field] == value
+                )
+            except StopIteration:
+                raise Exception(
+                    f"App '{app_name}' was not found in folder with {label} '{value}'"
+                ) from StopIteration
+
+        raise Exception(
+            f"App '{app_name}' was found but no folder key or folder path was provided to select a deployment"
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
diff --git a/src/uipath/models/action_schema.py b/packages/uipath-platform/src/uipath/platform/action_center/task_schema.py
similarity index 69%
rename from src/uipath/models/action_schema.py
rename to packages/uipath-platform/src/uipath/platform/action_center/task_schema.py
index 7489c9b42..2fb707549 100644
--- a/src/uipath/models/action_schema.py
+++ b/packages/uipath-platform/src/uipath/platform/action_center/task_schema.py
@@ -1,22 +1,26 @@
-from datetime import datetime
+"""Module defining the ActionSchema model for UiPath platform actions."""
+
 from typing import List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 
 class FieldDetails(BaseModel):
+    """Model representing details of a field in an action schema."""
+
     name: str
     key: str
 
 
-class ActionSchema(BaseModel):
+class TaskSchema(BaseModel):
+    """Model representing the schema of an action in the UiPath platform."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
     key: str
diff --git a/src/uipath/models/actions.py b/packages/uipath-platform/src/uipath/platform/action_center/tasks.py
similarity index 56%
rename from src/uipath/models/actions.py
rename to packages/uipath-platform/src/uipath/platform/action_center/tasks.py
index abb0ec30c..f1a932cb8 100644
--- a/src/uipath/models/actions.py
+++ b/packages/uipath-platform/src/uipath/platform/action_center/tasks.py
@@ -1,24 +1,83 @@
+"""Data model for an Action in the UiPath Platform."""
+
+import enum
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+
+class TaskStatus(enum.IntEnum):
+    """Enum representing possible Task status."""
+
+    UNASSIGNED = 0
+    PENDING = 1
+    COMPLETED = 2
+
+
+class TaskRecipientType(str, enum.Enum):
+    """Task recipient type enumeration."""
 
-from pydantic import BaseModel, ConfigDict, Field
+    USER_ID = "UserId"
+    GROUP_ID = "GroupId"
+    EMAIL = "UserEmail"
+    GROUP_NAME = "GroupName"
+    WORKLOAD = "Workload"
+    ROUND_ROBIN = "RoundRobin"
 
 
-class Action(BaseModel):
+class TaskRecipient(BaseModel):
+    """Model representing a task recipient.
+
+    `value` is the single identifier (group name, group id, user id, email, …).
+    `values` is the multi-assignee form used by Workload-with-custom-emails
+    assignments; when set it takes precedence over `value` for the
+    `assigneeNamesOrEmails` payload.
+
+    Note: there is no CustomAssignees member here on purpose. The agent-side
+    CustomAssignees criteria (AgentEscalationRecipientType.CUSTOM_ASSIGNEES,
+    type 11) is resolved to a Workload assignment with the explicit email list
+    in `values` before reaching this layer, so the Action Center
+    AssignTasks API only ever sees the existing literal types.
+    """
+
+    type: Literal[
+        TaskRecipientType.USER_ID,
+        TaskRecipientType.GROUP_ID,
+        TaskRecipientType.EMAIL,
+        TaskRecipientType.GROUP_NAME,
+        TaskRecipientType.WORKLOAD,
+        TaskRecipientType.ROUND_ROBIN,
+    ] = Field(..., alias="type")
+    value: str = Field(..., alias="value")
+    values: Optional[List[str]] = Field(default=None, alias="values")
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+
+
+class Task(BaseModel):
+    """Model representing a Task in the UiPath Platform."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
+    @field_serializer("*", when_used="json")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format for JSON output."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
     task_definition_properties_id: Optional[int] = Field(
         default=None, alias="taskDefinitionPropertiesId"
     )
     app_tasks_metadata: Optional[Any] = Field(default=None, alias="appTasksMetadata")
     action_label: Optional[str] = Field(default=None, alias="actionLabel")
+    # 2.3.0 change to TaskStatus enum
     status: Optional[Union[str, int]] = None
     data: Optional[Dict[str, Any]] = None
     action: Optional[str] = None
diff --git a/packages/uipath-platform/src/uipath/platform/agenthub/__init__.py b/packages/uipath-platform/src/uipath/platform/agenthub/__init__.py
new file mode 100644
index 000000000..426bec295
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/agenthub/__init__.py
@@ -0,0 +1,10 @@
+"""UiPath AgentHub Models and Services.
+
+This module contains models and services related to UiPath AgentHub.
+"""
+
+from uipath.platform.agenthub._remote_a2a_service import RemoteA2aService
+from uipath.platform.agenthub.agenthub import LlmModel
+from uipath.platform.agenthub.remote_a2a import RemoteA2aAgent, RemoteA2aAgentFolder
+
+__all__ = ["LlmModel", "RemoteA2aAgent", "RemoteA2aAgentFolder", "RemoteA2aService"]
diff --git a/packages/uipath-platform/src/uipath/platform/agenthub/_agenthub_service.py b/packages/uipath-platform/src/uipath/platform/agenthub/_agenthub_service.py
new file mode 100644
index 000000000..4119a433f
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/agenthub/_agenthub_service.py
@@ -0,0 +1,205 @@
+from typing import Any
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator import FolderService
+from .agenthub import LlmModel
+
+
+class AgentHubService(FolderContext, BaseService):
+    """Service class for interacting with AgentHub platform service."""
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folder_service: FolderService,
+    ) -> None:
+        self._folder_service = folder_service
+        super().__init__(config=config, execution_context=execution_context)
+
+    def get_available_llm_models(
+        self, headers: dict[str, Any] | None = None
+    ) -> list[LlmModel]:
+        """Fetch available models from LLM Gateway discovery endpoint.
+
+        Returns:
+           List of available models and their configurations.
+        """
+        spec = self._available_models_spec(headers=headers)
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return [
+            LlmModel.model_validate(available_model)
+            for available_model in response.json()
+        ]
+
+    async def get_available_llm_models_async(
+        self, headers: dict[str, Any] | None = None
+    ) -> list[LlmModel]:
+        """Asynchronously fetch available models from LLM Gateway discovery endpoint.
+
+        Returns:
+           List of available models and their configurations.
+        """
+        spec = self._available_models_spec(headers=headers)
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return [
+            LlmModel.model_validate(available_model)
+            for available_model in response.json()
+        ]
+
+    def invoke_system_agent(
+        self,
+        *,
+        agent_name: str,
+        entrypoint: str,
+        input_arguments: dict[str, Any] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+        headers: dict[str, Any] | None = None,
+    ) -> str:
+        """Start a system agent job.
+
+        Args:
+            agent_name: The name of the system agent to invoke.
+            entrypoint: The entry point to execute.
+            input_arguments: Optional input arguments to pass to the agent.
+            folder_key: Optional folder key to override the default folder context.
+            folder_path: Optional folder path to override the default folder context.
+
+        Returns:
+            str: The started job's key.
+        """
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        spec = self._start_spec(
+            agent_name=agent_name,
+            entrypoint=entrypoint,
+            input_arguments=input_arguments,
+            folder_key=folder_key,
+            headers=headers,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        response_data = response.json()
+
+        return response_data["key"]
+
+    async def invoke_system_agent_async(
+        self,
+        *,
+        agent_name: str,
+        entrypoint: str,
+        input_arguments: dict[str, Any] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+        headers: dict[str, Any] | None = None,
+    ) -> str:
+        """Asynchronously start a system agent and return the job.
+
+        Args:
+            agent_name: The name of the system agent to invoke.
+            entrypoint: The entry point to execute.
+            input_arguments: Optional input arguments to pass to the agent.
+            folder_key: Optional folder key to override the default folder context.
+            folder_path: Optional folder path to override the default folder context.
+
+        Returns:
+            str: The started job's key.
+
+        """
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        spec = self._start_spec(
+            agent_name=agent_name,
+            entrypoint=entrypoint,
+            input_arguments=input_arguments,
+            folder_key=folder_key,
+            headers=headers,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        response_data = response.json()
+
+        return response_data["key"]
+
+    def _start_spec(
+        self,
+        agent_name: str,
+        entrypoint: str,
+        input_arguments: dict[str, Any] | None,
+        folder_key: str,
+        headers: dict[str, Any] | None,
+    ) -> RequestSpec:
+        """Build the request specification for starting a system agent.
+
+        Args:
+            agent_name: The name of the system agent.
+            entrypoint: The entry point to execute.
+            input_arguments: Input arguments for the agent.
+            folder_key: Folder key for scoping.
+
+        Returns:
+            RequestSpec: The request specification with endpoint, method, headers, and body.
+        """
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"agenthub_/api/systemagents/{agent_name}/start"),
+            headers=header_folder(folder_key, None) | (headers or {}),
+            json={
+                "EntryPoint": entrypoint,
+                "InputArguments": input_arguments or {},
+            },
+        )
+
+    def _resolve_folder_key(
+        self, folder_key: str | None, folder_path: str | None
+    ) -> str:
+        if folder_key is None and folder_path is not None:
+            folder_key = self._folder_service.retrieve_key(folder_path=folder_path)
+
+        if folder_key is None and folder_path is None:
+            folder_key = self._folder_key or (
+                self._folder_service.retrieve_key(folder_path=self._folder_path)
+                if self._folder_path
+                else None
+            )
+
+        if folder_key is None:
+            raise ValueError("AgentHubClient: Failed to resolve folder key")
+
+        return folder_key
+
+    def _available_models_spec(self, headers: dict[str, Any] | None) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/agenthub_/llm/api/discovery"),
+            headers=headers or {},
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/agenthub/_remote_a2a_service.py b/packages/uipath-platform/src/uipath/platform/agenthub/_remote_a2a_service.py
new file mode 100644
index 000000000..c8993e3ee
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/agenthub/_remote_a2a_service.py
@@ -0,0 +1,293 @@
+"""Service for managing Remote A2A agents in UiPath AgentHub.
+
+.. warning::
+    This module is experimental and subject to change.
+    The Remote A2A feature is in preview and its API may change in future releases.
+"""
+
+import warnings
+from typing import Any, List
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator import FolderService
+from .remote_a2a import RemoteA2aAgent
+
+
+class RemoteA2aService(FolderContext, BaseService):
+    """Service for managing Remote A2A agents in UiPath AgentHub.
+
+    .. warning::
+        This service is experimental and subject to change.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: FolderService,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    def list(
+        self,
+        *,
+        top: int | None = None,
+        skip: int | None = None,
+        search: str | None = None,
+        folder_path: str | None = None,
+    ) -> List[RemoteA2aAgent]:
+        """List Remote A2A agents.
+
+        .. warning::
+            This method is experimental and subject to change.
+
+        When called without folder_path, returns all agents across
+        the tenant that the user has access to. When called with a folder,
+        returns only agents in that folder.
+
+        Args:
+            top: Maximum number of agents to return.
+            skip: Number of agents to skip (for pagination).
+            search: Filter agents by name or slug.
+            folder_path: Optional folder path to scope the query.
+
+        Returns:
+            List[RemoteA2aAgent]: A list of Remote A2A agents.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            # List all agents across tenant
+            agents = client.remote_a2a.list()
+            for agent in agents:
+                print(f"{agent.name} - {agent.slug}")
+
+            # List with folder scope
+            agents = client.remote_a2a.list(folder_path="MyFolder")
+            ```
+        """
+        warnings.warn(
+            "remote_a2a.list is experimental and subject to change.",
+            stacklevel=2,
+        )
+        spec = self._list_spec(
+            top=top,
+            skip=skip,
+            search=search,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        data = response.json()
+        return [RemoteA2aAgent.model_validate(agent) for agent in data.get("value", [])]
+
+    async def list_async(
+        self,
+        *,
+        top: int | None = None,
+        skip: int | None = None,
+        search: str | None = None,
+        folder_path: str | None = None,
+    ) -> List[RemoteA2aAgent]:
+        """Asynchronously list Remote A2A agents.
+
+        .. warning::
+            This method is experimental and subject to change.
+
+        Args:
+            top: Maximum number of agents to return.
+            skip: Number of agents to skip (for pagination).
+            search: Filter agents by name or slug.
+            folder_path: Optional folder path to scope the query.
+
+        Returns:
+            List[RemoteA2aAgent]: A list of Remote A2A agents.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                agents = await sdk.remote_a2a.list_async()
+                for agent in agents:
+                    print(f"{agent.name} - {agent.slug}")
+
+            asyncio.run(main())
+            ```
+        """
+        warnings.warn(
+            "remote_a2a.list_async is experimental and subject to change.",
+            stacklevel=2,
+        )
+        spec = self._list_spec(
+            top=top,
+            skip=skip,
+            search=search,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        data = response.json()
+        return [RemoteA2aAgent.model_validate(agent) for agent in data.get("value", [])]
+
+    @resource_override(resource_type="remoteA2aAgent", resource_identifier="slug")
+    def retrieve(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None = None,
+    ) -> RemoteA2aAgent:
+        """Retrieve a specific Remote A2A agent by slug.
+
+        .. warning::
+            This method is experimental and subject to change.
+
+        Args:
+            slug: The unique slug identifier for the agent.
+            folder_path: The folder path where the agent is located.
+
+        Returns:
+            RemoteA2aAgent: The Remote A2A agent.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            agent = client.remote_a2a.retrieve("weather", folder_path="MyFolder")
+            print(f"Agent: {agent.name}, URL: {agent.a2a_url}")
+            ```
+        """
+        warnings.warn(
+            "remote_a2a.retrieve is experimental and subject to change.",
+            stacklevel=2,
+        )
+        spec = self._retrieve_spec(slug=slug, folder_path=folder_path)
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return RemoteA2aAgent.model_validate(response.json())
+
+    @resource_override(resource_type="remoteA2aAgent", resource_identifier="slug")
+    async def retrieve_async(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None = None,
+    ) -> RemoteA2aAgent:
+        """Asynchronously retrieve a specific Remote A2A agent by slug.
+
+        .. warning::
+            This method is experimental and subject to change.
+
+        Args:
+            slug: The unique slug identifier for the agent.
+            folder_path: The folder path where the agent is located.
+
+        Returns:
+            RemoteA2aAgent: The Remote A2A agent.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                agent = await sdk.remote_a2a.retrieve_async("weather", folder_path="MyFolder")
+                print(f"Agent: {agent.name}, URL: {agent.a2a_url}")
+
+            asyncio.run(main())
+            ```
+        """
+        warnings.warn(
+            "remote_a2a.retrieve_async is experimental and subject to change.",
+            stacklevel=2,
+        )
+        spec = self._retrieve_spec(slug=slug, folder_path=folder_path)
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return RemoteA2aAgent.model_validate(response.json())
+
+    @property
+    def custom_headers(self) -> dict[str, str]:
+        return self.folder_headers
+
+    def _resolve_folder_key(self, folder_path: str | None) -> str | None:
+        """Resolve folder key from folder_path, falling back to FolderContext."""
+        if folder_path is not None:
+            return self._folders_service.retrieve_folder_key(folder_path)
+
+        return self._folder_key
+
+    def _list_spec(
+        self,
+        *,
+        top: int | None,
+        skip: int | None,
+        search: str | None,
+        folder_path: str | None,
+    ) -> RequestSpec:
+        headers = {}
+        if folder_path is not None:
+            folder_key = self._folders_service.retrieve_folder_key(folder_path)
+            headers = header_folder(folder_key, None)
+
+        params: dict[str, Any] = {}
+        if top is not None:
+            params["top"] = top
+        if skip is not None:
+            params["skip"] = skip
+        if search is not None:
+            params["search"] = search
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/agenthub_/api/remote-a2a-agents"),
+            params=params,
+            headers=headers,
+        )
+
+    def _retrieve_spec(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_path)
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/agenthub_/api/remote-a2a-agents/{slug}"),
+            headers={
+                **header_folder(folder_key, None),
+            },
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/agenthub/agenthub.py b/packages/uipath-platform/src/uipath/platform/agenthub/agenthub.py
new file mode 100644
index 000000000..6ccfea047
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/agenthub/agenthub.py
@@ -0,0 +1,18 @@
+"""AgentHub response payload models."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class LlmModel(BaseModel):
+    """Model representing an available LLM model."""
+
+    model_name: str = Field(..., alias="modelName")
+    vendor: str | None = Field(default=None)
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/agenthub/remote_a2a.py b/packages/uipath-platform/src/uipath/platform/agenthub/remote_a2a.py
new file mode 100644
index 000000000..c81a7f4b2
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/agenthub/remote_a2a.py
@@ -0,0 +1,59 @@
+"""Models for Remote A2A Agents in UiPath AgentHub.
+
+.. warning::
+    This module is experimental and subject to change.
+    The Remote A2A feature is in preview and its API may change in future releases.
+"""
+
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+
+class RemoteA2aAgentFolder(BaseModel):
+    """Folder information for a Remote A2A agent."""
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    key: Optional[str] = None
+    display_name: Optional[str] = None
+    fully_qualified_name: Optional[str] = None
+
+
+class RemoteA2aAgent(BaseModel):
+    """Model representing a Remote A2A agent in UiPath AgentHub.
+
+    .. warning::
+        This model is experimental and subject to change.
+    """
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    slug: Optional[str] = None
+    description: Optional[str] = None
+    agent_card_url: Optional[str] = None
+    a2a_url: Optional[str] = Field(None, alias="a2aUrl")
+    folder: Optional[RemoteA2aAgentFolder] = None
+    headers: Optional[str] = None
+    is_active: Optional[bool] = None
+    cached_agent_card: Optional[Any] = None
+    created_at: Optional[datetime] = None
+    created_by: Optional[str] = None
+    updated_at: Optional[datetime] = None
+    updated_by: Optional[str] = None
diff --git a/packages/uipath-platform/src/uipath/platform/attachments/__init__.py b/packages/uipath-platform/src/uipath/platform/attachments/__init__.py
new file mode 100644
index 000000000..302de848b
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/attachments/__init__.py
@@ -0,0 +1,12 @@
+"""UiPath Attachment Models.
+
+This module contains models related to UiPath Attachments service.
+"""
+
+from .attachments import Attachment, AttachmentMode, BlobFileAccessInfo
+
+__all__ = [
+    "Attachment",
+    "AttachmentMode",
+    "BlobFileAccessInfo",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/attachments/attachments.py b/packages/uipath-platform/src/uipath/platform/attachments/attachments.py
new file mode 100644
index 000000000..e91c7eff4
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/attachments/attachments.py
@@ -0,0 +1,44 @@
+"""Module defining the attachment model for attachments."""
+
+import uuid
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class AttachmentMode(str, Enum):
+    """Mode of attachment open."""
+
+    READ = "read"
+    WRITE = "write"
+
+
+class Attachment(BaseModel):
+    """Model representing an attachment. Id 'None' is used for uploads."""
+
+    id: uuid.UUID = Field(..., alias="ID")
+    full_name: str = Field(..., alias="FullName")
+    mime_type: str = Field(..., alias="MimeType")
+    metadata: Optional[dict[str, Any]] = Field(None, alias="Metadata")
+    model_config = {
+        "title": "UiPathAttachment",
+        "validate_by_name": True,
+        "validate_by_alias": True,
+    }
+
+
+@dataclass
+class BlobFileAccessInfo:
+    """Information about blob file access for an attachment.
+
+    Attributes:
+        id: The unique identifier (UUID) of the attachment.
+        uri: The blob storage URI for accessing the file.
+        name: The name of the attachment file.
+    """
+
+    id: uuid.UUID
+    uri: str
+    name: str
diff --git a/packages/uipath-platform/src/uipath/platform/automation_ops/__init__.py b/packages/uipath-platform/src/uipath/platform/automation_ops/__init__.py
new file mode 100644
index 000000000..87ce420ec
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/automation_ops/__init__.py
@@ -0,0 +1,9 @@
+"""AutomationOps service package.
+
+Provides the ``AutomationOpsService`` client for retrieving deployed AI Trust
+Layer policies from AgentHub.
+"""
+
+from ._automation_ops_service import AutomationOpsService
+
+__all__ = ["AutomationOpsService"]
diff --git a/packages/uipath-platform/src/uipath/platform/automation_ops/_automation_ops_service.py b/packages/uipath-platform/src/uipath/platform/automation_ops/_automation_ops_service.py
new file mode 100644
index 000000000..b5eac8cdd
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/automation_ops/_automation_ops_service.py
@@ -0,0 +1,70 @@
+"""AutomationOps service for UiPath Platform.
+
+Provides methods for retrieving deployed policies from the AgentHub service.
+"""
+
+from typing import Any
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+
+_DEPLOYED_POLICY_ENDPOINT = Endpoint("agenthub_/api/policies/deployed-policy")
+
+
+class AutomationOpsService(BaseService):
+    """Service for interacting with UiPath AutomationOps policies via AgentHub."""
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="automation_ops_get_deployed_policy", run_type="uipath")
+    def get_deployed_policy(self) -> dict[str, Any]:
+        """Retrieve the deployed policy.
+
+        Returns:
+            The deployed policy response as a dictionary. Returns an empty
+            dict when no policy is deployed (empty 200 response body).
+        """
+        spec = self._deployed_policy_spec()
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            scoped="tenant",
+        )
+        if not response.content:
+            return {}
+        return response.json()
+
+    @traced(name="automation_ops_get_deployed_policy", run_type="uipath")
+    async def get_deployed_policy_async(self) -> dict[str, Any]:
+        """Retrieve the deployed policy (async).
+
+        Returns:
+            The deployed policy response as a dictionary. Returns an empty
+            dict when no policy is deployed (empty 200 response body).
+        """
+        spec = self._deployed_policy_spec()
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            scoped="tenant",
+        )
+        if not response.content:
+            return {}
+        return response.json()
+
+    def _deployed_policy_spec(self) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=_DEPLOYED_POLICY_ENDPOINT,
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/automation_tracker/__init__.py b/packages/uipath-platform/src/uipath/platform/automation_tracker/__init__.py
new file mode 100644
index 000000000..a9bfbdb72
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/automation_tracker/__init__.py
@@ -0,0 +1,21 @@
+"""UiPath Automation Tracker (BTS) Models.
+
+This module contains models and service for tracking business transactions
+and operations via the Business Transaction Service (BTS).
+"""
+
+from ._automation_tracker_service import AutomationTrackerService
+from .automation_tracker import (
+    OperationPayload,
+    OperationStatus,
+    TransactionPayload,
+    TransactionStatus,
+)
+
+__all__ = [
+    "AutomationTrackerService",
+    "OperationPayload",
+    "OperationStatus",
+    "TransactionPayload",
+    "TransactionStatus",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/automation_tracker/_automation_tracker_service.py b/packages/uipath-platform/src/uipath/platform/automation_tracker/_automation_tracker_service.py
new file mode 100644
index 000000000..9a0537582
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/automation_tracker/_automation_tracker_service.py
@@ -0,0 +1,332 @@
+"""Automation Tracker (BTS) service for UiPath Platform.
+
+Provides HTTP client methods for tracking business transactions
+and operations via the Business Transaction Service, used for Process Mining.
+All errors are logged but never raised, ensuring BTS failures
+cannot break agent execution.
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from uipath.core import traced
+
+from ..common import BaseService, UiPathApiConfig, UiPathExecutionContext
+from ..common._config import UiPathConfig
+from ..common._models import Endpoint, RequestSpec
+from .automation_tracker import (
+    OperationPayload,
+    OperationStatus,
+    TransactionPayload,
+    TransactionStatus,
+)
+
+
+class AutomationTrackerService(BaseService):
+    """Service for tracking business transactions and operations via BTS.
+
+    This service provides methods to start/end transactions and operations
+    for Process Mining tracking. All errors are logged but never raised,
+    ensuring BTS failures cannot break agent execution.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._organization_id = UiPathConfig.organization_id or ""
+        self._tenant_id = UiPathConfig.tenant_id or ""
+
+    def _send(self, endpoint: str, payload_dict: Dict[str, Any]) -> None:
+        """Send a POST request to BTS, logging but never raising errors."""
+        spec = RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/automationtracker_/{endpoint}"),
+            json=payload_dict,
+        )
+        try:
+            self.request(
+                spec.method,
+                url=spec.endpoint,
+                json=spec.json,
+            )
+        except Exception:
+            self._logger.error(
+                "Failed to send request to BTS endpoint %s",
+                endpoint,
+                exc_info=True,
+            )
+
+    async def _send_async(self, endpoint: str, payload_dict: Dict[str, Any]) -> None:
+        """Send an async POST request to BTS, logging but never raising errors."""
+        spec = RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/automationtracker_/{endpoint}"),
+            json=payload_dict,
+        )
+        try:
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                json=spec.json,
+            )
+        except Exception:
+            self._logger.error(
+                "Failed to send request to BTS endpoint %s",
+                endpoint,
+                exc_info=True,
+            )
+
+    # ── Transaction methods ──────────────────────────────────────────
+
+    @traced(name="automation_tracker_start_transaction", run_type="uipath")
+    def start_transaction(
+        self,
+        *,
+        transaction_id: str,
+        name: str,
+        reference: str,
+        fingerprint: str,
+        status: TransactionStatus = TransactionStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """Start tracking a business transaction."""
+        payload = TransactionPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            name=name,
+            reference=reference,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            fingerprint=fingerprint,
+            result=result,
+            status=status.value,
+            attributes=attributes or {},
+        )
+        self._send(
+            "track/transaction/start", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_start_transaction", run_type="uipath")
+    async def start_transaction_async(
+        self,
+        *,
+        transaction_id: str,
+        name: str,
+        reference: str,
+        fingerprint: str,
+        status: TransactionStatus = TransactionStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """Start tracking a business transaction (async)."""
+        payload = TransactionPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            name=name,
+            reference=reference,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            fingerprint=fingerprint,
+            result=result,
+            status=status.value,
+            attributes=attributes or {},
+        )
+        await self._send_async(
+            "track/transaction/start", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_end_transaction", run_type="uipath")
+    def end_transaction(
+        self,
+        *,
+        transaction_id: str,
+        name: str,
+        reference: str,
+        fingerprint: str,
+        status: TransactionStatus = TransactionStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """End tracking a business transaction."""
+        payload = TransactionPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            name=name,
+            reference=reference,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            fingerprint=fingerprint,
+            result=result,
+            status=status.value,
+            attributes=attributes or {},
+        )
+        self._send(
+            "track/transaction/end", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_end_transaction", run_type="uipath")
+    async def end_transaction_async(
+        self,
+        *,
+        transaction_id: str,
+        name: str,
+        reference: str,
+        fingerprint: str,
+        status: TransactionStatus = TransactionStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """End tracking a business transaction (async)."""
+        payload = TransactionPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            name=name,
+            reference=reference,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            fingerprint=fingerprint,
+            result=result,
+            status=status.value,
+            attributes=attributes or {},
+        )
+        await self._send_async(
+            "track/transaction/end", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    # ── Operation methods ────────────────────────────────────────────
+
+    @traced(name="automation_tracker_start_operation", run_type="uipath")
+    def start_operation(
+        self,
+        *,
+        transaction_id: str,
+        operation_id: str,
+        name: str,
+        fingerprint: str,
+        parent_operation: Optional[str] = None,
+        status: OperationStatus = OperationStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """Start tracking an operation within a transaction."""
+        payload = OperationPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            operation_id=operation_id,
+            parent_operation=parent_operation,
+            name=name,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            status=status.value,
+            attributes=attributes or {},
+            result=result,
+            fingerprint=fingerprint,
+        )
+        self._send(
+            "track/operation/start", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_start_operation", run_type="uipath")
+    async def start_operation_async(
+        self,
+        *,
+        transaction_id: str,
+        operation_id: str,
+        name: str,
+        fingerprint: str,
+        parent_operation: Optional[str] = None,
+        status: OperationStatus = OperationStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """Start tracking an operation within a transaction (async)."""
+        payload = OperationPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            operation_id=operation_id,
+            parent_operation=parent_operation,
+            name=name,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            status=status.value,
+            attributes=attributes or {},
+            result=result,
+            fingerprint=fingerprint,
+        )
+        await self._send_async(
+            "track/operation/start", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_end_operation", run_type="uipath")
+    def end_operation(
+        self,
+        *,
+        transaction_id: str,
+        operation_id: str,
+        name: str,
+        fingerprint: str,
+        parent_operation: Optional[str] = None,
+        status: OperationStatus = OperationStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """End tracking an operation within a transaction."""
+        payload = OperationPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            operation_id=operation_id,
+            parent_operation=parent_operation,
+            name=name,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            status=status.value,
+            attributes=attributes or {},
+            result=result,
+            fingerprint=fingerprint,
+        )
+        self._send(
+            "track/operation/end", payload.model_dump(by_alias=True, mode="json")
+        )
+
+    @traced(name="automation_tracker_end_operation", run_type="uipath")
+    async def end_operation_async(
+        self,
+        *,
+        transaction_id: str,
+        operation_id: str,
+        name: str,
+        fingerprint: str,
+        parent_operation: Optional[str] = None,
+        status: OperationStatus = OperationStatus.UNKNOWN,
+        result: Optional[str] = None,
+        attributes: Optional[Dict[str, str]] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """End tracking an operation within a transaction (async)."""
+        payload = OperationPayload(
+            organization_id=self._organization_id,
+            tenant_id=self._tenant_id,
+            transaction_id=transaction_id,
+            operation_id=operation_id,
+            parent_operation=parent_operation,
+            name=name,
+            timestamp=timestamp or datetime.now(timezone.utc),
+            status=status.value,
+            attributes=attributes or {},
+            result=result,
+            fingerprint=fingerprint,
+        )
+        await self._send_async(
+            "track/operation/end", payload.model_dump(by_alias=True, mode="json")
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/automation_tracker/automation_tracker.py b/packages/uipath-platform/src/uipath/platform/automation_tracker/automation_tracker.py
new file mode 100644
index 000000000..918fa3393
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/automation_tracker/automation_tracker.py
@@ -0,0 +1,64 @@
+"""Automation Tracker (BTS) models for UiPath Platform.
+
+Models for tracking business transactions and operations
+via the Business Transaction Service, used for Process Mining.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class TransactionStatus(str, Enum):
+    """Status of a BTS transaction."""
+
+    UNKNOWN = "Unknown"
+    SUCCESSFUL = "Successful"
+    FAILED = "Failed"
+
+
+class OperationStatus(str, Enum):
+    """Status of a BTS operation."""
+
+    UNKNOWN = "Unknown"
+    SUCCESSFUL = "Successful"
+    FAILED = "Failed"
+    CANCELLED = "Cancelled"
+    ABANDONED = "Abandoned"
+
+
+class TransactionPayload(BaseModel):
+    """Wire-format payload for BTS transaction start/end endpoints."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    organization_id: str = Field(alias="organizationId")
+    tenant_id: str = Field(alias="tenantId")
+    transaction_id: str = Field(alias="transactionId")
+    name: str
+    reference: str
+    timestamp: datetime
+    fingerprint: str
+    result: Optional[str] = None
+    status: str
+    attributes: Dict[str, str] = Field(default_factory=dict)
+
+
+class OperationPayload(BaseModel):
+    """Wire-format payload for BTS operation start/end endpoints."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    organization_id: str = Field(alias="organizationId")
+    tenant_id: str = Field(alias="tenantId")
+    transaction_id: str = Field(alias="transactionId")
+    operation_id: str = Field(alias="operationId")
+    parent_operation: Optional[str] = Field(default=None, alias="parentOperation")
+    name: str
+    timestamp: datetime
+    status: str
+    attributes: Dict[str, str] = Field(default_factory=dict)
+    result: Optional[str] = None
+    fingerprint: str
diff --git a/packages/uipath-platform/src/uipath/platform/chat/__init__.py b/packages/uipath-platform/src/uipath/platform/chat/__init__.py
new file mode 100644
index 000000000..e192b047e
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/chat/__init__.py
@@ -0,0 +1,67 @@
+"""UiPath Chat Services.
+
+This module provides services for chat-related functionality including:
+- LLM Gateway services for chat completions and embeddings
+- Conversations service for autopilot conversations
+"""
+
+from ._conversations_service import ConversationsService
+from ._llm_gateway_service import (
+    DEFAULT_REQUESTING_FEATURE,
+    DEFAULT_REQUESTING_PRODUCT,
+    ChatModels,
+    EmbeddingModels,
+    UiPathLlmChatService,
+    UiPathOpenAIService,
+)
+from .llm_gateway import (
+    AutoToolChoice,
+    ChatCompletion,
+    ChatCompletionChoice,
+    ChatCompletionUsage,
+    ChatMessage,
+    EmbeddingItem,
+    EmbeddingUsage,
+    RequiredToolChoice,
+    SpecificToolChoice,
+    TextEmbedding,
+    ToolCall,
+    ToolChoice,
+    ToolDefinition,
+    ToolFunctionDefinition,
+    ToolParametersDefinition,
+    ToolPropertyDefinition,
+)
+from .llm_throttle import get_llm_semaphore, set_llm_concurrency
+
+__all__ = [
+    # Conversations Service
+    "ConversationsService",
+    # LLM Gateway Services
+    "ChatModels",
+    "EmbeddingModels",
+    "DEFAULT_REQUESTING_PRODUCT",
+    "DEFAULT_REQUESTING_FEATURE",
+    "UiPathLlmChatService",
+    "UiPathOpenAIService",
+    # LLM Throttling
+    "get_llm_semaphore",
+    "set_llm_concurrency",
+    # LLM Gateway Models
+    "ToolPropertyDefinition",
+    "ToolParametersDefinition",
+    "ToolFunctionDefinition",
+    "ToolDefinition",
+    "AutoToolChoice",
+    "RequiredToolChoice",
+    "SpecificToolChoice",
+    "ChatMessage",
+    "ChatCompletionChoice",
+    "ChatCompletionUsage",
+    "ChatCompletion",
+    "EmbeddingItem",
+    "EmbeddingUsage",
+    "TextEmbedding",
+    "ToolChoice",
+    "ToolCall",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/chat/_conversations_service.py b/packages/uipath-platform/src/uipath/platform/chat/_conversations_service.py
new file mode 100644
index 000000000..dcf501739
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/chat/_conversations_service.py
@@ -0,0 +1,52 @@
+from uipath.core.chat import UiPathConversationMessage
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+
+
+class ConversationsService(BaseService):
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="retrieve_message", run_type="uipath")
+    def retrieve_message(
+        self, conversation_id: str, exchange_id: str, message_id: str
+    ) -> UiPathConversationMessage:
+        retrieve_message_spec = self._retrieve_message_spec(
+            conversation_id, exchange_id, message_id
+        )
+
+        response = self.request(
+            retrieve_message_spec.method, retrieve_message_spec.endpoint
+        )
+
+        return UiPathConversationMessage.model_validate(response.json())
+
+    @traced(name="retrieve_message", run_type="uipath")
+    async def retrieve_message_async(
+        self, conversation_id: str, exchange_id: str, message_id: str
+    ) -> UiPathConversationMessage:
+        retrieve_message_spec = self._retrieve_message_spec(
+            conversation_id, exchange_id, message_id
+        )
+
+        response = await self.request_async(
+            retrieve_message_spec.method, retrieve_message_spec.endpoint
+        )
+
+        return UiPathConversationMessage.model_validate(response.json())
+
+    def _retrieve_message_spec(
+        self, conversation_id: str, exchange_id: str, message_id: str
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/autopilotforeveryone_/api/v1/conversation/{conversation_id}/exchange/{exchange_id}/message/{message_id}"
+            ),
+        )
diff --git a/src/uipath/_services/llm_gateway_service.py b/packages/uipath-platform/src/uipath/platform/chat/_llm_gateway_service.py
similarity index 50%
rename from src/uipath/_services/llm_gateway_service.py
rename to packages/uipath-platform/src/uipath/platform/chat/_llm_gateway_service.py
index 61258261e..cb02d8af3 100644
--- a/src/uipath/_services/llm_gateway_service.py
+++ b/packages/uipath-platform/src/uipath/platform/chat/_llm_gateway_service.py
@@ -16,22 +16,26 @@
     UiPathLlmChatService: Service using UiPath's normalized API format
 """
 
-import json
-from typing import Any, Dict, List, Optional
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._utils import Endpoint
-from ..models.llm_gateway import (
+from typing import Any, Optional
+
+from opentelemetry import trace
+from pydantic import BaseModel
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._endpoints_manager import EndpointManager
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint
+from .llm_gateway import (
     ChatCompletion,
     SpecificToolChoice,
     TextEmbedding,
     ToolChoice,
     ToolDefinition,
 )
-from ..tracing._traced import traced
-from ..utils import EndpointManager
-from ._base_service import BaseService
+from .llm_throttle import get_llm_semaphore
+from .llm_trace_context import build_trace_context_headers
 
 # Common constants
 API_VERSION = "2024-10-21"  # Standard API version for OpenAI-compatible endpoints
@@ -39,12 +43,26 @@
     "2024-08-01-preview"  # API version for UiPath's normalized endpoints
 )
 
-# Common headers used across all LLM Gateway requests
-DEFAULT_LLM_HEADERS = {
-    "X-UIPATH-STREAMING-ENABLED": "false",
-    "X-UiPath-LlmGateway-RequestingProduct": "uipath-python-sdk",
-    "X-UiPath-LlmGateway-RequestingFeature": "langgraph-agent",
-}
+DEFAULT_REQUESTING_PRODUCT = "uipath-python-sdk"
+DEFAULT_REQUESTING_FEATURE = "llm-call"
+
+
+def _build_llm_headers(
+    requesting_product: str = DEFAULT_REQUESTING_PRODUCT,
+    requesting_feature: str = DEFAULT_REQUESTING_FEATURE,
+    agenthub_config: Optional[str] = None,
+    action_id: Optional[str] = None,
+) -> dict[str, str]:
+    headers: dict[str, str] = {
+        "X-UIPATH-STREAMING-ENABLED": "false",
+        "X-UiPath-LlmGateway-RequestingProduct": requesting_product,
+        "X-UiPath-LlmGateway-RequestingFeature": requesting_feature,
+    }
+    if agenthub_config:
+        headers["X-UiPath-AgentHub-Config"] = agenthub_config
+    if action_id:
+        headers["X-UiPath-LlmGateway-ActionId"] = action_id
+    return headers
 
 
 class ChatModels(object):
@@ -62,6 +80,7 @@ class ChatModels(object):
     gpt_4o_2024_05_13 = "gpt-4o-2024-05-13"
     gpt_4o_2024_08_06 = "gpt-4o-2024-08-06"
     gpt_4o_mini_2024_07_18 = "gpt-4o-mini-2024-07-18"
+    gpt_4_1_mini_2025_04_14 = "gpt-4.1-mini-2025-04-14"
     o3_mini = "o3-mini-2025-01-31"
 
 
@@ -76,6 +95,65 @@ class EmbeddingModels(object):
     text_embedding_ada_002 = "text-embedding-ada-002"
 
 
+def _cleanup_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Clean up a JSON schema for use with LLM Gateway.
+
+    This function converts a JSON schema to a format that's
+    compatible with the LLM Gateway's JSON schema requirements by removing
+    titles and other metadata that might cause validation issues.
+
+    Args:
+        schema (dict[str, Any]): an input JSON schema.
+
+    Returns:
+        dict: A cleaned JSON schema dictionary suitable for LLM Gateway response_format.
+
+    Examples:
+        ```python
+        from pydantic import BaseModel
+
+        class Country(BaseModel):
+            name: str
+            capital: str
+            languages: list[str]
+
+        schema = _cleanup_schema(Country.model_json_schema())
+        # Returns a clean schema without titles and unnecessary metadata
+        ```
+    """
+
+    def clean_type(type_def):
+        """Clean property definitions by removing titles and cleaning nested items. Additionally, `additionalProperties` is ensured on all objects."""
+        cleaned_type = {}
+        for key, value in type_def.items():
+            if key == "title" or key == "properties":
+                continue
+            else:
+                cleaned_type[key] = value
+        if type_def.get("type") == "object" and "additionalProperties" not in type_def:
+            cleaned_type["additionalProperties"] = False
+
+        if "properties" in type_def:
+            properties = type_def.get("properties", {})
+            for key, value in properties.items():
+                properties[key] = clean_type(value)
+            cleaned_type["properties"] = properties
+
+        if type_def.get("type") == "object":
+            cleaned_type["required"] = list(cleaned_type.get("properties", {}).keys())
+
+        if "$defs" in type_def:
+            cleaned_defs = {}
+            for key, value in type_def["$defs"].items():
+                cleaned_defs[key] = clean_type(value)
+            cleaned_type["$defs"] = cleaned_defs
+        return cleaned_type
+
+    # Create clean schema
+    clean_schema = clean_type(schema)
+    return clean_schema
+
+
 class UiPathOpenAIService(BaseService):
     """Service for calling UiPath's LLM Gateway using OpenAI-compatible API.
 
@@ -84,8 +162,20 @@ class UiPathOpenAIService(BaseService):
     API format and is suitable for applications that need direct OpenAI API compatibility.
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        *,
+        requesting_product: str = DEFAULT_REQUESTING_PRODUCT,
+        requesting_feature: str = DEFAULT_REQUESTING_FEATURE,
+        agenthub_config: Optional[str] = None,
+        action_id: Optional[str] = None,
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
+        self._llm_headers = _build_llm_headers(
+            requesting_product, requesting_feature, agenthub_config, action_id
+        )
 
     @traced(name="llm_embeddings", run_type="uipath")
     async def embeddings(
@@ -129,24 +219,25 @@ async def embeddings(
         )
         endpoint = Endpoint("/" + endpoint)
 
-        response = await self.request_async(
-            "POST",
-            endpoint,
-            content=json.dumps({"input": input}),
-            params={"api-version": API_VERSION},
-            headers=DEFAULT_LLM_HEADERS,
-        )
+        async with get_llm_semaphore():
+            response = await self.request_async(
+                "POST",
+                endpoint,
+                json={"input": input},
+                params={"api-version": API_VERSION},
+                headers={**self._llm_headers, **build_trace_context_headers()},
+            )
 
         return TextEmbedding.model_validate(response.json())
 
-    @traced(name="llm_chat_completions", run_type="uipath")
+    @traced(name="LLM call", run_type="uipath")
     async def chat_completions(
         self,
-        messages: List[Dict[str, str]],
-        model: str = ChatModels.gpt_4o_mini_2024_07_18,
-        max_tokens: int = 50,
+        messages: list[dict[str, str]],
+        model: str = ChatModels.gpt_4_1_mini_2025_04_14,
+        max_tokens: int = 4096,
         temperature: float = 0,
-        response_format: Optional[Dict[str, Any]] = None,
+        response_format: dict[str, Any] | type[BaseModel] | None = None,
         api_version: str = API_VERSION,
     ):
         """Generate chat completions using UiPath's LLM Gateway service.
@@ -161,16 +252,18 @@ async def chat_completions(
                 the behavior/context, user messages are from the human, and assistant messages
                 are from the AI.
             model (str, optional): The model to use for chat completion.
-                Defaults to ChatModels.gpt_4o_mini_2024_07_18.
+                Defaults to ChatModels.gpt_4_1_mini_2025_04_14.
                 Available models are defined in the ChatModels class.
             max_tokens (int, optional): Maximum number of tokens to generate in the response.
-                Defaults to 50. Higher values allow longer responses.
+                Defaults to 4096. Higher values allow longer responses.
             temperature (float, optional): Temperature for sampling, between 0 and 1.
                 Lower values (closer to 0) make output more deterministic and focused,
                 higher values make it more creative and random. Defaults to 0.
-            response_format (Optional[Dict[str, Any]], optional): An object specifying the format
-                that the model must output. Used to enable JSON mode or other structured outputs.
-                Defaults to None.
+            response_format (Optional[Union[Dict[str, Any], type[BaseModel]]], optional):
+                An object specifying the format that the model must output. Can be either:
+                - A dictionary with response format configuration (traditional format)
+                - A Pydantic BaseModel class (automatically converted to JSON schema)
+                Used to enable JSON mode or other structured outputs. Defaults to None.
             api_version (str, optional): The API version to use. Defaults to API_VERSION.
 
         Returns:
@@ -198,12 +291,35 @@ async def chat_completions(
                 max_tokens=200,
                 temperature=0.3
             )
+
+            # Using Pydantic model for structured response
+            from pydantic import BaseModel
+
+            class Country(BaseModel):
+                name: str
+                capital: str
+                languages: list[str]
+
+            response = await service.chat_completions(
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant. Respond with structured JSON."},
+                    {"role": "user", "content": "Tell me about Canada."}
+                ],
+                response_format=Country,  # Pass BaseModel directly
+                max_tokens=1000
+            )
             ```
 
         Note:
             The conversation history can be included to provide context to the model.
             Each message should have both 'role' and 'content' keys.
+            When using a Pydantic BaseModel as response_format, it will be automatically
+            converted to the appropriate JSON schema format for the LLM Gateway.
         """
+        span = trace.get_current_span()
+        span.set_attribute("model", model)
+        span.set_attribute("uipath.custom_instrumentation", True)
+
         endpoint = EndpointManager.get_passthrough_endpoint().format(
             model=model, api_version=api_version
         )
@@ -215,17 +331,33 @@ async def chat_completions(
             "temperature": temperature,
         }
 
-        # Add response_format if provided
+        # Handle response_format - convert BaseModel to schema if needed
         if response_format:
-            request_body["response_format"] = response_format
-
-        response = await self.request_async(
-            "POST",
-            endpoint,
-            content=json.dumps(request_body),
-            params={"api-version": API_VERSION},
-            headers=DEFAULT_LLM_HEADERS,
-        )
+            if isinstance(response_format, type) and issubclass(
+                response_format, BaseModel
+            ):
+                # Convert Pydantic model to JSON schema format
+                cleaned_schema = _cleanup_schema(response_format.model_json_schema())
+                request_body["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": response_format.__name__.lower(),
+                        "strict": True,
+                        "schema": cleaned_schema,
+                    },
+                }
+            else:
+                # Use provided dictionary format directly
+                request_body["response_format"] = response_format
+
+        async with get_llm_semaphore():
+            response = await self.request_async(
+                "POST",
+                endpoint,
+                json=request_body,
+                params={"api-version": API_VERSION},
+                headers={**self._llm_headers, **build_trace_context_headers()},
+            )
 
         return ChatCompletion.model_validate(response.json())
 
@@ -242,23 +374,36 @@ class UiPathLlmChatService(BaseService):
     providers and includes enhanced features for enterprise use cases.
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        *,
+        requesting_product: str = DEFAULT_REQUESTING_PRODUCT,
+        requesting_feature: str = DEFAULT_REQUESTING_FEATURE,
+        agenthub_config: Optional[str] = None,
+        action_id: Optional[str] = None,
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
+        self._llm_headers = _build_llm_headers(
+            requesting_product, requesting_feature, agenthub_config, action_id
+        )
 
-    @traced(name="llm_chat_completions", run_type="uipath")
+    @traced(name="LLM call", run_type="uipath")
     async def chat_completions(
         self,
-        messages: List[Dict[str, str]],
-        model: str = ChatModels.gpt_4o_mini_2024_07_18,
-        max_tokens: int = 250,
+        messages: list[dict[str, str]] | list[tuple[str, str]],
+        model: str = ChatModels.gpt_4_1_mini_2025_04_14,
+        max_tokens: int = 4096,
         temperature: float = 0,
         n: int = 1,
         frequency_penalty: float = 0,
         presence_penalty: float = 0,
-        top_p: float = 1,
-        tools: Optional[List[ToolDefinition]] = None,
-        tool_choice: Optional[ToolChoice] = None,
-        response_format: Optional[Dict[str, Any]] = None,
+        top_p: float | None = 1,
+        top_k: int | None = None,
+        tools: list[ToolDefinition | dict[str, Any]] | None = None,
+        tool_choice: ToolChoice | None = None,
+        response_format: dict[str, Any] | type[BaseModel] | None = None,
         api_version: str = NORMALIZED_API_VERSION,
     ):
         """Generate chat completions using UiPath's normalized LLM Gateway API.
@@ -274,10 +419,10 @@ async def chat_completions(
                 the behavior/context, user messages are from the human, and assistant messages
                 are from the AI.
             model (str, optional): The model to use for chat completion.
-                Defaults to ChatModels.gpt_4o_mini_2024_07_18.
+                Defaults to ChatModels.gpt_4_1_mini_2025_04_14.
                 Available models are defined in the ChatModels class.
             max_tokens (int, optional): Maximum number of tokens to generate in the response.
-                Defaults to 250. Higher values allow longer responses.
+                Defaults to 4096. Higher values allow longer responses.
             temperature (float, optional): Temperature for sampling, between 0 and 1.
                 Lower values (closer to 0) make output more deterministic and focused,
                 higher values make it more creative and random. Defaults to 0.
@@ -289,15 +434,21 @@ async def chat_completions(
                 Positive values encourage discussion of new topics. Defaults to 0.
             top_p (float, optional): Nucleus sampling parameter between 0 and 1.
                 Controls diversity by considering only the top p probability mass. Defaults to 1.
-            tools (Optional[List[ToolDefinition]], optional): List of tool definitions that the
-                model can call. Tools enable the model to perform actions or retrieve information
-                beyond text generation. Defaults to None.
+            top_k (int, optional): Nucleus sampling parameter.
+                Controls diversity by considering only the top k most probable tokens. Defaults to None.
+            tools (Optional[List[ToolDefinition | dict]], optional): List of tool definitions
+                that the model can call. Tools enable the model to perform actions or retrieve
+                information beyond text generation. A tool given as a dict must already be in
+                UiPath wire format and is forwarded unchanged, which allows arbitrary nested
+                JSON schemas in its parameters. Defaults to None.
             tool_choice (Optional[ToolChoice], optional): Controls which tools the model can call.
                 Can be "auto" (model decides), "none" (no tools), or a specific tool choice.
                 Defaults to None.
-            response_format (Optional[Dict[str, Any]], optional): An object specifying the format
-                that the model must output. Used to enable JSON mode or other structured outputs.
-                Defaults to None.
+            response_format (Optional[Union[Dict[str, Any], type[BaseModel]]], optional):
+                An object specifying the format that the model must output. Can be either:
+                - A dictionary with response format configuration (traditional format)
+                - A Pydantic BaseModel class (automatically converted to JSON schema)
+                Used to enable JSON mode or other structured outputs. Defaults to None.
             api_version (str, optional): The normalized API version to use.
                 Defaults to NORMALIZED_API_VERSION.
 
@@ -349,35 +500,100 @@ async def chat_completions(
                 presence_penalty=0.2,
                 n=3  # Generate 3 alternative responses
             )
+
+            # Using Pydantic model for structured response
+            from pydantic import BaseModel
+
+            class Country(BaseModel):
+                name: str
+                capital: str
+                languages: list[str]
+
+            response = await service.chat_completions(
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant. Respond with structured JSON."},
+                    {"role": "user", "content": "Tell me about Canada."}
+                ],
+                response_format=Country,  # Pass BaseModel directly
+                max_tokens=1000
+            )
+            )
             ```
 
         Note:
             This service uses UiPath's normalized API format which provides consistent
             behavior across different underlying model providers and enhanced enterprise features.
         """
+        span = trace.get_current_span()
+        span.set_attribute("model", model)
+        span.set_attribute("uipath.custom_instrumentation", True)
+
+        converted_messages = []
+
+        for message in messages:
+            if isinstance(message, tuple) and len(message) == 2:
+                role, content = message
+                converted_messages.append({"role": role, "content": content})
+            elif isinstance(message, dict):
+                converted_messages.append(message)
+            else:
+                raise ValueError(
+                    f"Invalid message format: {message}. Expected tuple (role, content) or dict with 'role' and 'content' keys."
+                )
+
         endpoint = EndpointManager.get_normalized_endpoint().format(
             model=model, api_version=api_version
         )
         endpoint = Endpoint("/" + endpoint)
 
+        # Build request body - Claude models don't support some OpenAI-specific parameters
+        is_claude_model = "claude" in model.lower()
+
         request_body = {
-            "messages": messages,
+            "messages": converted_messages,
             "max_tokens": max_tokens,
             "temperature": temperature,
-            "n": n,
-            "frequency_penalty": frequency_penalty,
-            "presence_penalty": presence_penalty,
-            "top_p": top_p,
         }
 
-        # Add response_format if provided
+        # Only add OpenAI-specific parameters for non-Claude models
+        if not is_claude_model:
+            request_body["n"] = n
+            request_body["frequency_penalty"] = frequency_penalty
+            request_body["presence_penalty"] = presence_penalty
+            if top_p is not None:
+                request_body["top_p"] = top_p
+
+        if top_k is not None:
+            request_body["top_k"] = top_k
+
+        # Handle response_format - convert BaseModel to schema if needed
         if response_format:
-            request_body["response_format"] = response_format
+            if isinstance(response_format, type) and issubclass(
+                response_format, BaseModel
+            ):
+                # Convert Pydantic model to JSON schema format
+                cleaned_schema = _cleanup_schema(response_format.model_json_schema())
+                request_body["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": response_format.__name__.lower(),
+                        "strict": True,
+                        "schema": cleaned_schema,
+                    },
+                }
+            else:
+                # Use provided dictionary format directly
+                request_body["response_format"] = response_format
 
-        # Add tools if provided - convert to UiPath format
+        # Add tools if provided. A tool already in UiPath wire format (a dict) is
+        # passed through unchanged so callers can supply an arbitrary JSON schema
+        # for the parameters; ToolDefinition objects are converted as before.
         if tools:
             request_body["tools"] = [
-                self._convert_tool_to_uipath_format(tool) for tool in tools
+                tool
+                if isinstance(tool, dict)
+                else self._convert_tool_to_uipath_format(tool)
+                for tool in tools
             ]
 
         # Handle tool_choice
@@ -389,23 +605,64 @@ async def chat_completions(
             else:
                 request_body["tool_choice"] = tool_choice.model_dump()
 
-        # Use default headers but update with normalized API specific headers
         headers = {
-            **DEFAULT_LLM_HEADERS,
+            **self._llm_headers,
+            **build_trace_context_headers(),
             "X-UiPath-LlmGateway-NormalizedApi-ModelName": model,
+            "X-UiPath-LLMGateway-AllowFull4xxResponse": "true",
         }
 
-        response = await self.request_async(
-            "POST",
-            endpoint,
-            content=json.dumps(request_body),
-            params={"api-version": NORMALIZED_API_VERSION},
-            headers=headers,
-        )
+        # Log the complete request for debugging
+        import json as json_module
+        import logging
+
+        logger = logging.getLogger(__name__)
+
+        logger.info("=" * 80)
+        logger.info("📤 LLM Gateway Normalized API Request")
+        logger.info("=" * 80)
+        logger.info(f"Model: {model}")
+        logger.info(f"Endpoint: {endpoint}")
+        logger.info(f"API Version: {NORMALIZED_API_VERSION}")
+        logger.info(f"Is Claude Model: {is_claude_model}")
+        logger.info("-" * 80)
+        logger.info("Headers:")
+        for key, value in headers.items():
+            logger.info(f"  {key}: {value}")
+        logger.info("-" * 80)
+        logger.info("Request Body:")
+        # Create a copy for logging with tools truncated for readability
+        log_body: dict[str, Any] = request_body.copy()
+        tools_list = log_body.get("tools")
+        if tools_list and isinstance(tools_list, list):
+            log_body["tools"] = f"[{len(tools_list)} tool(s)]"
+        messages_list = log_body.get("messages")
+        if messages_list and isinstance(messages_list, list):
+            log_body["messages"] = [
+                {
+                    **msg,
+                    "content": msg["content"][:100] + "..."
+                    if len(msg.get("content", "")) > 100
+                    else msg["content"],
+                }
+                for msg in messages_list
+            ]
+        logger.info(json_module.dumps(log_body, indent=2))
+        logger.info("=" * 80)
+
+        async with get_llm_semaphore():
+            response = await self.request_async(
+                "POST",
+                endpoint,
+                json=request_body,
+                params={"api-version": NORMALIZED_API_VERSION},
+                headers=headers,
+            )
 
+        logger.info(f"✅ Response received with status: {response.status_code}")
         return ChatCompletion.model_validate(response.json())
 
-    def _convert_tool_to_uipath_format(self, tool: ToolDefinition) -> Dict[str, Any]:
+    def _convert_tool_to_uipath_format(self, tool: ToolDefinition) -> dict[str, Any]:
         """Convert an OpenAI-style tool definition to UiPath API format.
 
         This internal method transforms tool definitions from the standard OpenAI format
diff --git a/src/uipath/models/llm_gateway.py b/packages/uipath-platform/src/uipath/platform/chat/llm_gateway.py
similarity index 67%
rename from src/uipath/models/llm_gateway.py
rename to packages/uipath-platform/src/uipath/platform/chat/llm_gateway.py
index e0010cc80..0223bd4d3 100644
--- a/src/uipath/models/llm_gateway.py
+++ b/packages/uipath-platform/src/uipath/platform/chat/llm_gateway.py
@@ -1,20 +1,28 @@
+"""Models for LLM Gateway interactions in the UiPath platform."""
+
 from typing import Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
 
 class EmbeddingItem(BaseModel):
+    """Model representing an individual embedding item."""
+
     embedding: List[float]
     index: int
     object: str
 
 
 class EmbeddingUsage(BaseModel):
+    """Model representing usage statistics for embeddings."""
+
     prompt_tokens: int
     total_tokens: int
 
 
 class TextEmbedding(BaseModel):
+    """Model representing a text embedding response."""
+
     data: List[EmbeddingItem]
     model: str
     object: str
@@ -22,43 +30,59 @@ class TextEmbedding(BaseModel):
 
 
 class ToolCall(BaseModel):
+    """Model representing a tool call."""
+
     id: str
     name: str
     arguments: Dict[str, Any]
 
 
 class ToolPropertyDefinition(BaseModel):
+    """Model representing a tool property definition."""
+
     type: str
     description: Optional[str] = None
     enum: Optional[List[str]] = None
 
 
 class ToolParametersDefinition(BaseModel):
+    """Model representing tool parameters definition."""
+
     type: str = "object"
     properties: Dict[str, ToolPropertyDefinition]
     required: Optional[List[str]] = None
 
 
 class ToolFunctionDefinition(BaseModel):
+    """Model representing a tool function definition."""
+
     name: str
     description: Optional[str] = None
     parameters: ToolParametersDefinition
 
 
 class ToolDefinition(BaseModel):
+    """Model representing a tool definition."""
+
     type: Literal["function"] = "function"
     function: ToolFunctionDefinition
 
 
 class AutoToolChoice(BaseModel):
+    """Model representing an automatic tool choice."""
+
     type: Literal["auto"] = "auto"
 
 
 class RequiredToolChoice(BaseModel):
+    """Model representing a required tool choice."""
+
     type: Literal["required"] = "required"
 
 
 class SpecificToolChoice(BaseModel):
+    """Model representing a specific tool choice."""
+
     type: Literal["tool"] = "tool"
     name: str
 
@@ -69,18 +93,24 @@ class SpecificToolChoice(BaseModel):
 
 
 class ChatMessage(BaseModel):
+    """Model representing a chat message."""
+
     role: str
     content: Optional[str] = None
     tool_calls: Optional[List[ToolCall]] = None
 
 
 class ChatCompletionChoice(BaseModel):
+    """Model representing a chat completion choice."""
+
     index: int
     message: ChatMessage
     finish_reason: str
 
 
 class ChatCompletionUsage(BaseModel):
+    """Model representing usage statistics for chat completions."""
+
     prompt_tokens: int
     completion_tokens: int
     total_tokens: int
@@ -88,6 +118,8 @@ class ChatCompletionUsage(BaseModel):
 
 
 class ChatCompletion(BaseModel):
+    """Model representing a chat completion response."""
+
     id: str
     object: str
     created: int
diff --git a/packages/uipath-platform/src/uipath/platform/chat/llm_throttle.py b/packages/uipath-platform/src/uipath/platform/chat/llm_throttle.py
new file mode 100644
index 000000000..c51a299d0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/chat/llm_throttle.py
@@ -0,0 +1,57 @@
+"""LLM request throttling utilities.
+
+This module provides concurrency control for LLM API requests to prevent
+overwhelming the system with simultaneous calls.
+"""
+
+import asyncio
+
+DEFAULT_LLM_CONCURRENCY = 20
+_llm_concurrency_limit: int = DEFAULT_LLM_CONCURRENCY
+_llm_semaphore: asyncio.Semaphore | None = None
+_llm_semaphore_loop: asyncio.AbstractEventLoop | None = None
+
+
+def get_llm_semaphore() -> asyncio.Semaphore:
+    """Get the LLM semaphore, creating with configured limit if not set.
+
+    The semaphore is recreated if called from a different event loop than
+    the one it was originally created in. This prevents "bound to a different
+    event loop" errors when using multiple asyncio.run() calls.
+    """
+    global _llm_semaphore, _llm_semaphore_loop
+
+    loop = asyncio.get_running_loop()
+
+    # Recreate semaphore if it doesn't exist or if the event loop changed
+    if _llm_semaphore is None or _llm_semaphore_loop is not loop:
+        _llm_semaphore = asyncio.Semaphore(_llm_concurrency_limit)
+        _llm_semaphore_loop = loop
+
+    return _llm_semaphore
+
+
+def set_llm_concurrency(limit: int) -> None:
+    """Set the max concurrent LLM requests. Call before making any LLM calls.
+
+    Args:
+        limit: Maximum number of concurrent LLM requests allowed (must be > 0).
+
+    Raises:
+        ValueError: If limit is less than 1.
+    """
+    if limit < 1:
+        raise ValueError("LLM concurrency limit must be at least 1")
+
+    global _llm_concurrency_limit, _llm_semaphore, _llm_semaphore_loop
+    _llm_concurrency_limit = limit
+    _llm_semaphore = None
+    _llm_semaphore_loop = None
+
+
+def reset_llm_concurrency() -> None:
+    """Reset LLM concurrency limit and semaphore to defaults."""
+    global _llm_concurrency_limit, _llm_semaphore, _llm_semaphore_loop
+    _llm_concurrency_limit = DEFAULT_LLM_CONCURRENCY
+    _llm_semaphore = None
+    _llm_semaphore_loop = None
diff --git a/packages/uipath-platform/src/uipath/platform/chat/llm_trace_context.py b/packages/uipath-platform/src/uipath/platform/chat/llm_trace_context.py
new file mode 100644
index 000000000..b9c1f74a0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/chat/llm_trace_context.py
@@ -0,0 +1,50 @@
+"""W3C-style trace context headers for LLM Gateway requests."""
+
+from opentelemetry import trace
+from uipath.core.feature_flags import FeatureFlags
+from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+from ..common._config import UiPathConfig
+from ..common._span_utils import _SpanUtils, resolve_project_id
+
+
+def build_trace_context_headers(
+    extra_baggage: list[str] | None = None,
+) -> dict[str, str]:
+    """Build W3C-style trace context headers for LLM Gateway requests.
+
+    Resolves the current span via ``UiPathSpanUtils.get_external_current_span()``
+    (which returns the deepest active span from the LLMOps hierarchy) with a
+    fallback to ``trace.get_current_span()``.
+
+    Args:
+        extra_baggage: Additional baggage entries (e.g. ``["source=agents"]``)
+            that callers can inject alongside the platform-level entries.
+
+    Returns an empty dict when the ``EnableTraceContextHeaders`` feature flag
+    is not enabled, or when no active span is present.
+    """
+    if not FeatureFlags.is_flag_enabled("EnableTraceContextHeaders"):
+        return {}
+
+    headers: dict[str, str] = {}
+    llmops_span = UiPathSpanUtils.get_external_current_span()
+    span = llmops_span or trace.get_current_span()
+    config_trace_id = UiPathConfig.trace_id
+    ctx = span.get_span_context()
+    if config_trace_id and ctx and ctx.span_id:
+        trace_id = _SpanUtils.normalize_trace_id(config_trace_id)
+        span_id = format(ctx.span_id, "032x")
+        headers["x-uipath-traceparent-id"] = f"00-{trace_id}-{span_id}"
+
+    baggage_parts: list[str] = list(extra_baggage) if extra_baggage else []
+    if folder_key := UiPathConfig.folder_key:
+        baggage_parts.append(f"folderKey={folder_key}")
+    if agent_id := resolve_project_id():
+        baggage_parts.append(f"agentId={agent_id}")
+    if process_key := UiPathConfig.process_key:
+        baggage_parts.append(f"processKey={process_key}")
+    if baggage_parts:
+        headers["x-uipath-tracebaggage"] = ",".join(baggage_parts)
+
+    return headers
diff --git a/packages/uipath-platform/src/uipath/platform/common/__init__.py b/packages/uipath-platform/src/uipath/platform/common/__init__.py
new file mode 100644
index 000000000..555d6901d
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/__init__.py
@@ -0,0 +1,118 @@
+"""UiPath Common Models.
+
+This module contains common models used across multiple services.
+"""
+
+from ._api_client import ApiClient
+from ._base_service import BaseService, resolve_trace_id
+from ._bindings import (
+    ConnectionResourceOverwrite,
+    EntityResourceOverwrite,
+    GenericResourceOverwrite,
+    ResourceOverwrite,
+    ResourceOverwriteParser,
+    ResourceOverwritesContext,
+    resource_override,
+)
+from ._config import UiPathApiConfig, UiPathConfig
+from ._endpoints_manager import EndpointManager
+from ._execution_context import UiPathExecutionContext
+from ._external_application_service import ExternalApplicationService
+from ._folder_context import FolderContext, header_folder
+from ._http_config import get_ca_bundle_path, get_httpx_client_kwargs
+from ._models import Endpoint, RequestSpec
+from ._service_url_overrides import inject_routing_headers, resolve_service_url
+from ._span_utils import UiPathSpan, _SpanUtils
+from ._url import UiPathUrl
+from ._user_agent import user_agent_value
+from .auth import TokenData
+from .dynamic_schema import jsonschema_to_pydantic
+from .interrupt_models import (
+    CreateBatchTransform,
+    CreateDeepRag,
+    CreateDeepRagRaw,
+    CreateEphemeralIndex,
+    CreateEphemeralIndexRaw,
+    CreateEscalation,
+    CreateTask,
+    DocumentExtraction,
+    DocumentExtractionValidation,
+    InvokeProcess,
+    InvokeProcessRaw,
+    InvokeSystemAgent,
+    WaitBatchTransform,
+    WaitDeepRag,
+    WaitDeepRagRaw,
+    WaitDocumentExtraction,
+    WaitDocumentExtractionValidation,
+    WaitEphemeralIndex,
+    WaitEphemeralIndexRaw,
+    WaitEscalation,
+    WaitIntegrationEvent,
+    WaitJob,
+    WaitJobRaw,
+    WaitSystemAgent,
+    WaitTask,
+)
+from .paging import PagedResult
+
+__all__ = [
+    "ApiClient",
+    "BaseService",
+    "UiPathApiConfig",
+    "UiPathExecutionContext",
+    "ExternalApplicationService",
+    "FolderContext",
+    "TokenData",
+    "UiPathConfig",
+    "CreateTask",
+    "CreateEscalation",
+    "WaitEscalation",
+    "InvokeProcess",
+    "InvokeProcessRaw",
+    "WaitTask",
+    "WaitJob",
+    "WaitJobRaw",
+    "PagedResult",
+    "CreateDeepRag",
+    "CreateDeepRagRaw",
+    "WaitDeepRag",
+    "WaitDeepRagRaw",
+    "CreateBatchTransform",
+    "WaitBatchTransform",
+    "DocumentExtraction",
+    "WaitDocumentExtraction",
+    "InvokeSystemAgent",
+    "WaitSystemAgent",
+    "CreateEphemeralIndex",
+    "CreateEphemeralIndexRaw",
+    "WaitEphemeralIndex",
+    "WaitEphemeralIndexRaw",
+    "DocumentExtractionValidation",
+    "WaitDocumentExtractionValidation",
+    "WaitIntegrationEvent",
+    "RequestSpec",
+    "Endpoint",
+    "UiPathUrl",
+    "user_agent_value",
+    "get_ca_bundle_path",
+    "get_httpx_client_kwargs",
+    "resource_override",
+    "header_folder",
+    "validate_pagination_params",
+    "EndpointManager",
+    "jsonschema_to_pydantic",
+    "ConnectionResourceOverwrite",
+    "EntityResourceOverwrite",
+    "GenericResourceOverwrite",
+    "ResourceOverwrite",
+    "ResourceOverwriteParser",
+    "ResourceOverwritesContext",
+    "UiPathSpan",
+    "_SpanUtils",
+    "resolve_service_url",
+    "inject_routing_headers",
+    "resolve_trace_id",
+]
+
+from .validation import validate_pagination_params
diff --git a/src/uipath/_services/api_client.py b/packages/uipath-platform/src/uipath/platform/common/_api_client.py
similarity index 72%
rename from src/uipath/_services/api_client.py
rename to packages/uipath-platform/src/uipath/platform/common/_api_client.py
index 6a4334cab..da9b91f4a 100644
--- a/src/uipath/_services/api_client.py
+++ b/packages/uipath-platform/src/uipath/platform/common/_api_client.py
@@ -1,11 +1,11 @@
-from typing import Any, Union
+from typing import Any, Literal, Union
 
 from httpx import URL, Response
 
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
 from ._base_service import BaseService
+from ._config import UiPathApiConfig
+from ._execution_context import UiPathExecutionContext
+from ._folder_context import FolderContext
 
 
 class ApiClient(FolderContext, BaseService):
@@ -17,13 +17,16 @@ class ApiClient(FolderContext, BaseService):
     with automatic authentication and retry logic.
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
 
     def request(
         self,
         method: str,
         url: Union[URL, str],
+        scoped: Literal["org", "tenant"] = "tenant",
         **kwargs: Any,
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
@@ -35,12 +38,13 @@ def request(
         if "include_folder_headers" in kwargs:
             del kwargs["include_folder_headers"]
 
-        return super().request(method, url, **kwargs)
+        return super().request(method, url, scoped=scoped, **kwargs)
 
     async def request_async(
         self,
         method: str,
         url: Union[URL, str],
+        scoped: Literal["org", "tenant"] = "tenant",
         **kwargs: Any,
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
@@ -52,4 +56,4 @@ async def request_async(
         if "include_folder_headers" in kwargs:
             del kwargs["include_folder_headers"]
 
-        return await super().request_async(method, url, **kwargs)
+        return await super().request_async(method, url, scoped=scoped, **kwargs)
diff --git a/packages/uipath-platform/src/uipath/platform/common/_base_service.py b/packages/uipath-platform/src/uipath/platform/common/_base_service.py
new file mode 100644
index 000000000..95035b852
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_base_service.py
@@ -0,0 +1,279 @@
+import sys
+import types
+from logging import getLogger
+from typing import Any, Literal, Union
+
+from httpx import (
+    URL,
+    AsyncClient,
+    Client,
+    Headers,
+    HTTPStatusError,
+    Response,
+)
+from opentelemetry import trace
+from opentelemetry.trace import format_span_id, format_trace_id
+from tenacity import (
+    retry,
+    retry_if_exception,
+    retry_if_result,
+    stop_after_attempt,
+)
+
+from ..errors import EnrichedException
+from ._config import UiPathApiConfig
+from ._execution_context import UiPathExecutionContext
+from ._http_config import get_httpx_client_kwargs
+from ._service_url_overrides import inject_routing_headers, resolve_service_url
+from ._url import UiPathUrl
+from ._user_agent import user_agent_value
+from .constants import HEADER_USER_AGENT
+from .retry import (
+    MAX_RETRY_ATTEMPTS,
+    is_retryable_platform_exception,
+    is_retryable_response,
+    platform_wait_strategy,
+)
+
+_THIS_FILE = __file__
+_MAX_CALLER_FRAMES = 5
+
+
+def _get_caller_component() -> str:
+    try:
+        current: types.FrameType | None = sys._getframe(1)
+        for _ in range(_MAX_CALLER_FRAMES):
+            if current is None:
+                break
+            code = current.f_code
+            if code.co_filename == _THIS_FILE:
+                current = current.f_back
+                continue
+            # Skip frames from third-party libraries (e.g. tenacity)
+            if "site-packages" in code.co_filename:
+                current = current.f_back
+                continue
+            qualname = code.co_qualname
+            if "." in qualname:
+                parts = qualname.rsplit(".", 2)
+                return f"{parts[-2]}.{parts[-1]}"
+            current = current.f_back
+    except Exception:
+        pass
+    return ""
+
+
+_TRACE_PARENT_HEADER = "x-uipath-traceparent-id"
+
+
+def resolve_trace_id(fallback: str | None = None) -> str | None:
+    """Resolve the current UiPath trace id as a 32-char hex string.
+
+    Same lookup chain :func:`_inject_trace_context` uses to compose the
+    ``x-uipath-traceparent-id`` header, exposed as a public helper so
+    callers can capture the value when they need it in a request body
+    (e.g. governance compensation) or before hopping to a background
+    thread that won't inherit the OpenTelemetry context.
+
+    Resolution order (first hit wins):
+
+    1. :attr:`UiPathConfig.trace_id` (``UIPATH_TRACE_ID`` env var),
+       normalized via :meth:`_SpanUtils.normalize_trace_id`. This is the
+       canonical agent trace id the LLMOps exporter binds spans to.
+    2. The LLMOps external span trace id, when a provider is registered
+       via :meth:`UiPathSpanUtils.register_current_span_provider`.
+    3. The current OpenTelemetry span trace id.
+    4. The caller-supplied ``fallback``.
+
+    Args:
+        fallback: Returned when nothing above resolves.
+
+    Returns:
+        Lower-case 32-char hex trace id, or ``fallback`` (which may be
+        ``None``) when no source yields a usable value.
+
+    Thread Safety:
+        Steps 2 and 3 read OpenTelemetry's thread-local context. Call this
+        on the thread that owns the live span (e.g. the agent's hook
+        thread) and capture the result before submitting work to a
+        background pool — worker threads do not inherit the context.
+    """
+    from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+    from ._config import UiPathConfig
+    from ._span_utils import _SpanUtils
+
+    config_trace_id = UiPathConfig.trace_id
+    if config_trace_id:
+        try:
+            return _SpanUtils.normalize_trace_id(config_trace_id)
+        except ValueError:
+            # Malformed UIPATH_TRACE_ID — fall through to OTel context.
+            pass
+
+    llmops_span = UiPathSpanUtils.get_external_current_span()
+    span = llmops_span or trace.get_current_span()
+    ctx = span.get_span_context()
+    if ctx.trace_id:
+        return format_trace_id(ctx.trace_id)
+
+    return fallback
+
+
+def _inject_trace_context(headers: dict[str, str]) -> None:
+    """Inject UiPath trace context header.
+
+    Trace ID: uses the agent trace ID from UIPATH_TRACE_ID env var (same
+    remapping the LLMOps exporter applies), falling back to the OTEL trace ID.
+    Span ID: uses the LLMOps tool span (via external span provider) so the
+    span ID matches what's visible in the LLMOps trace UI.
+    """
+    from uipath.core.tracing.span_utils import UiPathSpanUtils
+
+    from ._config import UiPathConfig
+    from ._span_utils import _SpanUtils
+
+    llmops_span = UiPathSpanUtils.get_external_current_span()
+    span = llmops_span or trace.get_current_span()
+    ctx = span.get_span_context()
+    if not (ctx.trace_id and ctx.span_id):
+        return
+
+    config_trace_id = UiPathConfig.trace_id
+    trace_id = (
+        _SpanUtils.normalize_trace_id(config_trace_id)
+        if config_trace_id
+        else format_trace_id(ctx.trace_id)
+    )
+    span_id = format_span_id(ctx.span_id)
+    headers[_TRACE_PARENT_HEADER] = f"00-{trace_id}-{span_id}-01"
+
+
+class BaseService:
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        self._logger = getLogger("uipath")
+        self._config = config
+        self._execution_context = execution_context
+
+        self._url = UiPathUrl(self._config.base_url)
+
+        client_kwargs = get_httpx_client_kwargs(headers=self.default_headers)
+        client_kwargs["base_url"] = self._url.base_url
+        client_kwargs["headers"] = Headers(client_kwargs.get("headers", {}))
+
+        self._client = Client(**client_kwargs)
+        self._client_async = AsyncClient(**client_kwargs)
+
+        self._logger.debug(f"HEADERS: {self.default_headers}")
+
+        super().__init__()
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_platform_exception)
+            | retry_if_result(is_retryable_response)
+        ),
+        wait=platform_wait_strategy,
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        reraise=True,
+    )
+    def request(
+        self,
+        method: str,
+        url: Union[URL, str],
+        *,
+        scoped: Literal["org", "tenant"] = "tenant",
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(f"HEADERS: {kwargs.get('headers', self._client.headers)}")
+
+        specific_component = _get_caller_component()
+
+        kwargs.setdefault("headers", {})
+        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(specific_component)
+        _inject_trace_context(kwargs["headers"])
+
+        override = resolve_service_url(str(url))
+        if override:
+            scoped_url = override
+            inject_routing_headers(kwargs["headers"])
+        else:
+            scoped_url = self._url.scope_url(str(url), scoped)
+
+        response = self._client.request(method, scoped_url, **kwargs)
+
+        try:
+            response.raise_for_status()
+        except HTTPStatusError as e:
+            # include the http response in the error message
+            raise EnrichedException(e) from e
+
+        return response
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_platform_exception)
+            | retry_if_result(is_retryable_response)
+        ),
+        wait=platform_wait_strategy,
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        reraise=True,
+    )
+    async def request_async(
+        self,
+        method: str,
+        url: Union[URL, str],
+        *,
+        scoped: Literal["org", "tenant"] = "tenant",
+        **kwargs: Any,
+    ) -> Response:
+        self._logger.debug(f"Request: {method} {url}")
+        self._logger.debug(
+            f"HEADERS: {kwargs.get('headers', self._client_async.headers)}"
+        )
+
+        kwargs.setdefault("headers", {})
+        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(
+            self._specific_component
+        )
+        _inject_trace_context(kwargs["headers"])
+
+        override = resolve_service_url(str(url))
+        if override:
+            scoped_url = override
+            inject_routing_headers(kwargs["headers"])
+        else:
+            scoped_url = self._url.scope_url(str(url), scoped)
+
+        response = await self._client_async.request(method, scoped_url, **kwargs)
+
+        try:
+            response.raise_for_status()
+        except HTTPStatusError as e:
+            # include the http response in the error message
+            raise EnrichedException(e) from e
+        return response
+
+    @property
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/json",
+            **self.auth_headers,
+            **self.custom_headers,
+        }
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        header = f"Bearer {self._config.secret}"
+        return {"Authorization": header}
+
+    @property
+    def custom_headers(self) -> dict[str, str]:
+        return {}
+
+    @property
+    def _specific_component(self) -> str:
+        return _get_caller_component()
diff --git a/packages/uipath-platform/src/uipath/platform/common/_bindings.py b/packages/uipath-platform/src/uipath/platform/common/_bindings.py
new file mode 100644
index 000000000..a93880896
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_bindings.py
@@ -0,0 +1,324 @@
+import functools
+import inspect
+import logging
+from abc import ABC, abstractmethod
+from contextvars import ContextVar, Token
+from typing import (
+    Annotated,
+    Any,
+    Callable,
+    Coroutine,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    TypeAdapter,
+    model_validator,
+)
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class ResourceOverwrite(BaseModel, ABC):
+    """Abstract base class for resource overwrites.
+
+    Subclasses must implement properties to provide resource and folder identifiers
+    appropriate for their resource type.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @property
+    @abstractmethod
+    def resource_identifier(self) -> str:
+        """The identifier used to reference this resource."""
+        pass
+
+    @property
+    @abstractmethod
+    def folder_identifier(self) -> str:
+        """The folder location identifier for this resource."""
+        pass
+
+
+class GenericResourceOverwrite(ResourceOverwrite):
+    resource_type: Literal[
+        "process",
+        "index",
+        "app",
+        "asset",
+        "bucket",
+        "mcpServer",
+        "queue",
+        "remoteA2aAgent",
+        "memorySpace",
+    ]
+    name: str = Field(alias="name")
+    folder_path: str = Field(alias="folderPath")
+
+    @property
+    def resource_identifier(self) -> str:
+        return self.name
+
+    @property
+    def folder_identifier(self) -> str:
+        return self.folder_path
+
+
+class EntityResourceOverwrite(ResourceOverwrite):
+    resource_type: Literal["entity"]
+    name: str = Field(alias="name")
+    folder_id: Optional[str] = Field(default=None, alias="folderId")
+    folder_path: Optional[str] = Field(default=None, alias="folderPath")
+
+    @model_validator(mode="after")
+    def validate_folder_identifier(self) -> "EntityResourceOverwrite":
+        if self.folder_id and self.folder_path:
+            raise ValueError("Only one of folderId or folderPath may be provided.")
+        if not self.folder_id and not self.folder_path:
+            raise ValueError("Either folderId or folderPath must be provided.")
+        return self
+
+    @property
+    def resource_identifier(self) -> str:
+        return self.name
+
+    @property
+    def folder_identifier(self) -> str:
+        return self.folder_id or self.folder_path or ""
+
+
+class ConnectionResourceOverwrite(ResourceOverwrite):
+    resource_type: Literal["connection"]
+    # In eval context, studio web provides "ConnectionId".
+    connection_id: str = Field(
+        alias="connectionId",
+        validation_alias=AliasChoices("connectionId", "ConnectionId"),
+    )
+    folder_key: str = Field(alias="folderKey")
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="ignore",
+    )
+
+    @property
+    def resource_identifier(self) -> str:
+        return self.connection_id
+
+    @property
+    def folder_identifier(self) -> str:
+        return self.folder_key
+
+
+ResourceOverwriteUnion = Annotated[
+    Union[
+        GenericResourceOverwrite, EntityResourceOverwrite, ConnectionResourceOverwrite
+    ],
+    Field(discriminator="resource_type"),
+]
+
+
+class ResourceOverwriteParser:
+    """Parser for resource overwrite configurations.
+
+    Handles parsing of resource overwrites from key-value pairs where the key
+    contains the resource type prefix (e.g., "process.name", "connection.key").
+    """
+
+    _adapter: TypeAdapter[ResourceOverwriteUnion] = TypeAdapter(ResourceOverwriteUnion)
+
+    @classmethod
+    def parse(cls, key: str, value: dict[str, Any]) -> ResourceOverwrite:
+        """Parse a resource overwrite from a key-value pair.
+
+        Extracts the resource type from the key prefix and injects it into the value
+        for discriminated union validation.
+
+        Args:
+            key: The resource key (e.g., "process.MyProcess", "connection.abc-123")
+            value: The resource data dictionary
+
+        Returns:
+            The appropriate ResourceOverwrite subclass instance
+        """
+        resource_type = key.split(".")[0]
+        normalized_value = cls._normalize_value(resource_type, value)
+        value_with_type = {"resource_type": resource_type, **normalized_value}
+        return cls._adapter.validate_python(value_with_type)
+
+    @staticmethod
+    def _normalize_value(resource_type: str, value: dict[str, Any]) -> dict[str, Any]:
+        if resource_type != "entity":
+            return value
+
+        normalized = dict(value)
+        if "folderId" in normalized:
+            normalized["folder_id"] = normalized.pop("folderId")
+        if "folderPath" in normalized:
+            normalized["folder_path"] = normalized.pop("folderPath")
+
+        return normalized
+
+
+_resource_overwrites: ContextVar[Optional[dict[str, ResourceOverwrite]]] = ContextVar(
+    "resource_overwrites", default=None
+)
+
+
+class ResourceOverwritesContext:
+    def __init__(
+        self,
+        get_overwrites_callable: Callable[
+            [], Coroutine[Any, Any, dict[str, ResourceOverwrite]]
+        ],
+    ):
+        self.get_overwrites_callable = get_overwrites_callable
+        self._token: Optional[Token[Optional[dict[str, ResourceOverwrite]]]] = None
+        self.overwrites_count = 0
+
+    async def __aenter__(self) -> "ResourceOverwritesContext":
+        existing = _resource_overwrites.get()
+        if existing is not None:
+            logger.warning(
+                "Entering ResourceOverwritesContext while another context is already active (%d existing overwrite(s))",
+                len(existing),
+            )
+        overwrites = await self.get_overwrites_callable()
+        self._token = _resource_overwrites.set(overwrites)
+        self.overwrites_count = len(overwrites)
+        if overwrites:
+            logger.info(
+                "Resource overwrites context entered: %d overwrite(s) loaded, keys=%s",
+                len(overwrites),
+                list(overwrites.keys()),
+            )
+        else:
+            logger.debug("Resource overwrites context entered: no overwrites loaded")
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._token:
+            logger.debug(
+                "Resource overwrites context exited: %d overwrite(s) cleared",
+                self.overwrites_count,
+            )
+            _resource_overwrites.reset(self._token)
+
+
+def resource_override(
+    resource_type: str,
+    resource_identifier: str = "name",
+    folder_identifier: str = "folder_path",
+) -> Callable[..., Any]:
+    """Decorator for applying resource overrides for an overridable resource.
+
+    It checks the current ContextVar to identify the requested overrides and, if any key matches, it invokes the decorated function
+    with the extracted resource and folder identifiers.
+
+    Args:
+        resource_type: Type of resource to check for overrides (e.g., "asset", "bucket")
+        resource_identifier: Key name for the resource ID in override data (default: "name")
+        folder_identifier: Key name for the folder path in override data (default: "folder_path")
+
+    Returns:
+        Decorated function that receives overridden resource identifiers when applicable
+
+    Note:
+        Must be applied BEFORE the @traced decorator to ensure proper execution order.
+    """
+
+    def decorator(func: Callable[..., Any]):
+        sig = inspect.signature(func)
+
+        def process_args(args, kwargs) -> dict[str, Any]:
+            """Process arguments and apply resource overrides if applicable."""
+            # convert both args and kwargs to single dict
+            bound = sig.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+            all_args = dict(bound.arguments)
+            if (
+                "kwargs" in sig.parameters
+                and sig.parameters["kwargs"].kind == inspect.Parameter.VAR_KEYWORD
+            ):
+                extra_kwargs = all_args.pop("kwargs", {})
+                all_args.update(extra_kwargs)
+
+            # Get overwrites from context variable
+            context_overwrites = _resource_overwrites.get()
+
+            if context_overwrites is not None:
+                resource_identifier_value = all_args.get(resource_identifier)
+                folder_identifier_value = all_args.get(folder_identifier)
+
+                key = f"{resource_type}.{resource_identifier_value}"
+                # try to apply folder path, fallback to resource_type.resource_name
+                if folder_identifier_value:
+                    key = (
+                        f"{key}.{folder_identifier_value}"
+                        if f"{key}.{folder_identifier_value}" in context_overwrites
+                        else key
+                    )
+
+                matched_overwrite = context_overwrites.get(key)
+
+                # Apply the matched overwrite
+                if matched_overwrite is not None:
+                    old_resource = all_args.get(resource_identifier)
+                    old_folder = all_args.get(folder_identifier)
+                    if resource_identifier in sig.parameters:
+                        all_args[resource_identifier] = (
+                            matched_overwrite.resource_identifier
+                        )
+                    if folder_identifier in sig.parameters:
+                        all_args[folder_identifier] = (
+                            matched_overwrite.folder_identifier
+                        )
+                    logger.debug(
+                        "Resource overwrite applied for %s on %s: %s='%s' -> '%s', %s='%s' -> '%s'",
+                        resource_type,
+                        func.__name__,
+                        resource_identifier,
+                        old_resource,
+                        matched_overwrite.resource_identifier,
+                        folder_identifier,
+                        old_folder,
+                        matched_overwrite.folder_identifier,
+                    )
+                else:
+                    logger.info(
+                        "No resource overwrite matched for %s key='%s' on %s",
+                        resource_type,
+                        key,
+                        func.__name__,
+                    )
+
+            return all_args
+
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                all_args = process_args(args, kwargs)
+                return await func(**all_args)
+
+            return async_wrapper
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                all_args = process_args(args, kwargs)
+                return func(**all_args)
+
+            return wrapper
+
+    return decorator
diff --git a/packages/uipath-platform/src/uipath/platform/common/_config.py b/packages/uipath-platform/src/uipath/platform/common/_config.py
new file mode 100644
index 000000000..40db82214
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_config.py
@@ -0,0 +1,227 @@
+import os
+from functools import cached_property
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class UiPathApiConfig(BaseModel):
+    base_url: str
+    secret: str
+
+
+class ConfigurationManager:
+    _instance = None
+    studio_solution_id: str | None = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"project_id={self.project_id!r}, "
+            f"folder_key={self.folder_key!r}, "
+            f"folder_path={self.folder_path!r}, "
+            f"base_url={self.base_url!r}, "
+            f"tenant_id={self.tenant_id!r}, "
+            f"organization_id={self.organization_id!r}, "
+            f"job_key={self.job_key!r}, "
+            f"process_uuid={self.process_uuid!r}, "
+            f"process_version={self.process_version!r})"
+        )
+
+    @property
+    def bindings_file_path(self) -> Path:
+        from uipath.platform.common.constants import UIPATH_BINDINGS_FILE
+
+        return Path(UIPATH_BINDINGS_FILE)
+
+    @property
+    def config_file_path(self) -> Path:
+        from uipath.platform.common.constants import (
+            ENV_UIPATH_CONFIG_PATH,
+            UIPATH_CONFIG_FILE,
+        )
+
+        return Path(os.environ.get(ENV_UIPATH_CONFIG_PATH, UIPATH_CONFIG_FILE))
+
+    @property
+    def config_file_name(self) -> str:
+        from uipath.platform.common.constants import UIPATH_CONFIG_FILE
+
+        return UIPATH_CONFIG_FILE
+
+    @property
+    def project_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_PROJECT_ID
+
+        return os.getenv(ENV_UIPATH_PROJECT_ID, None)
+
+    @property
+    def agent_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_AGENT_ID
+
+        return os.getenv(ENV_UIPATH_AGENT_ID) or self.project_id
+
+    @property
+    def cloud_user_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_CLOUD_USER_ID
+
+        return os.getenv(ENV_UIPATH_CLOUD_USER_ID, None)
+
+    @property
+    def project_files_source(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_PROJECT_FILES_SOURCE
+
+        return os.getenv(ENV_UIPATH_PROJECT_FILES_SOURCE, None)
+
+    @property
+    def project_key(self) -> str | None:
+        from uipath.platform.common.constants import ENV_PROJECT_KEY
+
+        return os.getenv(ENV_PROJECT_KEY, None)
+
+    @property
+    def tenant_name(self) -> str | None:
+        from uipath.platform.common.constants import ENV_TENANT_NAME
+
+        return os.getenv(ENV_TENANT_NAME, None)
+
+    @property
+    def tenant_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_TENANT_ID
+
+        return os.getenv(ENV_TENANT_ID, None)
+
+    @property
+    def organization_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_ORGANIZATION_ID
+
+        return os.getenv(ENV_ORGANIZATION_ID, None)
+
+    @property
+    def base_url(self) -> str | None:
+        from uipath.platform.common.constants import ENV_BASE_URL
+
+        return os.getenv(ENV_BASE_URL, None)
+
+    @property
+    def folder_key(self) -> str | None:
+        from uipath.platform.common.constants import ENV_FOLDER_KEY
+
+        return os.getenv(ENV_FOLDER_KEY, None)
+
+    @property
+    def folder_path(self) -> str | None:
+        from uipath.platform.common.constants import ENV_FOLDER_PATH
+
+        return os.getenv(ENV_FOLDER_PATH, None)
+
+    @property
+    def process_key(self) -> str | None:
+        from uipath.platform.common.constants import ENV_PROCESS_KEY
+
+        return os.getenv(ENV_PROCESS_KEY, None)
+
+    @property
+    def process_uuid(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_PROCESS_UUID
+
+        return os.getenv(ENV_UIPATH_PROCESS_UUID, None)
+
+    @property
+    def trace_id(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_TRACE_ID
+
+        return os.getenv(ENV_UIPATH_TRACE_ID, None)
+
+    @property
+    def process_version(self) -> str | None:
+        from uipath.platform.common.constants import ENV_UIPATH_PROCESS_VERSION
+
+        return os.getenv(ENV_UIPATH_PROCESS_VERSION, None)
+
+    @property
+    def is_studio_project(self) -> bool:
+        return self.project_id is not None
+
+    @property
+    def job_key(self) -> str | None:
+        from uipath.platform.common.constants import ENV_JOB_KEY
+
+        return os.getenv(ENV_JOB_KEY, None)
+
+    @property
+    def has_legacy_eval_folder(self) -> bool:
+        from uipath.platform.common.constants import LEGACY_EVAL_FOLDER
+
+        eval_path = Path(os.getcwd()) / LEGACY_EVAL_FOLDER
+        return eval_path.exists() and eval_path.is_dir()
+
+    @property
+    def has_eval_folder(self) -> bool:
+        from uipath.platform.common.constants import EVALS_FOLDER
+
+        coded_eval_path = Path(os.getcwd()) / EVALS_FOLDER
+        return coded_eval_path.exists() and coded_eval_path.is_dir()
+
+    @property
+    def entry_points_file_path(self) -> Path:
+        from uipath.platform.common.constants import ENTRY_POINTS_FILE
+
+        return Path(ENTRY_POINTS_FILE)
+
+    @property
+    def uiproj_file_path(self) -> Path:
+        from uipath.platform.common.constants import UIPROJ_FILE
+
+        return Path(UIPROJ_FILE)
+
+    @property
+    def studio_metadata_file_path(self) -> Path:
+        from uipath.platform.common.constants import STUDIO_METADATA_FILE
+
+        return Path(".uipath", STUDIO_METADATA_FILE)
+
+    @property
+    def licensing_context(self) -> str | None:
+        return self._read_internal_argument("licensingContext")
+
+    @property
+    def is_rooted_to_debug_job(self) -> bool:
+        """Whether this job, which may be a deployed process, is rooted to a debug session (e.g. Maestro solution debug)."""
+        return self._read_internal_argument("isDebug") is True
+
+    @property
+    def is_tracing_enabled(self) -> bool:
+        from uipath.platform.common.constants import ENV_TRACING_ENABLED
+
+        return os.getenv(ENV_TRACING_ENABLED, "true").lower() == "true"
+
+    def reset(self) -> None:
+        """Reset mutable cached state to defaults."""
+        self.studio_solution_id = None
+        # Invalidate cached_property by removing from instance __dict__
+        self.__dict__.pop("_internal_arguments", None)
+
+    def _read_internal_argument(self, key: str) -> Any:
+        internal_args = self._internal_arguments
+        return internal_args.get(key) if internal_args else None
+
+    @cached_property
+    def _internal_arguments(self) -> dict[str, Any] | None:
+        import json
+
+        try:
+            with open(self.config_file_path, "r") as f:
+                data = json.load(f)
+                return data.get("runtime", {}).get("internalArguments")
+        except (FileNotFoundError, json.JSONDecodeError):
+            return None
+
+
+UiPathConfig = ConfigurationManager()
diff --git a/packages/uipath-platform/src/uipath/platform/common/_endpoints_manager.py b/packages/uipath-platform/src/uipath/platform/common/_endpoints_manager.py
new file mode 100644
index 000000000..044ab1393
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_endpoints_manager.py
@@ -0,0 +1,202 @@
+import logging
+import os
+from enum import Enum
+
+import httpx
+
+from ._config import UiPathConfig
+from ._http_config import get_httpx_client_kwargs
+from ._service_url_overrides import resolve_service_url
+
+loggger = logging.getLogger(__name__)
+
+
+class UiPathEndpoints(Enum):
+    AH_NORMALIZED_COMPLETION_ENDPOINT = "agenthub_/llm/api/chat/completions"
+    AH_PASSTHROUGH_COMPLETION_ENDPOINT = "agenthub_/llm/openai/deployments/{model}/chat/completions?api-version={api_version}"
+    AH_EMBEDDING_ENDPOINT = (
+        "agenthub_/llm/openai/deployments/{model}/embeddings?api-version={api_version}"
+    )
+    AH_VENDOR_COMPLETION_ENDPOINT = (
+        "agenthub_/llm/raw/vendor/{vendor}/model/{model}/completions"
+    )
+    AH_CAPABILITIES_ENDPOINT = "agenthub_/llm/api/capabilities"
+
+    OR_NORMALIZED_COMPLETION_ENDPOINT = "orchestrator_/llm/api/chat/completions"
+    OR_PASSTHROUGH_COMPLETION_ENDPOINT = "orchestrator_/llm/openai/deployments/{model}/chat/completions?api-version={api_version}"
+    OR_EMBEDDING_ENDPOINT = "orchestrator_/llm/openai/deployments/{model}/embeddings?api-version={api_version}"
+    OR_VENDOR_COMPLETION_ENDPOINT = (
+        "orchestrator_/llm/raw/vendor/{vendor}/model/{model}/completions"
+    )
+    OR_CAPABILITIES_ENDPOINT = "orchestrator_/llm/api/capabilities"
+
+
+class EndpointManager:
+    """Manages and caches the UiPath endpoints.
+    This class provides functionality to determine which UiPath endpoints to use based on
+    the availability of AgentHub and Orchestrator. It checks for capabilities and caches
+    the results to avoid repeated network calls.
+
+    The endpoint selection follows a fallback order:
+    1. AgentHub (if available)
+    2. Orchestrator (if available)
+
+    Environment Variable Override:
+    The fallback behavior can be bypassed using the UIPATH_LLM_SERVICE environment variable:
+    - 'agenthub' or 'ah': Force use of AgentHub endpoints (skips capability checks)
+    - 'orchestrator' or 'or': Force use of Orchestrator endpoints (skips capability checks)
+
+    Class Attributes:
+        _base_url (str): The base URL for UiPath services, retrieved from the UIPATH_URL
+                         environment variable.
+        _agenthub_available (Optional[bool]): Cached result of AgentHub availability check.
+        _orchestrator_available (Optional[bool]): Cached result of Orchestrator availability check.
+
+    Methods:
+        is_agenthub_available(): Checks if AgentHub is available, caching the result.
+        is_orchestrator_available(): Checks if Orchestrator is available, caching the result.
+        get_passthrough_endpoint(): Returns the appropriate passthrough completion endpoint.
+        get_normalized_endpoint(): Returns the appropriate normalized completion endpoint.
+        get_embeddings_endpoint(): Returns the appropriate embeddings endpoint.
+        get_vendor_endpoint(): Returns the appropriate vendor completion endpoint.
+    All endpoint methods automatically select the best available endpoint using the fallback order,
+    unless overridden by the UIPATH_LLM_SERVICE environment variable.
+    """  # noqa: D205
+
+    _base_url = UiPathConfig.base_url or ""
+    _agenthub_available: bool | None = None
+    _orchestrator_available: bool | None = None
+
+    @classmethod
+    def is_agenthub_available(cls) -> bool:
+        """Check if AgentHub is available and cache the result."""
+        if cls._agenthub_available is None:
+            cls._agenthub_available = cls._check_agenthub()
+        return cls._agenthub_available
+
+    @classmethod
+    def is_orchestrator_available(cls) -> bool:
+        """Check if Orchestrator is available and cache the result."""
+        if cls._orchestrator_available is None:
+            cls._orchestrator_available = cls._check_orchestrator()
+        return cls._orchestrator_available
+
+    @classmethod
+    def _check_capabilities(cls, endpoint: UiPathEndpoints, service_name: str) -> bool:
+        """Perform the actual check for service capabilities.
+
+        Args:
+            endpoint: The capabilities endpoint to check
+            service_name: Human-readable service name for logging
+
+        Returns:
+            bool: True if the service is available and has valid capabilities
+        """
+        try:
+            with httpx.Client(**get_httpx_client_kwargs()) as http_client:
+                capabilities_url = resolve_service_url(endpoint.value)
+                if not capabilities_url:
+                    base_url = UiPathConfig.base_url or ""
+                    capabilities_url = f"{base_url.rstrip('/')}/{endpoint.value}"
+                loggger.debug(
+                    f"Checking {service_name} capabilities at {capabilities_url}"
+                )
+                response = http_client.get(capabilities_url)
+
+                if response.status_code != 200:
+                    return False
+
+                capabilities = response.json()
+
+                # Validate structure and required fields
+                if not isinstance(capabilities, dict) or "version" not in capabilities:
+                    return False
+
+                return True
+
+        except Exception as e:
+            loggger.error(
+                f"Error checking {service_name} capabilities: {e}", exc_info=True
+            )
+            return False
+
+    @classmethod
+    def _check_agenthub(cls) -> bool:
+        """Perform the actual check for AgentHub capabilities."""
+        return cls._check_capabilities(
+            UiPathEndpoints.AH_CAPABILITIES_ENDPOINT, "AgentHub"
+        )
+
+    @classmethod
+    def _check_orchestrator(cls) -> bool:
+        """Perform the actual check for Orchestrator capabilities."""
+        return cls._check_capabilities(
+            UiPathEndpoints.OR_CAPABILITIES_ENDPOINT, "Orchestrator"
+        )
+
+    @classmethod
+    def _select_endpoint(cls, ah: UiPathEndpoints, orc: UiPathEndpoints) -> str:
+        """Select an endpoint based on UIPATH_LLM_SERVICE override or capability checks."""
+        service_override = os.getenv("UIPATH_LLM_SERVICE", "").lower()
+
+        if service_override in ("agenthub", "ah"):
+            return ah.value
+        if service_override in ("orchestrator", "or"):
+            return orc.value
+
+        # Determine fallback order based on environment hints
+        hdens_env = os.getenv("HDENS_ENV", "").lower()
+
+        # Default order: AgentHub -> Orchestrator
+        check_order = [
+            ("ah", ah, cls.is_agenthub_available),
+            ("orc", orc, cls.is_orchestrator_available),
+        ]
+
+        # Prioritize Orchestrator if HDENS_ENV is 'sf'
+        # Note: The default order already prioritizes AgentHub
+        if hdens_env == "sf":
+            check_order.reverse()
+
+        # Execute fallback checks in the determined order
+        for _, endpoint, is_available in check_order:
+            if is_available():
+                return endpoint.value
+
+        url = UiPathConfig.base_url or ""
+        if ".uipath.com" in url:
+            return ah.value
+        else:
+            return orc.value
+
+    @classmethod
+    def get_passthrough_endpoint(cls) -> str:
+        """Get the passthrough completion endpoint."""
+        return cls._select_endpoint(
+            UiPathEndpoints.AH_PASSTHROUGH_COMPLETION_ENDPOINT,
+            UiPathEndpoints.OR_PASSTHROUGH_COMPLETION_ENDPOINT,
+        )
+
+    @classmethod
+    def get_normalized_endpoint(cls) -> str:
+        """Get the normalized completion endpoint."""
+        return cls._select_endpoint(
+            UiPathEndpoints.AH_NORMALIZED_COMPLETION_ENDPOINT,
+            UiPathEndpoints.OR_NORMALIZED_COMPLETION_ENDPOINT,
+        )
+
+    @classmethod
+    def get_embeddings_endpoint(cls) -> str:
+        """Get the embeddings endpoint."""
+        return cls._select_endpoint(
+            UiPathEndpoints.AH_EMBEDDING_ENDPOINT,
+            UiPathEndpoints.OR_EMBEDDING_ENDPOINT,
+        )
+
+    @classmethod
+    def get_vendor_endpoint(cls) -> str:
+        """Get the vendor completion endpoint."""
+        return cls._select_endpoint(
+            UiPathEndpoints.AH_VENDOR_COMPLETION_ENDPOINT,
+            UiPathEndpoints.OR_VENDOR_COMPLETION_ENDPOINT,
+        )
diff --git a/src/uipath/_execution_context.py b/packages/uipath-platform/src/uipath/platform/common/_execution_context.py
similarity index 75%
rename from src/uipath/_execution_context.py
rename to packages/uipath-platform/src/uipath/platform/common/_execution_context.py
index 1b861929a..de54c0c99 100644
--- a/src/uipath/_execution_context.py
+++ b/packages/uipath-platform/src/uipath/platform/common/_execution_context.py
@@ -1,41 +1,36 @@
 from os import environ as env
-from typing import Optional
 
-from dotenv import load_dotenv
+from uipath.platform.common.constants import ENV_JOB_ID, ENV_JOB_KEY, ENV_ROBOT_KEY
 
-from ._utils.constants import ENV_JOB_ID, ENV_JOB_KEY, ENV_ROBOT_KEY
 
-load_dotenv(override=True)
-
-
-class ExecutionContext:
+class UiPathExecutionContext:
     """Manages the execution context for UiPath automation processes.
 
-    The ExecutionContext class handles information about the current execution environment,
+    The UiPathExecutionContext class handles information about the current execution environment,
     including the job instance ID and robot key. This information is essential for
     tracking and managing automation jobs in UiPath Automation Cloud.
     """
 
     def __init__(self) -> None:
         try:
-            self._instance_key: Optional[str] = env[ENV_JOB_KEY]
+            self._instance_key: str | None = env[ENV_JOB_KEY]
         except KeyError:
             self._instance_key = None
 
         try:
-            self._instance_id: Optional[str] = env[ENV_JOB_ID]
+            self._instance_id: str | None = env[ENV_JOB_ID]
         except KeyError:
             self._instance_id = None
 
         try:
-            self._robot_key: Optional[str] = env[ENV_ROBOT_KEY]
+            self._robot_key: str | None = env[ENV_ROBOT_KEY]
         except KeyError:
             self._robot_key = None
 
         super().__init__()
 
     @property
-    def instance_id(self) -> Optional[str]:
+    def instance_id(self) -> str | None:
         """Get the current job instance ID.
 
         The instance ID uniquely identifies the current automation job execution
@@ -53,7 +48,7 @@ def instance_id(self) -> Optional[str]:
         return self._instance_id
 
     @property
-    def instance_key(self) -> Optional[str]:
+    def instance_key(self) -> str | None:
         """Get the current job instance key.
 
         The instance key uniquely identifies the current automation job execution
@@ -65,7 +60,7 @@ def instance_key(self) -> Optional[str]:
         return self._instance_key
 
     @property
-    def robot_key(self) -> Optional[str]:
+    def robot_key(self) -> str | None:
         """Get the current robot key.
 
         The robot key identifies the UiPath Robot that is executing the current
diff --git a/packages/uipath-platform/src/uipath/platform/common/_external_application_service.py b/packages/uipath-platform/src/uipath/platform/common/_external_application_service.py
new file mode 100644
index 000000000..5c27ab779
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_external_application_service.py
@@ -0,0 +1,172 @@
+from os import environ as env
+from typing import Optional
+from urllib.parse import urlparse
+
+import httpx
+from httpx import HTTPStatusError
+
+from ..errors import EnrichedException
+from ..identity import IdentityService
+from .auth import TokenData
+from .constants import ENV_BASE_URL
+
+
+class ExternalApplicationService:
+    """Service for client credentials authentication flow."""
+
+    def __init__(self, base_url: Optional[str]):
+        if not (resolved_base_url := (base_url or env.get(ENV_BASE_URL))):
+            raise ValueError(
+                "Base URL must be set either via constructor or the BASE_URL environment variable."
+            )
+        self._base_url = resolved_base_url
+        self._domain = self._extract_environment_from_base_url(self._base_url)
+        domain_map = {
+            "alpha": "https://alpha.uipath.com",
+            "staging": "https://staging.uipath.com",
+        }
+        self._identity_service = IdentityService(
+            domain_map.get(self._domain, "https://cloud.uipath.com")
+        )
+
+    def _is_valid_domain_or_subdomain(self, hostname: str, domain: str) -> bool:
+        """Check if hostname is either an exact match or a valid subdomain of the domain.
+
+        Args:
+            hostname: The hostname to check
+            domain: The domain to validate against
+
+        Returns:
+            True if hostname is valid domain or subdomain, False otherwise
+        """
+        return hostname == domain or hostname.endswith(f".{domain}")
+
+    def _extract_environment_from_base_url(self, base_url: str) -> str:
+        """Extract domain from base URL.
+
+        Args:
+            base_url: The base URL to extract domain from
+
+        Returns:
+            The domain (alpha, staging, or cloud)
+        """
+        try:
+            parsed = urlparse(base_url)
+            hostname = parsed.hostname
+
+            if hostname:
+                match hostname:
+                    case h if self._is_valid_domain_or_subdomain(h, "alpha.uipath.com"):
+                        return "alpha"
+                    case h if self._is_valid_domain_or_subdomain(
+                        h, "staging.uipath.com"
+                    ):
+                        return "staging"
+                    case h if self._is_valid_domain_or_subdomain(h, "cloud.uipath.com"):
+                        return "cloud"
+
+            # Default to cloud if we can't determine
+            return "cloud"
+        except Exception:
+            # Default to cloud if parsing fails
+            return "cloud"
+
+    def get_token_data(
+        self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
+    ) -> TokenData:
+        """Authenticate using client credentials flow.
+
+        Args:
+            client_id: The client ID for authentication
+            client_secret: The client secret for authentication
+            scope: The scope for the token (default: OR.Execution)
+
+        Returns:
+            Token data if successful
+        """
+        try:
+            return self._identity_service.get_client_credentials_token(
+                client_id=client_id,
+                client_secret=client_secret,
+                scope=scope,
+            )
+        except HTTPStatusError as e:
+            match e.response.status_code:
+                case 400:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message="Invalid client credentials or request parameters.",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+                case 401:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message="Unauthorized: Invalid client credentials.",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+                case _:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message=f"Authentication failed with unexpected status: {e.response.status_code}",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+        except httpx.RequestError as e:
+            raise Exception(f"Network error during authentication: {e}") from e
+        except Exception as e:
+            raise Exception(f"Unexpected error during authentication: {e}") from e
+
+    async def get_token_data_async(
+        self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
+    ) -> TokenData:
+        """Authenticate using client credentials flow.
+
+        Args:
+            client_id: The client ID for authentication
+            client_secret: The client secret for authentication
+            scope: The scope for the token (default: OR.Execution)
+
+        Returns:
+            Token data if successful
+        """
+        try:
+            return await self._identity_service.get_client_credentials_token_async(
+                client_id=client_id,
+                client_secret=client_secret,
+                scope=scope,
+            )
+        except HTTPStatusError as e:
+            match e.response.status_code:
+                case 400:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message="Invalid client credentials or request parameters.",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+                case 401:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message="Unauthorized: Invalid client credentials.",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+                case _:
+                    raise EnrichedException(
+                        HTTPStatusError(
+                            message=f"Authentication failed with unexpected status: {e.response.status_code}",
+                            request=e.request,
+                            response=e.response,
+                        )
+                    ) from e
+        except httpx.RequestError as e:
+            raise Exception(f"Network error during authentication: {e}") from e
+        except Exception as e:
+            raise Exception(f"Unexpected error during authentication: {e}") from e
diff --git a/src/uipath/_folder_context.py b/packages/uipath-platform/src/uipath/platform/common/_folder_context.py
similarity index 54%
rename from src/uipath/_folder_context.py
rename to packages/uipath-platform/src/uipath/platform/common/_folder_context.py
index 2ca3bd83c..4d401aded 100644
--- a/src/uipath/_folder_context.py
+++ b/packages/uipath-platform/src/uipath/platform/common/_folder_context.py
@@ -1,16 +1,44 @@
+from base64 import b64encode
 from os import environ as env
 from typing import Any, Optional
 
-from dotenv import load_dotenv
-
-from ._utils.constants import (
+from uipath.platform.common.constants import (
     ENV_FOLDER_KEY,
     ENV_FOLDER_PATH,
     HEADER_FOLDER_KEY,
     HEADER_FOLDER_PATH,
+    HEADER_FOLDER_PATH_ENCODED,
 )
 
-load_dotenv(override=True)
+
+def folder_path_header(folder_path: str) -> dict[str, str]:
+    """Return the appropriate folder path header.
+
+    Uses the encoded header variant when the path contains non-ASCII
+    characters, since HTTP headers require ASCII values. The Orchestrator
+    expects Base64(UTF-16LE) in the encoded header.
+    """
+    try:
+        folder_path.encode("ascii")
+        return {HEADER_FOLDER_PATH: folder_path}
+    except UnicodeEncodeError:
+        encoded = b64encode(folder_path.encode("utf-16-le")).decode("ascii")
+        return {HEADER_FOLDER_PATH_ENCODED: encoded}
+
+
+def header_folder(
+    folder_key: Optional[str], folder_path: Optional[str]
+) -> dict[str, str]:
+    if folder_key is not None and folder_path is not None:
+        raise ValueError("Only one of folder_key or folder_path can be provided")
+
+    headers = {}
+    if folder_key is not None and folder_key != "":
+        headers[HEADER_FOLDER_KEY] = folder_key
+    if folder_path is not None and folder_path != "":
+        headers.update(folder_path_header(folder_path))
+
+    return headers
 
 
 class FolderContext:
@@ -24,12 +52,12 @@ class FolderContext:
 
     def __init__(self, **kwargs: Any) -> None:
         try:
-            self._folder_key: Optional[str] = env[ENV_FOLDER_KEY]
+            self._folder_key: str | None = env[ENV_FOLDER_KEY]
         except KeyError:
             self._folder_key = None
 
         try:
-            self._folder_path: Optional[str] = env[ENV_FOLDER_PATH]
+            self._folder_path: str | None = env[ENV_FOLDER_PATH]
         except KeyError:
             self._folder_path = None
 
@@ -52,6 +80,6 @@ def folder_headers(self) -> dict[str, str]:
         if self._folder_key is not None:
             return {HEADER_FOLDER_KEY: self._folder_key}
         elif self._folder_path is not None:
-            return {HEADER_FOLDER_PATH: self._folder_path}
+            return folder_path_header(self._folder_path)
         else:
             return {}
diff --git a/packages/uipath-platform/src/uipath/platform/common/_http_config.py b/packages/uipath-platform/src/uipath/platform/common/_http_config.py
new file mode 100644
index 000000000..191d768c4
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_http_config.py
@@ -0,0 +1,81 @@
+import os
+import ssl
+from typing import Any, Dict
+
+
+def expand_path(path):
+    """Expand environment variables and user home directory in path."""
+    if not path:
+        return path
+    # Expand environment variables like $HOME
+    path = os.path.expandvars(path)
+    # Expand user home directory ~
+    path = os.path.expanduser(path)
+    return path
+
+
+def get_ca_bundle_path() -> str | None:
+    """Resolve CA bundle path from environment variables.
+
+    Returns None if SSL verification is disabled via UIPATH_DISABLE_SSL_VERIFY.
+    Otherwise returns the CA bundle path with priority:
+    SSL_CERT_FILE > REQUESTS_CA_BUNDLE > certifi default.
+    """
+    disable_ssl_env = os.environ.get("UIPATH_DISABLE_SSL_VERIFY", "").lower()
+    if disable_ssl_env in ("1", "true", "yes", "on"):
+        return None
+
+    import certifi
+
+    ssl_cert_file = expand_path(os.environ.get("SSL_CERT_FILE"))
+    requests_ca_bundle = expand_path(os.environ.get("REQUESTS_CA_BUNDLE"))
+
+    return ssl_cert_file or requests_ca_bundle or certifi.where()
+
+
+def create_ssl_context(cafile: str):
+    """Create an SSL context for httpx clients.
+
+    Args:
+        cafile: Path to the CA bundle file.
+    """
+    try:
+        import truststore
+
+        return truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    except ImportError:
+        ssl_cert_dir = expand_path(os.environ.get("SSL_CERT_DIR"))
+
+        return ssl.create_default_context(
+            cafile=cafile,
+            capath=ssl_cert_dir,
+        )
+
+
+def get_httpx_client_kwargs(
+    headers: Dict[str, str] | None = None,
+) -> Dict[str, Any]:
+    """Get standardized httpx client configuration.
+
+    Args:
+        headers: Optional headers to merge with platform headers (e.g. licensing).
+            Caller headers take priority on key conflicts.
+    """
+    client_kwargs: Dict[str, Any] = {"follow_redirects": True, "timeout": 30.0}
+
+    ca_bundle = get_ca_bundle_path()
+    client_kwargs["verify"] = create_ssl_context(ca_bundle) if ca_bundle else False
+
+    from ._config import UiPathConfig
+    from .constants import HEADER_LICENSING_CONTEXT
+
+    merged_headers: Dict[str, str] = {}
+    licensing_context = UiPathConfig.licensing_context
+    if licensing_context:
+        merged_headers[HEADER_LICENSING_CONTEXT] = licensing_context
+    if headers:
+        merged_headers.update(headers)
+    if merged_headers:
+        client_kwargs["headers"] = merged_headers
+
+    return client_kwargs
diff --git a/packages/uipath-platform/src/uipath/platform/common/_job_context.py b/packages/uipath-platform/src/uipath/platform/common/_job_context.py
new file mode 100644
index 000000000..ccbd99f22
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_job_context.py
@@ -0,0 +1,13 @@
+from ._config import UiPathConfig
+from .constants import HEADER_JOB_KEY
+
+
+def header_job_key() -> dict[str, str]:
+    """Return the X-UiPath-JobKey header when the orchestrator job key is set.
+
+    Returns an empty dict when ``UiPathConfig.job_key`` is unset or empty.
+    """
+    job_key = UiPathConfig.job_key
+    if not job_key:
+        return {}
+    return {HEADER_JOB_KEY: job_key}
diff --git a/packages/uipath-platform/src/uipath/platform/common/_models.py b/packages/uipath-platform/src/uipath/platform/common/_models.py
new file mode 100644
index 000000000..60a79b8c6
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_models.py
@@ -0,0 +1,100 @@
+from dataclasses import dataclass, field
+from typing import Any, Optional, Union
+
+
+class Endpoint(str):
+    """A string subclass representing a normalized API endpoint path.
+
+    This class ensures consistent endpoint formatting by:
+    - Adding a leading slash if missing
+    - Removing trailing slashes (except for root '/')
+    - Stripping query parameters
+
+    The class supports string formatting for dynamic path parameters.
+
+    Examples:
+        >>> endpoint = Endpoint("/api/v1/users/{id}")
+        >>> endpoint.format(id=123)
+        '/api/v1/users/123'
+
+        >>> endpoint = Endpoint("projects")
+        >>> str(endpoint)
+        '/projects'
+
+    Args:
+        endpoint (str): The endpoint path to normalize. May include format placeholders
+            for dynamic values (e.g. "/users/{id}").
+
+    Raises:
+        ValueError: If format() is called with None or empty string arguments.
+    """
+
+    def __new__(cls, endpoint: str) -> "Endpoint":
+        if not endpoint.startswith("/"):
+            endpoint = f"/{endpoint}"
+
+        if endpoint != "/" and endpoint.endswith("/"):
+            endpoint = endpoint[:-1]
+
+        endpoint = endpoint.split("?")[0]
+
+        return super().__new__(cls, endpoint)
+
+    def format(self, *args: Any, **kwargs: Any) -> str:
+        """Formats the endpoint with the given arguments."""
+        for index, arg in enumerate(args):
+            if not self._is_valid_value(arg):
+                raise ValueError(f"Positional argument `{index}` is `{arg}`.")
+
+        for key, value in kwargs.items():
+            if not self._is_valid_value(value):
+                raise ValueError(f"Keyword argument `{key}` is `{value}`.")
+
+        return super().format(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return f"Endpoint({super().__str__()!r})"
+
+    def _is_valid_value(self, value: Any) -> bool:
+        return value is not None and value != ""
+
+    @property
+    def service(self) -> str:
+        """Extracts and returns the service name from the endpoint path.
+
+        The service name is expected to be the first path segment after the leading slash,
+        with any underscores removed.
+
+        Examples:
+            >>> endpoint = Endpoint("/cloud_/projects")
+            >>> endpoint.service
+            'cloud'
+
+            >>> endpoint = Endpoint("/automation_hub_/assets")
+            >>> endpoint.service
+            'automationhub'
+
+        Returns:
+            str: The service name with underscores removed.
+        """
+        return self.split("/")[1].replace("_", "")
+
+
+@dataclass
+class RequestSpec:
+    """Encapsulates the configuration for making an HTTP request.
+
+    This class contains all necessary parameters to construct and send an HTTP request,
+    including the HTTP method, endpoint, query parameters, headers, and various forms
+    of request body data (content, JSON, form data).
+    """
+
+    method: str
+    endpoint: Endpoint
+    params: dict[str, Any] = field(default_factory=dict)
+    headers: dict[str, Any] = field(default_factory=dict)
+    content: Optional[Any] = None
+    json: Optional[Any] = None
+    data: Optional[Any] = None
+    files: Optional[dict[str, Any]] = None
+    timeout: Optional[Union[int, float]] = None
diff --git a/packages/uipath-platform/src/uipath/platform/common/_service_url_overrides.py b/packages/uipath-platform/src/uipath/platform/common/_service_url_overrides.py
new file mode 100644
index 000000000..f0a56318d
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_service_url_overrides.py
@@ -0,0 +1,64 @@
+"""Per-service URL overrides for local development.
+
+Set UIPATH_SERVICE_URL_<SERVICE>=http://localhost:<port> to redirect
+requests for a specific service to a local server. The service name
+is derived from the endpoint prefix (e.g., agenthub_ -> AGENTHUB).
+
+The local server receives only the API path — org/tenant prefix and
+service prefix are stripped.
+
+When an override is active, routing headers (X-UiPath-Internal-TenantId,
+X-UiPath-Internal-AccountId) are injected since the platform routing
+layer is bypassed.
+"""
+
+import os
+
+from ._config import UiPathConfig
+
+
+def resolve_service_url(endpoint_path: str) -> str | None:
+    """Resolve a service URL override for the given endpoint path.
+
+    Args:
+        endpoint_path: Endpoint path with service prefix,
+            e.g. "agenthub_/llm/api/chat/completions" or
+            "/orchestrator_/odata/Buckets".
+
+    Returns:
+        Override URL with the API path appended, or None if no override is set.
+    """
+    path = endpoint_path.lstrip("/")
+    if not path:
+        return None
+
+    first_segment = path.split("/")[0]
+    if "_" not in first_segment:
+        return None
+
+    service_name = first_segment.replace("_", "").upper()
+    override_base = os.getenv(f"UIPATH_SERVICE_URL_{service_name}")
+    if not override_base:
+        return None
+
+    remaining = path[len(first_segment) :]
+    return f"{override_base.rstrip('/')}{remaining}"
+
+
+def inject_routing_headers(headers: dict[str, str]) -> None:
+    """Add routing headers bypassed when using a local service override.
+
+    The platform routing layer normally injects tenant and account
+    identifiers. When going direct to a local service, these must
+    be sent explicitly.
+
+    Args:
+        headers: Mutable headers dict to update in place.
+    """
+    tenant_id = UiPathConfig.tenant_id
+    if tenant_id:
+        headers["X-UiPath-Internal-TenantId"] = tenant_id
+
+    organization_id = UiPathConfig.organization_id
+    if organization_id:
+        headers["X-UiPath-Internal-AccountId"] = organization_id
diff --git a/packages/uipath-platform/src/uipath/platform/common/_span_utils.py b/packages/uipath-platform/src/uipath/platform/common/_span_utils.py
new file mode 100644
index 000000000..954fbc038
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/_span_utils.py
@@ -0,0 +1,467 @@
+import inspect
+import json
+import logging
+import os
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import IntEnum
+from functools import lru_cache
+from os import environ as env
+from typing import Any, Dict, List, Optional
+
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.trace import StatusCode
+from pydantic import BaseModel, ConfigDict, Field
+from uipath.core.serialization import serialize_json
+
+logger = logging.getLogger(__name__)
+
+# SourceEnum.CodedAgents = 10 (default for Python SDK / coded agents)
+DEFAULT_SOURCE = 10
+
+
+@lru_cache(maxsize=1)
+def _read_config_id() -> str | None:
+    """Return a valid GUID ``id`` from ``uipath.json``, cached for the process lifetime."""
+    from uipath.platform.common._config import UiPathConfig
+
+    try:
+        config_file = json.loads(UiPathConfig.config_file_path.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+
+    project_id = config_file.get("id")
+    if not isinstance(project_id, str):
+        logger.warning("'id' field not present in uipath.json")
+        return None
+
+    try:
+        uuid.UUID(project_id)
+    except ValueError:
+        logger.warning("Ignoring uipath.json 'id' %r: not a valid GUID.", project_id)
+        return None
+
+    return project_id
+
+
+def resolve_project_id() -> str | None:
+    """Resolve the project id.
+
+    Prefers ``uipath.json#id``, falls back to env vars.
+    """
+    from uipath.platform.common._config import UiPathConfig
+
+    return _read_config_id() or UiPathConfig.agent_id or UiPathConfig.project_key
+
+
+class AttachmentProvider(IntEnum):
+    ORCHESTRATOR = 0
+
+
+class AttachmentDirection(IntEnum):
+    NONE = 0
+    IN = 1
+    OUT = 2
+
+
+class VerbosityLevel(IntEnum):
+    VERBOSE = 0
+    TRACE = 1
+    INFORMATION = 2
+    WARNING = 3
+    ERROR = 4
+    CRITICAL = 5
+    OFF = 6
+
+
+class SpanAttachment(BaseModel):
+    """Represents an attachment in the UiPath tracing system."""
+
+    model_config = ConfigDict(populate_by_name=True, use_enum_values=True)
+
+    id: str = Field(..., alias="id")
+    file_name: str = Field(..., alias="fileName")
+    mime_type: str = Field(..., alias="mimeType")
+    provider: AttachmentProvider = Field(
+        default=AttachmentProvider.ORCHESTRATOR, alias="provider"
+    )
+    direction: AttachmentDirection = Field(
+        default=AttachmentDirection.NONE, alias="direction"
+    )
+
+
+@dataclass
+class UiPathSpan:
+    """Represents a span in the UiPath tracing system.
+
+    Note: attributes can be either a JSON string (backwards compatible) or a dict (optimized).
+    IDs are stored as OTEL hex strings (32 chars for trace_id, 16 chars for span_id/parent_id).
+    """
+
+    id: str  # 16-char hex (OTEL span ID format)
+    trace_id: str  # 32-char hex (OTEL trace ID format)
+    name: str
+    attributes: str | Dict[str, Any]  # Support both str (legacy) and dict (optimized)
+    parent_id: Optional[str] = None  # 16-char hex (OTEL span ID format)
+    start_time: str = field(default_factory=lambda: datetime.now().isoformat())
+    end_time: str = field(default_factory=lambda: datetime.now().isoformat())
+    status: int = 1
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
+    updated_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
+    organization_id: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_ORGANIZATION_ID", "")
+    )
+    tenant_id: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_TENANT_ID", "")
+    )
+    expiry_time_utc: Optional[str] = None
+    folder_key: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_FOLDER_KEY", "")
+    )
+    source: int = DEFAULT_SOURCE
+    span_type: str = "Coded Agents"
+    process_key: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_PROCESS_UUID")
+    )
+    reference_id: Optional[str] = field(
+        default_factory=lambda: env.get("TRACE_REFERENCE_ID")
+    )
+
+    job_key: Optional[str] = field(default_factory=lambda: env.get("UIPATH_JOB_KEY"))
+
+    # Top-level fields for internal tracing schema
+    execution_type: Optional[int] = None
+    agent_version: Optional[str] = None
+    verbosity_level: Optional[int] = None
+    attachments: Optional[List[SpanAttachment]] = None
+
+    def to_dict(self, serialize_attributes: bool = True) -> Dict[str, Any]:
+        """Convert the Span to a dictionary suitable for JSON serialization.
+
+        Args:
+            serialize_attributes: If True and attributes is a dict, serialize to JSON string.
+                                 If False, keep attributes as-is (dict or str).
+                                 Default True for backwards compatibility.
+        """
+        attributes_out = self.attributes
+        if serialize_attributes and isinstance(self.attributes, dict):
+            attributes_out = json.dumps(self.attributes)
+
+        attachments_out = None
+        if self.attachments is not None:
+            attachments_out = [
+                {
+                    "Id": att.id,
+                    "FileName": att.file_name,
+                    "MimeType": att.mime_type,
+                    "Provider": int(att.provider),
+                    "Direction": int(att.direction),
+                }
+                for att in self.attachments
+            ]
+
+        result: Dict[str, Any] = {
+            "Id": self.id,
+            "TraceId": self.trace_id,
+            "ParentId": self.parent_id,
+            "Name": self.name,
+            "StartTime": self.start_time,
+            "EndTime": self.end_time,
+            "Attributes": attributes_out,
+            "Status": self.status,
+            "CreatedAt": self.created_at,
+            "UpdatedAt": self.updated_at,
+            "OrganizationId": self.organization_id,
+            "TenantId": self.tenant_id,
+            "ExpiryTimeUtc": self.expiry_time_utc,
+            "FolderKey": self.folder_key,
+            "Source": self.source,
+            "SpanType": self.span_type,
+            "ProcessKey": self.process_key,
+            "JobKey": self.job_key,
+            "ReferenceId": self.reference_id,
+            "ExecutionType": self.execution_type,
+            "AgentVersion": self.agent_version,
+            "Attachments": attachments_out,
+        }
+        if self.verbosity_level is not None:
+            result["VerbosityLevel"] = self.verbosity_level
+        return result
+
+
+class _SpanUtils:
+    @staticmethod
+    def normalize_trace_id(value: str) -> str:
+        """Normalize trace ID to 32-char OTEL hex format.
+
+        Accepts both UUID format (with dashes) and OTEL hex format (32 chars).
+        Returns lowercase 32-char hex string.
+        """
+        # Remove dashes if UUID format
+        normalized = value.replace("-", "").lower()
+        if len(normalized) != 32:
+            raise ValueError(f"Invalid trace ID format: {value}")
+        return normalized
+
+    @staticmethod
+    def normalize_span_id(value: str) -> str:
+        """Normalize span ID to 16-char OTEL hex format.
+
+        Accepts both UUID format (with dashes, uses last 16 hex chars) and OTEL hex format (16 chars).
+        Returns lowercase 16-char hex string.
+        """
+        # Remove dashes if UUID format
+        normalized = value.replace("-", "").lower()
+        if len(normalized) == 32:
+            # UUID format - take last 16 chars (span ID portion)
+            return normalized[16:]
+        elif len(normalized) == 16:
+            return normalized
+        else:
+            raise ValueError(f"Invalid span ID format: {value}")
+
+    @staticmethod
+    def otel_span_to_uipath_span(
+        otel_span: ReadableSpan,
+        custom_trace_id: Optional[str] = None,
+        serialize_attributes: bool = True,
+    ) -> UiPathSpan:
+        """Convert an OpenTelemetry span to a UiPathSpan.
+
+        Args:
+            otel_span: The OpenTelemetry span to convert
+            custom_trace_id: Optional custom trace ID to use (UUID or OTEL hex format)
+            serialize_attributes: If True, serialize attributes to JSON string (backwards compatible).
+                                 If False, keep as dict for optimized processing. Default True.
+        """
+        # Extract the context information from the OTel span
+        span_context = otel_span.get_span_context()
+
+        # Convert to OTEL hex format (32 chars for trace_id, 16 chars for span_id)
+        trace_id = format(span_context.trace_id, "032x")
+        span_id = format(span_context.span_id, "016x")
+
+        # Override trace_id if custom or env var provided (supports both UUID and hex format)
+        trace_id_override = custom_trace_id or os.environ.get("UIPATH_TRACE_ID")
+        if trace_id_override:
+            trace_id = _SpanUtils.normalize_trace_id(trace_id_override)
+
+        # Get parent span ID if it exists
+        parent_id: Optional[str] = None
+        if otel_span.parent is not None:
+            parent_id = format(otel_span.parent.span_id, "016x")
+        else:
+            # Only set UIPATH_PARENT_SPAN_ID for root spans (spans without a parent)
+            parent_span_id_str = env.get("UIPATH_PARENT_SPAN_ID")
+            if parent_span_id_str:
+                parent_id = _SpanUtils.normalize_span_id(parent_span_id_str)
+
+        # Build attributes dict efficiently
+        # Use the otel attributes as base - we only add new keys, don't modify existing
+        otel_attrs = otel_span.attributes if otel_span.attributes else {}
+        # Only copy if we need to modify - we'll build attributes_dict lazily
+        attributes_dict: dict[str, Any] = dict(otel_attrs) if otel_attrs else {}
+
+        # Map status
+        status = 1  # Default to OK
+        if otel_span.status.status_code == StatusCode.ERROR:
+            status = 2  # Error
+            attributes_dict["error"] = otel_span.status.description
+
+        # Process inputs - avoid redundant parsing if already parsed
+        original_inputs = otel_attrs.get("input", None)
+        if original_inputs:
+            if isinstance(original_inputs, str):
+                try:
+                    attributes_dict["input.value"] = json.loads(original_inputs)
+                    attributes_dict["input.mime_type"] = "application/json"
+                except Exception:
+                    attributes_dict["input.value"] = original_inputs
+            else:
+                attributes_dict["input.value"] = original_inputs
+
+        # Process outputs - avoid redundant parsing if already parsed
+        original_outputs = otel_attrs.get("output", None)
+        if original_outputs:
+            if isinstance(original_outputs, str):
+                try:
+                    attributes_dict["output.value"] = json.loads(original_outputs)
+                    attributes_dict["output.mime_type"] = "application/json"
+                except Exception:
+                    attributes_dict["output.value"] = original_outputs
+            else:
+                attributes_dict["output.value"] = original_outputs
+
+        # Add events as additional attributes if they exist
+        if otel_span.events:
+            events_list = [
+                {
+                    "name": event.name,
+                    "timestamp": event.timestamp,
+                    "attributes": dict(event.attributes) if event.attributes else {},
+                }
+                for event in otel_span.events
+            ]
+            attributes_dict["events"] = events_list
+
+        # Add links as additional attributes if they exist
+        if hasattr(otel_span, "links") and otel_span.links:
+            links_list = [
+                {
+                    "trace_id": link.context.trace_id,
+                    "span_id": link.context.span_id,
+                    "attributes": dict(link.attributes) if link.attributes else {},
+                }
+                for link in otel_span.links
+            ]
+            attributes_dict["links"] = links_list
+
+        if agent_id := resolve_project_id():
+            attributes_dict["agentId"] = agent_id
+
+        # Add process context attributes from environment variables
+        for env_key, attr_key in (
+            ("UIPATH_PROCESS_KEY", "agentName"),
+            ("UIPATH_PROCESS_VERSION", "agentVersion"),
+        ):
+            value = env.get(env_key)
+            if value:
+                attributes_dict[attr_key] = value
+
+        span_type_value = attributes_dict.get("span_type", "OpenTelemetry")
+        span_type = str(span_type_value)
+
+        # Top-level fields for internal tracing schema
+        execution_type = attributes_dict.get("executionType")
+        agent_version = attributes_dict.get("agentVersion")
+        reference_id = attributes_dict.get("agentId") or attributes_dict.get(
+            "referenceId"
+        )
+        verbosity_level = attributes_dict.get("verbosityLevel")
+
+        # Source: override via uipath.source attribute, else DEFAULT_SOURCE
+        uipath_source = attributes_dict.get("uipath.source")
+        source = uipath_source if isinstance(uipath_source, int) else DEFAULT_SOURCE
+
+        attachments = None
+        attachments_data = attributes_dict.get("attachments")
+        if attachments_data:
+            try:
+                attachments_list = json.loads(attachments_data)
+                attachments = [
+                    SpanAttachment(
+                        id=att.get("id"),
+                        file_name=att.get("fileName", ""),
+                        mime_type=att.get("mimeType", ""),
+                        provider=att.get("provider", 0),
+                        direction=att.get("direction", 0),
+                    )
+                    for att in attachments_list
+                ]
+            except Exception as e:
+                logger.warning(f"Error processing attachments: {e}")
+
+        # Create UiPathSpan from OpenTelemetry span
+        start_time = datetime.fromtimestamp(
+            (otel_span.start_time or 0) / 1e9
+        ).isoformat()
+
+        end_time_str = None
+        if otel_span.end_time is not None:
+            end_time_str = datetime.fromtimestamp(
+                (otel_span.end_time or 0) / 1e9
+            ).isoformat()
+        else:
+            end_time_str = datetime.now().isoformat()
+
+        return UiPathSpan(
+            id=span_id,
+            trace_id=trace_id,
+            parent_id=parent_id,
+            name=otel_span.name,
+            attributes=json.dumps(attributes_dict)
+            if serialize_attributes
+            else attributes_dict,
+            start_time=start_time,
+            end_time=end_time_str,
+            status=status,
+            span_type=span_type,
+            execution_type=execution_type,
+            agent_version=agent_version,
+            verbosity_level=verbosity_level,
+            reference_id=reference_id,
+            source=source,
+            attachments=attachments,
+        )
+
+    @staticmethod
+    def format_object_for_trace_json(
+        input_object: Any,
+    ) -> str:
+        """Return a JSON string of inputs from the function signature."""
+        return serialize_json(input_object)
+
+    @staticmethod
+    def format_args_for_trace(
+        signature: inspect.Signature, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        try:
+            """Return a dictionary of inputs from the function signature."""
+            # Create a parameter mapping by partially binding the arguments
+
+            parameter_binding = signature.bind_partial(*args, **kwargs)
+
+            # Fill in default values for any unspecified parameters
+            parameter_binding.apply_defaults()
+
+            # Extract the input parameters, skipping special Python parameters
+            result = {}
+            for name, value in parameter_binding.arguments.items():
+                # Skip class and instance references
+                if name in ("self", "cls"):
+                    continue
+
+                # Handle **kwargs parameters specially
+                param_info = signature.parameters.get(name)
+                if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
+                    # Flatten nested kwargs directly into the result
+                    if isinstance(value, dict):
+                        result.update(value)
+                else:
+                    # Regular parameter
+                    result[name] = value
+
+            return result
+        except Exception as e:
+            logger.warning(
+                f"Error formatting arguments for trace: {e}. Using args and kwargs directly."
+            )
+            return {"args": args, "kwargs": kwargs}
+
+    @staticmethod
+    def spans_to_llm_context(spans: list[ReadableSpan]) -> str:
+        """Convert spans to a formatted conversation history string suitable for LLM context.
+
+        Includes function calls (including LLM calls) with their inputs and outputs.
+        """
+        history = []
+        for span in spans:
+            attributes = dict(span.attributes) if span.attributes else {}
+
+            input_value = attributes.get("input.value")
+            output_value = attributes.get("output.value")
+            telemetry_filter = attributes.get("telemetry.filter")
+
+            if not input_value or not output_value or telemetry_filter == "drop":
+                continue
+
+            history.append(f"Function: {span.name}")
+            history.append(f"Input: {input_value}")
+            history.append(f"Output: {output_value}")
+            history.append("")
+
+        if not history:
+            return "(empty)"
+
+        return "\n".join(history)
diff --git a/src/uipath/_utils/_url.py b/packages/uipath-platform/src/uipath/platform/common/_url.py
similarity index 100%
rename from src/uipath/_utils/_url.py
rename to packages/uipath-platform/src/uipath/platform/common/_url.py
diff --git a/src/uipath/_utils/_user_agent.py b/packages/uipath-platform/src/uipath/platform/common/_user_agent.py
similarity index 100%
rename from src/uipath/_utils/_user_agent.py
rename to packages/uipath-platform/src/uipath/platform/common/_user_agent.py
diff --git a/packages/uipath-platform/src/uipath/platform/common/auth.py b/packages/uipath-platform/src/uipath/platform/common/auth.py
new file mode 100644
index 000000000..885a0ef1b
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/auth.py
@@ -0,0 +1,37 @@
+"""Module defining the TokenData model for authentication tokens."""
+
+from os import environ as env
+from typing import Optional
+
+from pydantic import BaseModel
+
+from uipath.platform.common.constants import (
+    ENV_BASE_URL,
+    ENV_UIPATH_ACCESS_TOKEN,
+    ENV_UNATTENDED_USER_ACCESS_TOKEN,
+)
+
+
+class TokenData(BaseModel):
+    """Pydantic model for token data structure."""
+
+    access_token: str
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+    token_type: Optional[str] = None
+    scope: Optional[str] = None
+    id_token: Optional[str] = None
+
+
+def resolve_config_from_env(
+    base_url: Optional[str],
+    secret: Optional[str],
+):
+    """Simple config resolution from environment variables."""
+    base_url_value = base_url or env.get(ENV_BASE_URL)
+    secret_value = (
+        secret
+        or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
+        or env.get(ENV_UIPATH_ACCESS_TOKEN)
+    )
+    return base_url_value, secret_value
diff --git a/packages/uipath-platform/src/uipath/platform/common/constants.py b/packages/uipath-platform/src/uipath/platform/common/constants.py
new file mode 100644
index 000000000..304ef64a6
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/constants.py
@@ -0,0 +1,92 @@
+"""Constants."""
+
+# Environment variables
+DOTENV_FILE = ".env"
+ENV_BASE_URL = "UIPATH_URL"
+ENV_EVAL_BACKEND_URL = "UIPATH_EVAL_BACKEND_URL"
+ENV_UNATTENDED_USER_ACCESS_TOKEN = "UNATTENDED_USER_ACCESS_TOKEN"
+ENV_UIPATH_ACCESS_TOKEN = "UIPATH_ACCESS_TOKEN"
+ENV_FOLDER_KEY = "UIPATH_FOLDER_KEY"
+ENV_FOLDER_PATH = "UIPATH_FOLDER_PATH"
+ENV_JOB_KEY = "UIPATH_JOB_KEY"
+ENV_JOB_ID = "UIPATH_JOB_ID"
+ENV_ROBOT_KEY = "UIPATH_ROBOT_KEY"
+ENV_TENANT_ID = "UIPATH_TENANT_ID"
+ENV_TENANT_NAME = "UIPATH_TENANT_NAME"
+ENV_ORGANIZATION_ID = "UIPATH_ORGANIZATION_ID"
+ENV_TELEMETRY_ENABLED = "UIPATH_TELEMETRY_ENABLED"
+ENV_TRACING_ENABLED = "UIPATH_TRACING_ENABLED"
+ENV_UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
+ENV_UIPATH_AGENT_ID = "UIPATH_AGENT_ID"
+ENV_UIPATH_CLOUD_USER_ID = "UIPATH_CLOUD_USER_ID"
+ENV_UIPATH_PROJECT_FILES_SOURCE = "UIPATH_PROJECT_FILES_SOURCE"
+ENV_PROJECT_KEY = "PROJECT_KEY"
+ENV_PROCESS_KEY = "UIPATH_PROCESS_KEY"
+ENV_UIPATH_PROCESS_UUID = "UIPATH_PROCESS_UUID"
+ENV_UIPATH_TRACE_ID = "UIPATH_TRACE_ID"
+ENV_UIPATH_PROCESS_VERSION = "UIPATH_PROCESS_VERSION"
+ENV_UIPATH_CONFIG_PATH = "UIPATH_CONFIG_PATH"
+
+# Headers
+HEADER_FOLDER_KEY = "x-uipath-folderkey"
+HEADER_FOLDER_PATH = "x-uipath-folderpath"
+HEADER_FOLDER_PATH_ENCODED = "x-uipath-folderpath-encoded"
+HEADER_USER_AGENT = "x-uipath-user-agent"
+HEADER_TENANT_ID = "x-uipath-tenantid"
+HEADER_INTERNAL_TENANT_ID = "x-uipath-internal-tenantid"
+HEADER_INTERNAL_ACCOUNT_ID = "x-uipath-internal-accountid"
+HEADER_JOB_KEY = "x-uipath-jobkey"
+HEADER_PROCESS_KEY = "x-uipath-processkey"
+HEADER_TRACE_ID = "x-uipath-traceid"
+HEADER_AGENTHUB_CONFIG = "x-uipath-agenthub-config"
+HEADER_LLMGATEWAY_BYO_CONNECTION_ID = "x-uipath-llmgateway-byoisconnectionid"
+HEADER_SW_LOCK_KEY = "x-uipath-sw-lockkey"
+HEADER_LICENSING_CONTEXT = "x-uipath-licensing-context"
+
+# Data sources (request types)
+ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
+)
+CONFLUENCE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSourceRequest"
+)
+DROPBOX_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSourceRequest"
+)
+GOOGLE_DRIVE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSourceRequest"
+)
+ONEDRIVE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSourceRequest"
+)
+
+# Data sources
+ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSource"
+)
+CONFLUENCE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSource"
+DROPBOX_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSource"
+GOOGLE_DRIVE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSource"
+ONEDRIVE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSource"
+
+
+# Local storage
+TEMP_ATTACHMENTS_FOLDER = "uipath_attachments"
+
+# LLM models
+COMMUNITY_agents_SUFFIX = "-community-agents"
+
+# File names
+PYTHON_CONFIGURATION_FILE = "pyproject.toml"
+UIPATH_CONFIG_FILE = "uipath.json"
+UIPATH_BINDINGS_FILE = "bindings.json"
+ENTRY_POINTS_FILE = "entry-points.json"
+STUDIO_METADATA_FILE = "studio_metadata.json"
+UIPROJ_FILE = "project.uiproj"
+
+
+# Folder names
+LEGACY_EVAL_FOLDER = "evals"
+EVALS_FOLDER = "evaluations"
+# Evaluators
+CUSTOM_EVALUATOR_PREFIX = "file://"
diff --git a/packages/uipath-platform/src/uipath/platform/common/dynamic_schema.py b/packages/uipath-platform/src/uipath/platform/common/dynamic_schema.py
new file mode 100644
index 000000000..c07f94198
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/dynamic_schema.py
@@ -0,0 +1,128 @@
+"""Json schema to dynamic pydantic model."""
+
+from enum import Enum
+from typing import Any, Type, Union
+
+from pydantic import BaseModel, Field, create_model
+
+
+def jsonschema_to_pydantic(
+    schema: dict[str, Any],
+) -> Type[BaseModel]:
+    """Convert a schema dict to a pydantic model.
+
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for three unresolved issues.
+      1. Support for title
+      2. Better representation of optionals.
+      3. Support for optional
+
+    Args:
+        schema: JSON schema.
+        definitions: Definitions dict. Defaults to `$def`.
+
+    Returns: Pydantic model.
+    """
+    dynamic_type_counter = 0
+    combined_model_counter = 0
+
+    def convert_type(prop: dict[str, Any]) -> Any:
+        nonlocal dynamic_type_counter, combined_model_counter
+        if "$ref" in prop:
+            # This is the full path. It will be updated in update_forward_refs.
+            return prop["$ref"].split("/")[-1].capitalize()
+
+        if "type" in prop:
+            type_mapping = {
+                "string": str,
+                "number": float,
+                "integer": int,
+                "boolean": bool,
+                "array": list,
+                "object": dict,
+                "null": None,
+            }
+
+            type_ = prop["type"]
+
+            if "enum" in prop:
+                dynamic_members = {
+                    f"KEY_{i}": value for i, value in enumerate(prop["enum"])
+                }
+
+                base_type: Any = type_mapping.get(type_, Any)
+
+                class DynamicEnum(base_type, Enum):
+                    pass
+
+                type_ = DynamicEnum(prop.get("title", "DynamicEnum"), dynamic_members)  # type: ignore[call-arg] # explicit ignore
+                return type_
+            elif type_ == "array":
+                item_type: Any = convert_type(prop.get("items", {}))
+                return list[item_type]  # noqa F821
+            elif type_ == "object":
+                if "properties" in prop:
+                    if "title" in prop and prop["title"]:
+                        title = prop["title"]
+                    else:
+                        title = f"DynamicType_{dynamic_type_counter}"
+                        dynamic_type_counter += 1
+
+                    fields: dict[str, Any] = {}
+                    required_fields = prop.get("required", [])
+
+                    for name, property in prop.get("properties", {}).items():
+                        pydantic_type = convert_type(property)
+                        field_kwargs = {}
+                        if "default" in property:
+                            field_kwargs["default"] = property["default"]
+                        if name not in required_fields:
+                            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
+                            # If we convert the Optional type back to json schema, it is represented as type | None.
+                            # pydantic_type = Optional[pydantic_type]
+
+                            if "default" not in field_kwargs:
+                                field_kwargs["default"] = None
+                        if "description" in property:
+                            field_kwargs["description"] = property["description"]
+                        if "title" in property:
+                            field_kwargs["title"] = property["title"]
+
+                        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+                    object_model = create_model(title, **fields)
+                    if "description" in prop:
+                        object_model.__doc__ = prop["description"]
+                    return object_model
+                else:
+                    return dict[str, Any]
+            else:
+                return type_mapping.get(type_, Any)
+
+        elif "allOf" in prop:
+            combined_fields = {}
+            for sub_schema in prop["allOf"]:
+                model = convert_type(sub_schema)
+                combined_fields.update(model.__annotations__)
+            combined_model = create_model(
+                f"CombinedModel_{combined_model_counter}", **combined_fields
+            )
+            combined_model_counter += 1
+            return combined_model
+
+        elif "anyOf" in prop:
+            unioned_types = tuple(
+                convert_type(sub_schema) for sub_schema in prop["anyOf"]
+            )
+            return Union[unioned_types]
+        elif prop == {} or "type" not in prop:
+            return Any
+        else:
+            raise ValueError(f"Unsupported schema: {prop}")
+
+    namespace: dict[str, Any] = {}
+    for name, definition in schema.get("$defs", schema.get("definitions", {})).items():
+        model = convert_type(definition)
+        namespace[name.capitalize()] = model
+    model = convert_type(schema)
+    model.model_rebuild(force=True, _types_namespace=namespace)
+    return model
diff --git a/packages/uipath-platform/src/uipath/platform/common/interrupt_models.py b/packages/uipath-platform/src/uipath/platform/common/interrupt_models.py
new file mode 100644
index 000000000..3b2468551
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/interrupt_models.py
@@ -0,0 +1,281 @@
+"""Models for interrupt operations in UiPath platform."""
+
+from typing import Annotated, Any
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from uipath.platform.context_grounding.context_grounding_index import (
+    ContextGroundingIndex,
+)
+
+from ..action_center.tasks import Task, TaskRecipient
+from ..attachments import Attachment
+from ..context_grounding import (
+    BatchTransformCreationResponse,
+    BatchTransformOutputColumn,
+    CitationMode,
+    DeepRagCreationResponse,
+    EphemeralIndexUsage,
+)
+from ..documents import (
+    ActionPriority,
+    ExtractionResponseIXP,
+    FileContent,
+    StartExtractionResponse,
+)
+from ..documents.documents import StartExtractionValidationResponse
+from ..orchestrator.job import Job
+
+
+class InvokeProcess(BaseModel):
+    """Model representing a process invocation."""
+
+    name: str
+    process_folder_path: str | None = None
+    process_folder_key: str | None = None
+    input_arguments: dict[str, Any] | None
+    attachments: list[Attachment] | None = None
+
+
+class WaitJob(BaseModel):
+    """Model representing a wait job operation."""
+
+    job: Job
+    process_folder_path: str | None = None
+    process_folder_key: str | None = None
+
+
+class InvokeProcessRaw(InvokeProcess):
+    """Model representing a raw process invocation (returns job without state validation)."""
+
+    pass
+
+
+class WaitJobRaw(WaitJob):
+    """Model representing a raw wait job operation (returns job without state validation)."""
+
+    pass
+
+
+class CreateTask(BaseModel):
+    """Model representing an action creation."""
+
+    title: str
+    data: dict[str, Any] | None = None
+    assignee: str | None = ""
+    recipient: TaskRecipient | None = None
+    app_name: str | None = None
+    app_folder_path: str | None = None
+    app_folder_key: str | None = None
+    app_key: str | None = None
+    priority: str | None = None
+    labels: list[str] | None = None
+    is_actionable_message_enabled: bool | None = None
+    actionable_message_metadata: dict[str, Any] | None = None
+    source_name: str = "Agent"
+
+
+class CreateEscalation(CreateTask):
+    """Model representing an escalation creation."""
+
+    pass
+
+
+class WaitTask(BaseModel):
+    """Model representing a wait action operation."""
+
+    action: Task
+    app_folder_path: str | None = None
+    app_folder_key: str | None = None
+    app_name: str | None = None
+    recipient: TaskRecipient | None = None
+
+
+class WaitEscalation(WaitTask):
+    """Model representing a wait escalation operation."""
+
+    pass
+
+
+class CreateDeepRag(BaseModel):
+    """Model representing a Deep RAG task creation."""
+
+    name: str
+    index_name: Annotated[str, Field(max_length=512)] | None = None
+    index_id: Annotated[str, Field(max_length=512)] | None = None
+    prompt: Annotated[str, Field(max_length=250000)]
+    glob_pattern: Annotated[str, Field(max_length=512, default="*")] = "**"
+    citation_mode: CitationMode = CitationMode.SKIP
+    index_folder_key: str | None = None
+    index_folder_path: str | None = None
+    is_ephemeral_index: bool | None = None
+
+    @model_validator(mode="after")
+    def validate_ephemeral_index_requires_index_id(self) -> "CreateDeepRag":
+        """Validate that if it is an ephemeral index that it is using index id."""
+        if self.is_ephemeral_index is True and self.index_id is None:
+            raise ValueError("Index id must be provided for an ephemeral index")
+        return self
+
+
+class CreateDeepRagRaw(CreateDeepRag):
+    """Model representing a Deep RAG task creation (returns the deep_rag without status validation)."""
+
+    pass
+
+
+class WaitDeepRag(BaseModel):
+    """Model representing a wait Deep RAG task."""
+
+    deep_rag: DeepRagCreationResponse
+    index_folder_path: str | None = None
+    index_folder_key: str | None = None
+
+
+class WaitDeepRagRaw(WaitDeepRag):
+    """Model representing a wait Deep RAG task (returns the deep_rag without status validation)."""
+
+    pass
+
+
+class CreateEphemeralIndex(BaseModel):
+    """Model representing an Ephemeral Index task creation."""
+
+    usage: EphemeralIndexUsage
+    attachments: list[str]
+
+
+class CreateEphemeralIndexRaw(CreateEphemeralIndex):
+    """Model representing an Ephemeral Index task creation (returns the ephemeral index without status validation)."""
+
+    pass
+
+
+class WaitEphemeralIndex(BaseModel):
+    """Model representing a wait Ephemeral Index task."""
+
+    index: ContextGroundingIndex
+
+
+class WaitEphemeralIndexRaw(WaitEphemeralIndex):
+    """Model representing a wait Ephemeral Index task (returns the ephemeral index without status validation)."""
+
+    pass
+
+
+class CreateBatchTransform(BaseModel):
+    """Model representing a Batch Transform task creation."""
+
+    name: str
+    index_name: str | None = None
+    index_id: Annotated[str, Field(max_length=512)] | None = None
+    prompt: Annotated[str, Field(max_length=250000)]
+    output_columns: list[BatchTransformOutputColumn]
+    storage_bucket_folder_path_prefix: Annotated[str | None, Field(max_length=512)] = (
+        None
+    )
+    enable_web_search_grounding: bool = False
+    destination_path: str
+    index_folder_key: str | None = None
+    index_folder_path: str | None = None
+    is_ephemeral_index: bool | None = None
+
+    @model_validator(mode="after")
+    def validate_ephemeral_index_requires_index_id(self) -> "CreateBatchTransform":
+        """Validate that if it is an ephemeral index that it is using index id."""
+        if self.is_ephemeral_index is True and self.index_id is None:
+            raise ValueError("Index id must be provided for an ephemeral index")
+        return self
+
+
+class WaitBatchTransform(BaseModel):
+    """Model representing a wait Batch Transform task."""
+
+    batch_transform: BatchTransformCreationResponse
+    index_folder_path: str | None = None
+    index_folder_key: str | None = None
+
+
+class InvokeSystemAgent(BaseModel):
+    """Model representing a system agent job invocation."""
+
+    agent_name: str
+    entrypoint: str
+    input_arguments: dict[str, Any] | None = None
+    folder_path: str | None = None
+    folder_key: str | None = None
+
+
+class WaitSystemAgent(BaseModel):
+    """Model representing a wait system agent job invocation."""
+
+    job_key: str
+    process_folder_path: str | None = None
+    process_folder_key: str | None = None
+
+
+class DocumentExtraction(BaseModel):
+    """Model representing a document extraction task creation."""
+
+    project_name: str
+    tag: str
+    file: FileContent | None = None
+    file_path: str | None = None
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @model_validator(mode="after")
+    def validate_exactly_one_file_source(self) -> "DocumentExtraction":
+        """Validate that exactly one of file or file_path is provided."""
+        if (self.file is None) == (self.file_path is None):
+            raise ValueError(
+                "Exactly one of 'file' or 'file_path' must be provided, not both or neither"
+            )
+        return self
+
+
+class WaitDocumentExtraction(BaseModel):
+    """Model representing a wait document extraction task creation."""
+
+    extraction: StartExtractionResponse
+
+
+class DocumentExtractionValidation(BaseModel):
+    """Model representing a document extraction task creation."""
+
+    extraction_response: ExtractionResponseIXP
+    action_title: str
+    action_catalog: str | None = None
+    action_priority: ActionPriority | None = None
+    action_folder: str | None = None
+    storage_bucket_name: str | None = None
+    storage_bucket_directory_path: str | None = None
+
+
+class WaitDocumentExtractionValidation(BaseModel):
+    """Model representing a wait document extraction task creation."""
+
+    extraction_validation: StartExtractionValidationResponse
+    task_url: str | None = None
+
+
+class WaitIntegrationEvent(BaseModel):
+    """Model representing a wait on an Integration Services event.
+
+    Used to suspend a job until a remote event (e.g. Slack message, Teams reply)
+    is delivered by Integration Services. The SDK resolves `connection_name`
+    (scoped to `connection_folder_path` when provided) to the underlying
+    connection id and generates a fresh `inbox_id` when the trigger is created;
+    the rest of the fields describe which remote event to subscribe to via
+    the Connections service.
+    """
+
+    connector: str
+    connection_name: str
+    connection_folder_path: str | None = None
+    operation: str
+    object_name: str
+    filter_expression: str | None = None
+    parameters: dict[str, str] | None = None
diff --git a/packages/uipath-platform/src/uipath/platform/common/paging.py b/packages/uipath-platform/src/uipath/platform/common/paging.py
new file mode 100644
index 000000000..5fe41d0cc
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/paging.py
@@ -0,0 +1,63 @@
+"""Pagination result types for UiPath SDK."""
+
+from dataclasses import dataclass
+from typing import Generic, Iterator, List, Optional, TypeVar
+
+__all__ = ["PagedResult"]
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class PagedResult(Generic[T]):
+    """Container for a single page of results from a paginated API.
+
+    Attributes:
+        items: The list of items in this page
+        continuation_token: Token to fetch next page (REST APIs)
+        has_more: Whether more results likely exist (OData APIs)
+        skip: Number of items skipped (OData APIs)
+        top: Maximum items requested (OData APIs)
+
+    Example:
+        # Offset-based pagination (OData)
+        skip = 0
+        while True:
+            result = sdk.buckets.list(skip=skip, top=100)
+            for bucket in result.items:
+                process(bucket)
+            if not result.has_more:
+                break
+            skip += 100
+
+        # Cursor-based pagination (REST)
+        token = None
+        while True:
+            result = sdk.buckets.list_files(
+                name="my-storage",
+                continuation_token=token
+            )
+            for file in result.items:
+                process(file)
+            if not result.continuation_token:
+                break
+            token = result.continuation_token
+    """
+
+    items: List[T]
+    continuation_token: Optional[str] = None
+    has_more: Optional[bool] = None
+    skip: Optional[int] = None
+    top: Optional[int] = None
+
+    def __iter__(self) -> Iterator[T]:
+        """Allow iteration over items directly."""
+        return iter(self.items)
+
+    def __len__(self) -> int:
+        """Return the number of items in this page."""
+        return len(self.items)
+
+    def __bool__(self) -> bool:
+        """Return True if page contains items."""
+        return bool(self.items)
diff --git a/packages/uipath-platform/src/uipath/platform/common/retry.py b/packages/uipath-platform/src/uipath/platform/common/retry.py
new file mode 100644
index 000000000..ff4b5a064
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/retry.py
@@ -0,0 +1,94 @@
+"""Retry utilities for UiPath platform HTTP requests.
+
+Provides generic, reusable retry helpers (status codes, header parsing, backoff)
+and platform-specific retry strategy for BaseService.
+"""
+
+import random
+
+from httpx import ConnectTimeout, HTTPStatusError, Response, TimeoutException
+from tenacity import RetryCallState
+
+from ..errors import EnrichedException
+
+RETRYABLE_STATUS_CODES: frozenset[int] = frozenset({408, 429, 502, 503, 504, 524})
+NON_RETRYABLE_STATUS_CODES: frozenset[int] = frozenset({400, 401, 403, 404, 413, 422})
+
+
+def parse_retry_after(header_value: str) -> float | None:
+    """Parse a numeric Retry-After header value.
+
+    Only handles numeric durations (seconds). HTTP-date values return None.
+    Negative values return None.
+    """
+    try:
+        seconds = float(header_value.strip())
+        if seconds < 0:
+            return None
+        return seconds
+    except (ValueError, AttributeError):
+        return None
+
+
+def exponential_backoff_with_jitter(attempt: int, initial: float) -> float:
+    """Calculate exponential backoff with jitter.
+
+    Returns ``initial * 2^(attempt-1) + uniform(0, 1.0)``.
+    """
+    exponent = attempt - 1
+    exponential = initial * (2**exponent)
+    jitter = random.uniform(0, 1.0)
+    return exponential + jitter
+
+
+def extract_retry_after_from_chain(exception: BaseException) -> float | None:
+    """Walk the exception __cause__ chain looking for a Retry-After header.
+
+    Supports ``HTTPStatusError`` (has ``.response.headers``) and
+    ``EnrichedException`` whose ``__cause__`` is an ``HTTPStatusError``.
+    """
+    current: BaseException | None = exception
+    while current is not None:
+        if isinstance(current, HTTPStatusError):
+            header = current.response.headers.get("retry-after")
+            if header:
+                parsed = parse_retry_after(header)
+                if parsed is not None:
+                    return parsed
+        current = current.__cause__
+    return None
+
+
+MAX_RETRY_ATTEMPTS: int = 5
+_MAX_RETRY_AFTER_DELAY: float = 120.0
+_MAX_BACKOFF_DELAY: float = 10.0
+_INITIAL_BACKOFF: float = 1.0
+
+
+def is_retryable_platform_exception(exception: BaseException) -> bool:
+    """Return True if the exception is transient and should be retried."""
+    if isinstance(exception, (ConnectTimeout, TimeoutException)):
+        return True
+    if isinstance(exception, EnrichedException):
+        return exception.status_code in RETRYABLE_STATUS_CODES
+    return False
+
+
+def is_retryable_response(response: Response) -> bool:
+    """Return True if the response has a server error status code (5xx)."""
+    return 500 <= response.status_code < 600
+
+
+def platform_wait_strategy(retry_state: RetryCallState) -> float:
+    """Wait strategy that honors Retry-After, falling back to exponential backoff."""
+    if retry_state.outcome is not None:
+        exception = retry_state.outcome.exception()
+        if exception is not None:
+            retry_after = extract_retry_after_from_chain(exception)
+            if retry_after is not None:
+                return min(retry_after, _MAX_RETRY_AFTER_DELAY)
+
+    backoff = exponential_backoff_with_jitter(
+        retry_state.attempt_number, _INITIAL_BACKOFF
+    )
+    return min(backoff, _MAX_BACKOFF_DELAY)
diff --git a/packages/uipath-platform/src/uipath/platform/common/validation.py b/packages/uipath-platform/src/uipath/platform/common/validation.py
new file mode 100644
index 000000000..2fa2b111c
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/common/validation.py
@@ -0,0 +1,43 @@
+"""Validation utilities for SDK services."""
+
+
+def validate_pagination_params(
+    skip: int,
+    top: int,
+    max_skip: int = 10000,
+    max_top: int = 1000,
+) -> None:
+    """Validate pagination parameters for OData queries.
+
+    This validator is used across multiple services (BucketsService, JobsService, etc.)
+    to ensure consistent pagination behavior.
+
+    Args:
+        skip: Number of items to skip (must be >= 0 and <= max_skip)
+        top: Maximum items per page (must be >= 1 and <= max_top)
+        max_skip: Maximum allowed skip value (default: 10000)
+        max_top: Maximum allowed top value (default: 1000)
+
+    Raises:
+        ValueError: If parameters are invalid
+
+    Examples:
+        >>> validate_pagination_params(skip=0, top=100)
+        >>> validate_pagination_params(skip=5000, top=500)
+        >>> validate_pagination_params(skip=-1, top=100)  # Raises ValueError
+        >>> validate_pagination_params(skip=0, top=2000)  # Raises ValueError
+    """
+    if skip < 0:
+        raise ValueError("skip must be >= 0")
+    if skip > max_skip:
+        raise ValueError(
+            f"skip must be <= {max_skip} (requested: {skip}). "
+            f"Use filters to narrow results or manual pagination."
+        )
+    if top < 1:
+        raise ValueError("top must be >= 1")
+    if top > max_top:
+        raise ValueError(
+            f"top must be <= {max_top} (requested: {top}). "
+            f"Use pagination with skip and top parameters."
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/connections/__init__.py b/packages/uipath-platform/src/uipath/platform/connections/__init__.py
new file mode 100644
index 000000000..2a29b94ae
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/connections/__init__.py
@@ -0,0 +1,26 @@
+"""UiPath Connections Models.
+
+This module contains models related to UiPath Connections service.
+"""
+
+from ._connections_service import ConnectionsService
+from .connections import (
+    ActivityMetadata,
+    ActivityParameterLocationInfo,
+    Connection,
+    ConnectionMetadata,
+    ConnectionToken,
+    ConnectionTokenType,
+    EventArguments,
+)
+
+__all__ = [
+    "ConnectionsService",
+    "ActivityMetadata",
+    "ActivityParameterLocationInfo",
+    "Connection",
+    "ConnectionMetadata",
+    "ConnectionToken",
+    "ConnectionTokenType",
+    "EventArguments",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/connections/_connections_service.py b/packages/uipath-platform/src/uipath/platform/connections/_connections_service.py
new file mode 100644
index 000000000..b7c1e9444
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/connections/_connections_service.py
@@ -0,0 +1,838 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional
+from urllib.parse import parse_qsl, quote, urlsplit
+
+from httpx import Response
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig, UiPathConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator._folder_service import FolderService
+from .connections import (
+    ActivityMetadata,
+    Connection,
+    ConnectionMetadata,
+    ConnectionToken,
+    ConnectionTokenType,
+    EventArguments,
+)
+
+logger: logging.Logger = logging.getLogger("uipath")
+
+HEADER_ORIGINATOR = "x-uipath-originator"
+HEADER_SOURCE = "x-uipath-source"
+# Sent on outbound Integration Service activity invocations so GenAI activities
+# can be stitched back to the parent job for licensing attribution.
+HEADER_ACTIVITY_JOB_ID = "x-uipath-job-id"
+_ORIGINATOR_VALUE = "uipath-python"
+
+
+class ConnectionsService(BaseService):
+    """Service for managing UiPath external service connections.
+
+    This service provides methods to retrieve direct connection information retrieval
+    and secure token management.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: FolderService,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    @resource_override("connection", resource_identifier="key")
+    @traced(
+        name="connections_retrieve",
+        run_type="uipath",
+        hide_output=True,
+    )
+    def retrieve(self, key: str) -> Connection:
+        """Retrieve connection details by its key.
+
+        This method fetches the configuration and metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            key (str): The unique identifier of the connection to retrieve.
+
+        Returns:
+            Connection: The connection details, including configuration parameters
+                and authentication information.
+        """
+        spec = self._retrieve_spec(key)
+        response = self.request(spec.method, url=spec.endpoint)
+        return Connection.model_validate(response.json())
+
+    @traced(
+        name="connections_metadata",
+        run_type="uipath",
+        hide_output=True,
+    )
+    def metadata(
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        parameters: Optional[Dict[str, str]] = None,
+        schema_mode: bool = True,
+        max_jit_depth: int = 5,
+    ) -> ConnectionMetadata:
+        """Synchronously retrieve connection API metadata.
+
+        This method fetches the metadata for a connection. When parameters are provided,
+        it automatically fetches JIT (Just-In-Time) metadata for cascading fields in a loop,
+        following action URLs up to a maximum depth.
+
+        Args:
+            element_instance_id (int): The element instance ID of the connection.
+            connector_key (str): The connector key (e.g., 'uipath-atlassian-jira', 'uipath-slack').
+            tool_path (str): The tool path to retrieve metadata for.
+            parameters (Optional[Dict[str, str]]): Parameter values. When provided, triggers
+                automatic JIT fetching for cascading fields.
+            schema_mode (bool): Whether or not to represent the output schema in the response fields.
+            max_jit_depth (int): The maximum depth of the JIT resolution loop.
+
+        Returns:
+            ConnectionMetadata: The connection metadata.
+
+        Examples:
+            >>> metadata = sdk.connections.metadata(
+            ...     element_instance_id=123,
+            ...     connector_key="uipath-atlassian-jira",
+            ...     tool_path="Issue",
+            ...     parameters={"projectId": "PROJ-123"}  # Optional
+            ... )
+        """
+        spec = self._metadata_spec(
+            element_instance_id, connector_key, tool_path, schema_mode
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+        data = response.json()
+        metadata = ConnectionMetadata.model_validate(data)
+
+        last_action_url = None
+        depth = 0
+
+        while (
+            parameters
+            and (action_url := self._get_jit_action_url(metadata))
+            and depth < max_jit_depth
+        ):
+            # Stop if we're about to call the same URL template again
+            if action_url == last_action_url:
+                break
+
+            last_action_url = action_url
+            depth += 1
+
+            jit_spec = self._metadata_jit_spec(
+                element_instance_id, action_url, parameters, schema_mode
+            )
+            jit_response = self.request(
+                jit_spec.method,
+                url=jit_spec.endpoint,
+                params=jit_spec.params,
+                headers=jit_spec.headers,
+            )
+            data = jit_response.json()
+            metadata = ConnectionMetadata.model_validate(data)
+
+        return metadata
+
+    @traced(name="connections_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        name: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> List[Connection]:
+        """Lists all connections with optional filtering.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_path: Optional folder path for filtering connections
+            folder_key: Optional folder key (mutually exclusive with folder_path)
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            List[Connection]: List of connection instances
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+
+        Examples:
+            >>> # List all connections
+            >>> connections = sdk.connections.list()
+
+            >>> # Find connections by name
+            >>> salesforce_conns = sdk.connections.list(name="Salesforce")
+
+            >>> # List all Slack connections in Finance folder
+            >>> connections = sdk.connections.list(
+            ...     folder_path="Finance",
+            ...     connector_key="uipath-slack"
+            ... )
+        """
+        spec = self._list_spec(
+            name=name,
+            folder_key=self._folders_service.retrieve_folder_key(folder_path),
+            connector_key=connector_key,
+            skip=skip,
+            top=top,
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return self._parse_and_validate_list_response(response)
+
+    @traced(name="connections_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> List[Connection]:
+        """Asynchronously lists all connections with optional filtering.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_path: Optional folder path for filtering connections
+            folder_key: Optional folder key (mutually exclusive with folder_path)
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            List[Connection]: List of connection instances
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+
+        Examples:
+            >>> # List all connections
+            >>> connections = await sdk.connections.list_async()
+
+            >>> # Find connections by name
+            >>> salesforce_conns = await sdk.connections.list_async(name="Salesforce")
+
+            >>> # List all Slack connections in Finance folder
+            >>> connections = await sdk.connections.list_async(
+            ...     folder_path="Finance",
+            ...     connector_key="uipath-slack"
+            ... )
+        """
+        spec = self._list_spec(
+            name=name,
+            folder_key=await self._folders_service.retrieve_folder_key_async(
+                folder_path
+            ),
+            connector_key=connector_key,
+            skip=skip,
+            top=top,
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return self._parse_and_validate_list_response(response)
+
+    @resource_override("connection", resource_identifier="key")
+    @traced(
+        name="connections_retrieve",
+        run_type="uipath",
+        hide_output=True,
+    )
+    async def retrieve_async(self, key: str) -> Connection:
+        """Asynchronously retrieve connection details by its key.
+
+        This method fetches the configuration and metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            key (str): The unique identifier of the connection to retrieve.
+
+        Returns:
+            Connection: The connection details, including configuration parameters
+                and authentication information.
+        """
+        spec = self._retrieve_spec(key)
+        response = await self.request_async(spec.method, url=spec.endpoint)
+        return Connection.model_validate(response.json())
+
+    @traced(
+        name="connections_metadata",
+        run_type="uipath",
+        hide_output=True,
+    )
+    async def metadata_async(
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        parameters: Optional[Dict[str, str]] = None,
+        schema_mode: bool = True,
+        max_jit_depth: int = 5,
+    ) -> ConnectionMetadata:
+        """Asynchronously retrieve connection API metadata.
+
+        This method fetches the metadata for a connection. When parameters are provided,
+        it automatically fetches JIT (Just-In-Time) metadata for cascading fields in a loop,
+        following action URLs up to a maximum depth.
+
+        Args:
+            element_instance_id (int): The element instance ID of the connection.
+            connector_key (str): The connector key (e.g., 'uipath-atlassian-jira', 'uipath-slack').
+            tool_path (str): The tool path to retrieve metadata for.
+            parameters (Optional[Dict[str, str]]): Parameter values. When provided, triggers
+                automatic JIT fetching for cascading fields.
+            schema_mode (bool): Whether or not to represent the output schema in the response fields.
+            max_jit_depth (int): The maximum depth of the JIT resolution loop.
+
+        Returns:
+            ConnectionMetadata: The connection metadata.
+
+        Examples:
+            >>> metadata = await sdk.connections.metadata_async(
+            ...     element_instance_id=123,
+            ...     connector_key="uipath-atlassian-jira",
+            ...     tool_path="Issue",
+            ...     parameters={"projectId": "PROJ-123"}  # Optional
+            ... )
+        """
+        spec = self._metadata_spec(
+            element_instance_id, connector_key, tool_path, schema_mode
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+        data = response.json()
+        metadata = ConnectionMetadata.model_validate(data)
+
+        last_action_url = None
+        depth = 0
+
+        while (
+            parameters
+            and (action_url := self._get_jit_action_url(metadata))
+            and depth < max_jit_depth
+        ):
+            # Stop if we're about to call the same URL template again
+            if action_url == last_action_url:
+                break
+
+            last_action_url = action_url
+            depth += 1
+
+            jit_spec = self._metadata_jit_spec(
+                element_instance_id, action_url, parameters, schema_mode
+            )
+            jit_response = await self.request_async(
+                jit_spec.method,
+                url=jit_spec.endpoint,
+                params=jit_spec.params,
+                headers=jit_spec.headers,
+            )
+            data = jit_response.json()
+            metadata = ConnectionMetadata.model_validate(data)
+
+        return metadata
+
+    @traced(
+        name="connections_retrieve_token",
+        run_type="uipath",
+        hide_output=True,
+    )
+    def retrieve_token(
+        self, key: str, token_type: ConnectionTokenType = ConnectionTokenType.DIRECT
+    ) -> ConnectionToken:
+        """Retrieve an authentication token for a connection.
+
+        This method obtains a fresh authentication token that can be used to
+        communicate with the external service. This is particularly useful for
+        services that use token-based authentication.
+
+        Args:
+            key (str): The unique identifier of the connection.
+            token_type (ConnectionTokenType): The token type to use.
+
+        Returns:
+            ConnectionToken: The authentication token details, including the token
+                value and any associated metadata.
+        """
+        spec = self._retrieve_token_spec(key, token_type)
+        response = self.request(spec.method, url=spec.endpoint, params=spec.params)
+        return ConnectionToken.model_validate(response.json())
+
+    @traced(
+        name="connections_retrieve_token",
+        run_type="uipath",
+        hide_output=True,
+    )
+    async def retrieve_token_async(
+        self, key: str, token_type: ConnectionTokenType = ConnectionTokenType.DIRECT
+    ) -> ConnectionToken:
+        """Asynchronously retrieve an authentication token for a connection.
+
+        This method obtains a fresh authentication token that can be used to
+        communicate with the external service. This is particularly useful for
+        services that use token-based authentication.
+
+        Args:
+            key (str): The unique identifier of the connection.
+            token_type (ConnectionTokenType): The token type to use.
+
+        Returns:
+            ConnectionToken: The authentication token details, including the token
+                value and any associated metadata.
+        """
+        spec = self._retrieve_token_spec(key, token_type)
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params
+        )
+        return ConnectionToken.model_validate(response.json())
+
+    @traced(
+        name="connections_retrieve_event_payload",
+        run_type="uipath",
+    )
+    def retrieve_event_payload(self, event_args: EventArguments) -> Dict[str, Any]:
+        """Retrieve event payload from UiPath Integration Service.
+
+        Args:
+            event_args (EventArguments): The event arguments. Should be passed along from the job's input.
+
+        Returns:
+            Dict[str, Any]: The event payload data
+        """
+        if not event_args.additional_event_data:
+            raise ValueError("additional_event_data is required")
+
+        # Parse additional event data to get event id
+        event_data = json.loads(event_args.additional_event_data)
+
+        event_id = None
+        if "processedEventId" in event_data:
+            event_id = event_data["processedEventId"]
+        elif "rawEventId" in event_data:
+            event_id = event_data["rawEventId"]
+        else:
+            raise ValueError("Event Id not found in additional event data")
+
+        # Build request URL using connection token's API base URI
+        spec = self._retrieve_event_payload_spec("v1", event_id)
+
+        response = self.request(spec.method, url=spec.endpoint)
+
+        return response.json()
+
+    @traced(
+        name="connections_retrieve_event_payload",
+        run_type="uipath",
+    )
+    async def retrieve_event_payload_async(
+        self, event_args: EventArguments
+    ) -> Dict[str, Any]:
+        """Retrieve event payload from UiPath Integration Service.
+
+        Args:
+            event_args (EventArguments): The event arguments. Should be passed along from the job's input.
+
+        Returns:
+            Dict[str, Any]: The event payload data
+        """
+        if not event_args.additional_event_data:
+            raise ValueError("additional_event_data is required")
+
+        # Parse additional event data to get event id
+        event_data = json.loads(event_args.additional_event_data)
+
+        event_id = None
+        if "processedEventId" in event_data:
+            event_id = event_data["processedEventId"]
+        elif "rawEventId" in event_data:
+            event_id = event_data["rawEventId"]
+        else:
+            raise ValueError("Event Id not found in additional event data")
+
+        # Build request URL using connection token's API base URI
+        spec = self._retrieve_event_payload_spec("v1", event_id)
+
+        response = await self.request_async(spec.method, url=spec.endpoint)
+
+        return response.json()
+
+    def _retrieve_event_payload_spec(self, version: str, event_id: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/elements_/{version}/events/{event_id}"),
+        )
+
+    def _retrieve_spec(self, key: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}"),
+        )
+
+    def _metadata_spec(
+        self,
+        element_instance_id: int,
+        connector_key: str,
+        tool_path: str,
+        schema_mode: bool,
+    ) -> RequestSpec:
+        metadata_endpoint_url = f"/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata"
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(metadata_endpoint_url),
+            headers={
+                "accept": "application/schema+json"
+                if schema_mode
+                else "application/json"
+            },
+        )
+
+    def _metadata_jit_spec(
+        self,
+        element_instance_id: int,
+        dynamic_path: str,
+        parameters: Dict[str, str],
+        schema_mode: bool,
+    ) -> RequestSpec:
+        """Build request spec for JIT metadata with dynamic path parameter substitution.
+
+        For example, if the dynamic path is "elements/jira/projects/{projectId}/issues", and the parameters
+        are {"projectId": "PROJ-123"}, the resolved path will be "elements/jira/projects/PROJ-123/issues".
+        """
+        for key, value in parameters.items():
+            dynamic_path = dynamic_path.replace(
+                f"{{{key}}}", quote(str(value), safe="")
+            )
+        split = urlsplit(dynamic_path.lstrip("/"))
+        query_params = dict(parse_qsl(split.query))
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/elements_/v3/element/instances/{element_instance_id}/{split.path}"
+            ),
+            params=query_params,
+            headers={
+                "accept": "application/schema+json"
+                if schema_mode
+                else "application/json"
+            },
+        )
+
+    def _get_jit_action_url(
+        self, connection_metadata: ConnectionMetadata
+    ) -> Optional[str]:
+        """Return the URL of the JIT action that should be triggered dynamically."""
+        if "method" not in connection_metadata.metadata:
+            return None
+
+        methods = connection_metadata.metadata["method"]
+        actions = [
+            action
+            for method_data in methods.values()
+            for action in method_data.get("design", {}).get("actions", [])
+            if action.get("actionType") == "api"
+        ]
+        return actions[0].get("apiConfiguration", {}).get("url") if actions else None
+
+    def _retrieve_token_spec(
+        self, key: str, token_type: ConnectionTokenType = ConnectionTokenType.DIRECT
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}/token"),
+            params={"tokenType": token_type.value},
+        )
+
+    def _parse_and_validate_list_response(self, response: Response) -> List[Connection]:
+        """Parse and validate the list response from the API.
+
+        Handles both OData response format (with 'value' field) and raw list responses.
+
+        Args:
+            response: The HTTP response from the API
+
+        Returns:
+            List of validated Connection instances
+        """
+        data = response.json()
+
+        # Handle both OData responses (dict with 'value') and raw list responses
+        if isinstance(data, dict):
+            connections_data = data.get("value", [])
+        elif isinstance(data, list):
+            connections_data = data
+        else:
+            connections_data = []
+
+        return [Connection.model_validate(conn) for conn in connections_data]
+
+    def _list_spec(
+        self,
+        name: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the request specification for listing connections.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_key: Optional folder key
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            RequestSpec with endpoint, params, and headers configured
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+        """
+        # Build OData filters
+        filters = []
+        if name:
+            # Escape single quotes in name for OData
+            escaped_name = name.replace("'", "''")
+            filters.append(f"contains(Name, '{escaped_name}')")
+        if connector_key:
+            filters.append(f"connector/key eq '{connector_key}'")
+
+        params = {}
+        if filters:
+            params["$filter"] = " and ".join(filters)
+        if skip is not None:
+            params["$skip"] = str(skip)
+        if top is not None:
+            params["$top"] = str(top)
+
+        # Always expand connector and folder for complete information
+        params["$expand"] = "connector,folder"
+
+        # Use header_folder which handles validation
+        headers = header_folder(folder_key, None)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/connections_/api/v1/Connections"),
+            params=params,
+            headers=headers,
+        )
+
+    @traced(
+        name="activity_invoke",
+        run_type="uipath",
+    )
+    def invoke_activity(
+        self,
+        activity_metadata: ActivityMetadata,
+        connection_id: str,
+        activity_input: Dict[str, Any],
+    ) -> Any:
+        """Invoke an activity synchronously.
+
+        Args:
+            activity_metadata: Metadata describing the activity to invoke
+            connection_id: The ID of the connection
+            activity_input: Input parameters for the activity
+
+        Returns:
+            The response from the activity
+
+        Raises:
+            ValueError: If required parameters are missing or invalid
+            RuntimeError: If the HTTP request fails or returns an error status
+        """
+        connection = self.retrieve(connection_id)
+        folder_key = connection.folder.get("key") if connection.folder else None
+
+        spec = self._build_activity_request_spec(
+            activity_metadata, connection.id, activity_input, folder_key
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            params=spec.params,
+            json=spec.json,
+            files=spec.files,
+        )
+
+        return response.json()
+
+    @traced(
+        name="activity_invoke",
+        run_type="uipath",
+    )
+    async def invoke_activity_async(
+        self,
+        activity_metadata: ActivityMetadata,
+        connection_id: str,
+        activity_input: Dict[str, Any],
+    ) -> Any:
+        """Invoke an activity asynchronously.
+
+        Args:
+            activity_metadata: Metadata describing the activity to invoke
+            connection_id: The ID of the connection
+            activity_input: Input parameters for the activity
+
+        Returns:
+            The response from the activity
+
+        Raises:
+            ValueError: If required parameters are missing or invalid
+            RuntimeError: If the HTTP request fails or returns an error status
+        """
+        connection = await self.retrieve_async(connection_id)
+        folder_key = connection.folder.get("key") if connection.folder else None
+
+        spec = self._build_activity_request_spec(
+            activity_metadata, connection.id, activity_input, folder_key
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            params=spec.params,
+            json=spec.json,
+            files=spec.files,
+        )
+
+        return response.json()
+
+    def _build_activity_request_spec(
+        self,
+        activity_metadata: ActivityMetadata,
+        connection_id: str,
+        activity_input: Dict[str, Any],
+        folder_key: Optional[str] = None,
+    ) -> RequestSpec:
+        """Build the request specification for invoking an activity."""
+        url = f"/elements_/v3/element/instances/{connection_id}{activity_metadata.object_path}"
+
+        query_params: Dict[str, str] = {}
+        path_params: Dict[str, str] = {}
+        header_params: Dict[str, str] = {}
+        multipart_params: Dict[str, Any] = {}
+        body_fields: Dict[str, Any] = {}
+
+        # iterating through input items instead of parameters because input will usually not contain all parameters
+        # and we don't want to add unused optional parameters to the request
+        for param_name, value in activity_input.items():
+            if value is None:
+                continue
+
+            value_str = str(value) if not isinstance(value, str) else value
+
+            if param_name in activity_metadata.parameter_location_info.query_params:
+                query_params[param_name] = value_str
+            elif param_name in activity_metadata.parameter_location_info.path_params:
+                path_params[param_name] = value_str
+            elif param_name in activity_metadata.parameter_location_info.header_params:
+                header_params[param_name] = value_str
+            elif (
+                param_name in activity_metadata.parameter_location_info.multipart_params
+            ):
+                multipart_params[param_name] = value
+            elif param_name in activity_metadata.parameter_location_info.body_fields:
+                body_fields[param_name] = value
+
+        # path parameter handling
+        for key, value in path_params.items():
+            url = url.replace(f"{{{key}}}", value)
+
+        # header parameter handling
+        headers = {
+            HEADER_ORIGINATOR: _ORIGINATOR_VALUE,
+            HEADER_SOURCE: _ORIGINATOR_VALUE,
+            **header_folder(folder_key, None),
+            **header_params,
+        }
+        if job_key := UiPathConfig.job_key:
+            headers[HEADER_ACTIVITY_JOB_ID] = job_key
+
+        # body and files handling
+        json_data: Dict[str, Any] | None = None
+        files: Dict[str, Any] | None = None
+
+        # multipart/form-data for file uploads
+        json_section = activity_metadata.json_body_section or "body"
+        if "multipart" in activity_metadata.content_type.lower():
+            files = {}
+
+            for key, val in multipart_params.items():
+                # json body itself appears as a multipart param as well
+                # instead of making assumptions on whether or not it's present, we'll handle it defensively
+                if key == json_section:
+                    continue
+                if isinstance(val, tuple):
+                    # Caller supplied httpx's (filename, content[, content_type])
+                    # shape — pass through verbatim. This is the recommended path
+                    # for file uploads so the multipart Content-Disposition gets
+                    # the real filename instead of the form-field name.
+                    files[key] = val
+                elif isinstance(val, (bytes, bytearray)) or hasattr(val, "read"):
+                    # Raw file content with no filename — fall back to the
+                    # form-field name (legacy behaviour). Backwards compatible
+                    # with callers that still pass bytes directly.
+                    files[key] = (key, val, "application/octet-stream")
+                else:
+                    # Scalar (string/number/etc.) — send as a plain multipart
+                    # form field, not a file part. The (None, value) shape tells
+                    # httpx to omit `filename=...` from the Content-Disposition.
+                    files[key] = (None, str(val))
+
+            files[json_section] = (
+                "",
+                json.dumps(body_fields),
+                "application/json",
+            )
+
+        # application/json for regular requests
+        elif "json" in activity_metadata.content_type.lower():
+            json_data = body_fields
+        else:
+            raise ValueError(
+                f"Unsupported content type: {activity_metadata.content_type}"
+            )
+
+        return RequestSpec(
+            method=activity_metadata.method_name,
+            endpoint=Endpoint(url),
+            headers=headers,
+            params=query_params,
+            json=json_data,
+            files=files,
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/connections/connections.py b/packages/uipath-platform/src/uipath/platform/connections/connections.py
new file mode 100644
index 000000000..394861708
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/connections/connections.py
@@ -0,0 +1,108 @@
+"""Models for connections in the UiPath platform."""
+
+from enum import Enum
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ConnectionMetadata(BaseModel):
+    """Metadata about a connection."""
+
+    fields: dict[str, Any] = Field(default_factory=dict, alias="fields")
+    metadata: dict[str, Any] = Field(default_factory=dict, alias="metadata")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class Connection(BaseModel):
+    """Model representing a connection in the UiPath platform."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    id: Optional[str] = None
+    name: Optional[str] = None
+    owner: Optional[str] = None
+    create_time: Optional[str] = Field(default=None, alias="createTime")
+    update_time: Optional[str] = Field(default=None, alias="updateTime")
+    state: Optional[str] = None
+    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
+    element_instance_id: int = Field(alias="elementInstanceId")
+    connector: Optional[Any] = None
+    is_default: Optional[bool] = Field(default=None, alias="isDefault")
+    last_used_time: Optional[str] = Field(default=None, alias="lastUsedTime")
+    connection_identity: Optional[str] = Field(default=None, alias="connectionIdentity")
+    polling_interval_in_minutes: Optional[int] = Field(
+        default=None, alias="pollingIntervalInMinutes"
+    )
+    folder: Optional[Any] = None
+    element_version: Optional[str] = Field(default=None, alias="elementVersion")
+
+
+class ConnectionTokenType(str, Enum):
+    """Enum representing types of connection tokens."""
+
+    DIRECT = "direct"
+    BEARER = "bearer"
+
+
+class ConnectionToken(BaseModel):
+    """Model representing a connection token in the UiPath platform."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    access_token: str = Field(alias="accessToken")
+    token_type: Optional[str] = Field(default=None, alias="tokenType")
+    scope: Optional[str] = None
+    expires_in: Optional[int] = Field(default=None, alias="expiresIn")
+    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
+    element_instance_id: Optional[int] = Field(default=None, alias="elementInstanceId")
+
+
+class EventArguments(BaseModel):
+    """Model representing event arguments for a connection."""
+
+    event_connector: Optional[str] = Field(default=None, alias="UiPathEventConnector")
+    event: Optional[str] = Field(default=None, alias="UiPathEvent")
+    event_object_type: Optional[str] = Field(
+        default=None, alias="UiPathEventObjectType"
+    )
+    event_object_id: Optional[str] = Field(default=None, alias="UiPathEventObjectId")
+    additional_event_data: Optional[str] = Field(
+        default=None, alias="UiPathAdditionalEventData"
+    )
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="allow",
+    )
+
+
+class ActivityParameterLocationInfo(BaseModel):
+    """Information about parameter location in an activity."""
+
+    query_params: List[str] = []
+    header_params: List[str] = []
+    path_params: List[str] = []
+    multipart_params: List[str] = []
+    body_fields: List[str] = []
+
+
+class ActivityMetadata(BaseModel):
+    """Metadata for an activity."""
+
+    object_path: str
+    method_name: str
+    content_type: str
+    parameter_location_info: ActivityParameterLocationInfo
+    json_body_section: Optional[str] = None
diff --git a/packages/uipath-platform/src/uipath/platform/context_grounding/__init__.py b/packages/uipath-platform/src/uipath/platform/context_grounding/__init__.py
new file mode 100644
index 000000000..f614dcff2
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/context_grounding/__init__.py
@@ -0,0 +1,81 @@
+"""Init file for context grounding module."""
+
+from ._context_grounding_service import ContextGroundingService
+from .context_grounding import (
+    BatchTransformCreationResponse,
+    BatchTransformOutputColumn,
+    BatchTransformResponse,
+    BatchTransformStatus,
+    Citation,
+    CitationMode,
+    ContextGroundingQueryResponse,
+    ContextGroundingSearchResultItem,
+    DeepRagContent,
+    DeepRagCreationResponse,
+    DeepRagResponse,
+    DeepRagStatus,
+    EphemeralIndexUsage,
+    IndexStatus,
+    SearchMode,
+    SemanticSearchOptions,
+    SemanticSearchResult,
+    UnifiedQueryResult,
+    UnifiedSearchScope,
+)
+from .context_grounding_index import ContextGroundingIndex
+from .context_grounding_payloads import (
+    BaseSourceConfig,
+    BucketDataSource,
+    BucketSourceConfig,
+    ConfluenceDataSource,
+    ConfluenceSourceConfig,
+    ConnectionSourceConfig,
+    CreateIndexPayload,
+    DropboxDataSource,
+    DropboxSourceConfig,
+    GoogleDriveDataSource,
+    GoogleDriveSourceConfig,
+    Indexer,
+    OneDriveDataSource,
+    OneDriveSourceConfig,
+    SourceConfig,
+)
+
+__all__ = [
+    "BatchTransformCreationResponse",
+    "BatchTransformOutputColumn",
+    "BatchTransformResponse",
+    "BatchTransformStatus",
+    "BaseSourceConfig",
+    "BucketDataSource",
+    "BucketSourceConfig",
+    "CitationMode",
+    "ConfluenceDataSource",
+    "ConfluenceSourceConfig",
+    "ConnectionSourceConfig",
+    "ContextGroundingIndex",
+    "ContextGroundingQueryResponse",
+    "ContextGroundingSearchResultItem",
+    "ContextGroundingService",
+    "CreateIndexPayload",
+    "DeepRagCreationResponse",
+    "DeepRagResponse",
+    "DeepRagContent",
+    "DeepRagStatus",
+    "IndexStatus",
+    "DropboxDataSource",
+    "DropboxSourceConfig",
+    "EphemeralIndexUsage",
+    "GoogleDriveDataSource",
+    "GoogleDriveSourceConfig",
+    "Indexer",
+    "OneDriveDataSource",
+    "OneDriveSourceConfig",
+    "SearchMode",
+    "SemanticSearchOptions",
+    "SemanticSearchResult",
+    "SourceConfig",
+    "UnifiedQueryResult",
+    "UnifiedSearchScope",
+    "Citation",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/context_grounding/_context_grounding_service.py b/packages/uipath-platform/src/uipath/platform/context_grounding/_context_grounding_service.py
new file mode 100644
index 000000000..6bff3f77f
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/context_grounding/_context_grounding_service.py
@@ -0,0 +1,2579 @@
+from pathlib import Path
+from typing import Annotated, Any, Dict, List, Optional, Tuple, Union
+
+import httpx
+from pydantic import Field, TypeAdapter
+from typing_extensions import deprecated
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._http_config import get_httpx_client_kwargs
+from ..common._job_context import header_job_key
+from ..common._models import Endpoint, RequestSpec
+from ..common.constants import (
+    ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
+)
+from ..errors import (
+    BatchTransformFailedException,
+    BatchTransformNotCompleteException,
+    ContextGroundingIndexNotFoundError,
+    IngestionInProgressException,
+    UnsupportedDataSourceException,
+)
+from ..orchestrator._buckets_service import BucketsService
+from ..orchestrator._folder_service import FolderService
+from .context_grounding import (
+    BatchTransformCreationResponse,
+    BatchTransformOutputColumn,
+    BatchTransformReadUriResponse,
+    BatchTransformResponse,
+    BatchTransformStatus,
+    CitationMode,
+    ContextGroundingQueryResponse,
+    DeepRagCreationResponse,
+    DeepRagResponse,
+    EphemeralIndexUsage,
+    SearchMode,
+    UnifiedQueryResult,
+    UnifiedSearchScope,
+)
+from .context_grounding_index import ContextGroundingIndex
+from .context_grounding_payloads import (
+    AttachmentsDataSource,
+    BucketDataSource,
+    BucketSourceConfig,
+    ConfluenceDataSource,
+    ConfluenceSourceConfig,
+    CreateEphemeralIndexPayload,
+    CreateIndexPayload,
+    DropboxDataSource,
+    DropboxSourceConfig,
+    GoogleDriveDataSource,
+    GoogleDriveSourceConfig,
+    OneDriveDataSource,
+    OneDriveSourceConfig,
+    SourceConfig,
+)
+
+
+class ContextGroundingService(FolderContext, BaseService):
+    """Service for managing semantic automation contexts in UiPath.
+
+    Context Grounding is a feature that helps in understanding and managing the
+    semantic context in which automation processes operate. It provides capabilities
+    for indexing, retrieving, and searching through contextual information that
+    can be used to enhance AI-enabled automation.
+
+    This service requires a valid folder key to be set in the environment, as
+    context grounding operations are always performed within a specific folder
+    context.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: FolderService,
+        buckets_service: BucketsService,
+    ) -> None:
+        self._folders_service = folders_service
+        self._buckets_service = buckets_service
+        super().__init__(config=config, execution_context=execution_context)
+
+    # 2.3.0 prefix trace name with contextgrounding
+    @resource_override(resource_type="index")
+    @traced(name="add_to_index", run_type="uipath")
+    def add_to_index(
+        self,
+        name: str,
+        blob_file_path: str,
+        content_type: Optional[str] = None,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        ingest_data: bool = True,
+    ) -> None:
+        """Add content to the index.
+
+        Args:
+            name (str): The name of the index to add content to.
+            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
+            blob_file_path (str): The path where the blob will be stored in the storage bucket.
+            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
+            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            ingest_data (bool): Whether to ingest data in the index after content is uploaded. Defaults to True.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+        """
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        index = self.retrieve(name=name, folder_key=folder_key, folder_path=folder_path)
+        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
+        if source_path:
+            self._buckets_service.upload(
+                name=bucket_name,
+                blob_file_path=blob_file_path,
+                source_path=source_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+        else:
+            self._buckets_service.upload(
+                name=bucket_name,
+                content=content,
+                blob_file_path=blob_file_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+
+        if ingest_data:
+            self.ingest_data(index, folder_key=folder_key, folder_path=folder_path)
+
+    # 2.3.0 prefix trace name with contextgrounding
+    @resource_override(resource_type="index")
+    @traced(name="add_to_index", run_type="uipath")
+    async def add_to_index_async(
+        self,
+        name: str,
+        blob_file_path: str,
+        content_type: Optional[str] = None,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        ingest_data: bool = True,
+    ) -> None:
+        """Asynchronously add content to the index.
+
+        Args:
+            name (str): The name of the index to add content to.
+            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
+            blob_file_path (str): The path where the blob will be stored in the storage bucket.
+            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
+            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            ingest_data (bool): Whether to ingest data in the index after content is uploaded. Defaults to True.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+        """
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        index = await self.retrieve_async(
+            name=name, folder_key=folder_key, folder_path=folder_path
+        )
+        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
+        if source_path:
+            await self._buckets_service.upload_async(
+                name=bucket_name,
+                blob_file_path=blob_file_path,
+                source_path=source_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+        else:
+            await self._buckets_service.upload_async(
+                name=bucket_name,
+                content=content,
+                blob_file_path=blob_file_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+
+        if ingest_data:
+            await self.ingest_data_async(
+                index, folder_key=folder_key, folder_path=folder_path
+            )
+
+    @traced(name="contextgrounding_retrieve_across_folders", run_type="uipath")
+    def retrieve_across_folders(
+        self,
+        name: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """Retrieve all context grounding indexes across all folders.
+
+        This method fetches indexes from all folders without requiring a folder key.
+
+        Args:
+            name (Optional[str]): Optional name filter. If provided, only indexes
+                matching this name will be returned.
+
+        Returns:
+            List[ContextGroundingIndex]: A list of indexes across all folders.
+        """
+        spec = self._retrieve_across_folders_spec(name=name)
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item) for item in response["value"]
+        ]
+
+    @traced(name="contextgrounding_retrieve_across_folders", run_type="uipath")
+    async def retrieve_across_folders_async(
+        self,
+        name: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """Asynchronously retrieve all context grounding indexes across all folders.
+
+        This method fetches indexes from all folders without requiring a folder key.
+
+        Args:
+            name (Optional[str]): Optional name filter. If provided, only indexes
+                matching this name will be returned.
+
+        Returns:
+            List[ContextGroundingIndex]: A list of indexes across all folders.
+        """
+        spec = self._retrieve_across_folders_spec(name=name)
+
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item) for item in response["value"]
+        ]
+
+    @traced(name="contextgrounding_retrieve_system_indexes", run_type="uipath")
+    def _retrieve_system_indexes(
+        self,
+        name: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        spec = self._retrieve_system_indexes_spec(name=name)
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item) for item in response["value"]
+        ]
+
+    @traced(name="contextgrounding_retrieve_system_indexes", run_type="uipath")
+    async def _retrieve_system_indexes_async(
+        self,
+        name: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        spec = self._retrieve_system_indexes_spec(name=name)
+
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item) for item in response["value"]
+        ]
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_retrieve", run_type="uipath")
+    def retrieve(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        include_system_indexes: bool = False,
+    ) -> ContextGroundingIndex:
+        """Retrieve context grounding index information by its name.
+
+        If no folder_key or folder_path is provided and no folder context is
+        configured, falls back to searching across all folders. When
+        ``include_system_indexes`` is True, an additional fallback against
+        system indexes is attempted before raising not-found.
+
+        Args:
+            name (str): The name of the context index to retrieve.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            include_system_indexes (bool): If True, fall back to system indexes
+                when the index is not found in the per-folder or across-folders listings.
+                Defaults to False.
+
+        Returns:
+            ContextGroundingIndex: The index information, including its configuration and metadata if found.
+
+        Raises:
+            ContextGroundingIndexNotFoundError: If no index with the given name is found.
+        """
+        resolved_folder_key = self._resolve_folder_key(folder_key, folder_path)
+        if not resolved_folder_key:
+            indexes = self.retrieve_across_folders(name=name)
+            try:
+                return next(index for index in indexes if index.name == name)
+            except StopIteration:
+                if include_system_indexes:
+                    return self._retrieve_from_system_indexes(name)
+                raise ContextGroundingIndexNotFoundError(name) from None
+
+        spec = self._retrieve_spec(
+            name,
+            folder_key=resolved_folder_key,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+        try:
+            return next(
+                ContextGroundingIndex.model_validate(item)
+                for item in response["value"]
+                if item["name"] == name
+            )
+        except StopIteration:
+            if include_system_indexes:
+                return self._retrieve_from_system_indexes(name)
+            raise ContextGroundingIndexNotFoundError(name) from None
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_retrieve", run_type="uipath")
+    async def retrieve_async(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        include_system_indexes: bool = False,
+    ) -> ContextGroundingIndex:
+        """Asynchronously retrieve context grounding index information by its name.
+
+        If no folder_key or folder_path is provided and no folder context is
+        configured, falls back to searching across all folders. When
+        ``include_system_indexes`` is True, an additional fallback against
+        system indexes is attempted before raising not-found.
+
+        Args:
+            name (str): The name of the context index to retrieve.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            include_system_indexes (bool): If True, fall back to system indexes when
+                the index is not found in the per-folder or across-folders listings.
+                Defaults to False.
+
+        Returns:
+            ContextGroundingIndex: The index information, including its configuration and metadata if found.
+
+        Raises:
+            ContextGroundingIndexNotFoundError: If no index with the given name is found.
+        """
+        resolved_folder_key = self._resolve_folder_key(folder_key, folder_path)
+        if not resolved_folder_key:
+            indexes = await self.retrieve_across_folders_async(name=name)
+            try:
+                return next(index for index in indexes if index.name == name)
+            except StopIteration:
+                if include_system_indexes:
+                    return await self._retrieve_from_system_indexes_async(name)
+                raise ContextGroundingIndexNotFoundError(name) from None
+
+        spec = self._retrieve_spec(
+            name,
+            folder_key=resolved_folder_key,
+        )
+
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+        try:
+            return next(
+                ContextGroundingIndex.model_validate(item)
+                for item in response["value"]
+                if item["name"] == name
+            )
+        except StopIteration:
+            if include_system_indexes:
+                return await self._retrieve_from_system_indexes_async(name)
+            raise ContextGroundingIndexNotFoundError(name) from None
+
+    def _retrieve_from_system_indexes(self, name: str) -> ContextGroundingIndex:
+        indexes = self._retrieve_system_indexes(name=name)
+        try:
+            return next(index for index in indexes if index.name == name)
+        except StopIteration:
+            raise ContextGroundingIndexNotFoundError(name) from None
+
+    async def _retrieve_from_system_indexes_async(
+        self, name: str
+    ) -> ContextGroundingIndex:
+        indexes = await self._retrieve_system_indexes_async(name=name)
+        try:
+            return next(index for index in indexes if index.name == name)
+        except StopIteration:
+            raise ContextGroundingIndexNotFoundError(name) from None
+
+    @traced(name="contextgrounding_list", run_type="uipath")
+    def list(
+        self,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """List all context grounding indexes in a folder.
+
+        Args:
+            folder_key (Optional[str]): The key of the folder to list indexes from.
+            folder_path (Optional[str]): The path of the folder to list indexes from.
+
+        Returns:
+            List[ContextGroundingIndex]: All indexes in the folder.
+        """
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+        response = self.request(
+            "GET",
+            Endpoint("/ecs_/v2/indexes"),
+            params={"$expand": "dataSource"},
+            headers={**header_folder(folder_key, None), **header_job_key()},
+        ).json()
+        return [
+            ContextGroundingIndex.model_validate(item)
+            for item in response.get("value", [])
+        ]
+
+    @traced(name="contextgrounding_list", run_type="uipath")
+    async def list_async(
+        self,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """Asynchronously list all context grounding indexes in a folder.
+
+        Args:
+            folder_key (Optional[str]): The key of the folder to list indexes from.
+            folder_path (Optional[str]): The path of the folder to list indexes from.
+
+        Returns:
+            List[ContextGroundingIndex]: All indexes in the folder.
+        """
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+        response = (
+            await self.request_async(
+                "GET",
+                Endpoint("/ecs_/v2/indexes"),
+                params={"$expand": "dataSource"},
+                headers={**header_folder(folder_key, None), **header_job_key()},
+            )
+        ).json()
+        return [
+            ContextGroundingIndex.model_validate(item)
+            for item in response.get("value", [])
+        ]
+
+    @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
+    def retrieve_by_id(
+        self,
+        id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Any:
+        """Retrieve context grounding index information by its ID.
+
+        This method provides direct access to a context index using its unique
+        identifier, which can be more efficient than searching by name.
+
+        Args:
+            id (str): The unique identifier of the context index.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Returns:
+            Any: The index information, including its configuration and metadata.
+        """
+        spec = self._retrieve_by_id_spec(
+            id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        return self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+    @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
+    async def retrieve_by_id_async(
+        self,
+        id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Any:
+        """Retrieve asynchronously context grounding index information by its ID.
+
+        This method provides direct access to a context index using its unique
+        identifier, which can be more efficient than searching by name.
+
+        Args:
+            id (str): The unique identifier of the context index.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Returns:
+            Any: The index information, including its configuration and metadata.
+        """
+        spec = self._retrieve_by_id_spec(
+            id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return response.json()
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_create_index", run_type="uipath")
+    def create_index(
+        self,
+        name: str,
+        source: SourceConfig,
+        description: Optional[str] = None,
+        extraction_strategy: Optional[str] = None,
+        embeddings_enabled: Optional[bool] = None,
+        is_encrypted: Optional[bool] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> ContextGroundingIndex:
+        """Create a new context grounding index.
+
+        Args:
+            name (str): The name of the index to create.
+            source (SourceConfig): Source configuration using one of:
+                - BucketSourceConfig: For storage buckets
+                - GoogleDriveSourceConfig: For Google Drive
+                - DropboxSourceConfig: For Dropbox
+                - OneDriveSourceConfig: For OneDrive
+                - ConfluenceSourceConfig: For Confluence
+
+                The source can include an optional indexer field for scheduled indexing:
+                    source.indexer = Indexer(cron_expression="0 0 18 ? * 2", time_zone_id="UTC")
+            description (Optional[str]): Description of the index.
+            extraction_strategy (Optional[str]): Extraction method - "NativeV1" or "LLMV4". Defaults to NativeV1.
+            embeddings_enabled (Optional[bool]): Whether to generate embeddings. Defaults to true.
+            is_encrypted (Optional[bool]): Whether to encrypt the index. Defaults to false.
+            folder_key (Optional[str]): The key of the folder where the index will be created.
+            folder_path (Optional[str]): The path of the folder where the index will be created.
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            source=source,
+            extraction_strategy=extraction_strategy,
+            embeddings_enabled=embeddings_enabled,
+            is_encrypted=is_encrypted,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_create_index", run_type="uipath")
+    async def create_index_async(
+        self,
+        name: str,
+        source: SourceConfig,
+        description: Optional[str] = None,
+        extraction_strategy: Optional[str] = None,
+        embeddings_enabled: Optional[bool] = None,
+        is_encrypted: Optional[bool] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> ContextGroundingIndex:
+        """Create a new context grounding index.
+
+        Args:
+            name (str): The name of the index to create.
+            source (SourceConfig): Source configuration using one of:
+                - BucketSourceConfig: For storage buckets
+                - GoogleDriveSourceConfig: For Google Drive
+                - DropboxSourceConfig: For Dropbox
+                - OneDriveSourceConfig: For OneDrive
+                - ConfluenceSourceConfig: For Confluence
+
+                The source can include an optional indexer field for scheduled indexing:
+                    source.indexer = Indexer(cron_expression="0 0 18 ? * 2", time_zone_id="UTC")
+            description (Optional[str]): Description of the index.
+            extraction_strategy (Optional[str]): Extraction method - "NativeV1" or "LLMV4". Defaults to NativeV1.
+            embeddings_enabled (Optional[bool]): Whether to generate embeddings. Defaults to true.
+            is_encrypted (Optional[bool]): Whether to encrypt the index. Defaults to false.
+            folder_key (Optional[str]): The key of the folder where the index will be created.
+            folder_path (Optional[str]): The path of the folder where the index will be created.
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            source=source,
+            extraction_strategy=extraction_strategy,
+            embeddings_enabled=embeddings_enabled,
+            is_encrypted=is_encrypted,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_create_ephemeral_index", run_type="uipath")
+    def create_ephemeral_index(
+        self,
+        usage: EphemeralIndexUsage,
+        attachments: List[str],
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> ContextGroundingIndex:
+        """Create a new ephemeral context grounding index.
+
+        Args:
+            usage (EphemeralIndexUsage): The task type for the ephemeral index (DeepRAG or BatchRAG)
+            attachments (list[str]): The list of attachments ids from which the ephemeral index will be created
+            folder_key (Optional[str]): The folder key to scope the ephemeral index to.
+            folder_path (Optional[str]): The folder path to scope the ephemeral index to (resolved to a key if folder_key is not provided).
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        if folder_key is not None or folder_path is not None:
+            folder_key = self._resolve_folder_key(folder_key, folder_path)
+        spec = self._create_ephemeral_spec(
+            usage,
+            attachments,
+            folder_key=folder_key,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_create_ephemeral_index", run_type="uipath")
+    async def create_ephemeral_index_async(
+        self,
+        usage: EphemeralIndexUsage,
+        attachments: List[str],
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> ContextGroundingIndex:
+        """Create a new ephemeral context grounding index.
+
+        Args:
+            usage (EphemeralIndexUsage): The task type for the ephemeral index (DeepRAG or BatchRAG)
+            attachments (list[str]): The list of attachments ids from which the ephemeral index will be created
+            folder_key (Optional[str]): The folder key to scope the ephemeral index to.
+            folder_path (Optional[str]): The folder path to scope the ephemeral index to (resolved to a key if folder_key is not provided).
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        if folder_key is not None or folder_path is not None:
+            folder_key = self._resolve_folder_key(folder_key, folder_path)
+        spec = self._create_ephemeral_spec(
+            usage,
+            attachments,
+            folder_key=folder_key,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_retrieve_deep_rag", run_type="uipath")
+    def retrieve_deep_rag(
+        self,
+        id: str,
+        *,
+        index_name: str | None = None,
+    ) -> DeepRagResponse:
+        """Retrieves a Deep RAG task.
+
+        Args:
+            id (str): The id of the Deep RAG task.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Returns:
+            DeepRagResponse: The Deep RAG task response.
+        """
+        spec = self._deep_rag_retrieve_spec(
+            id=id,
+        )
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+        )
+        return DeepRagResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_retrieve_deep_rag_async", run_type="uipath")
+    async def retrieve_deep_rag_async(
+        self,
+        id: str,
+        *,
+        index_name: str | None = None,
+    ) -> DeepRagResponse:
+        """Asynchronously retrieves a Deep RAG task.
+
+        Args:
+            id (str): The id of the Deep RAG task.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Returns:
+            DeepRagResponse: The Deep RAG task response.
+        """
+        spec = self._deep_rag_retrieve_spec(
+            id=id,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return DeepRagResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_batch_transform", run_type="uipath")
+    def start_batch_transform(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: Annotated[
+            str | None, Field(max_length=512)
+        ] = None,
+        target_file_name: Annotated[str | None, Field(max_length=512)] = None,
+        enable_web_search_grounding: bool = False,
+        index_name: str | None = None,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> BatchTransformCreationResponse:
+        """Starts a Batch Transform, task on the targeted index.
+
+        Batch Transform tasks are processing and transforming csv files from the index.
+        Only one file can be processed per batch transform job.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            index_name (str): The name of the context index to search in.
+            prompt (str): Describe the task: what to research, what to synthesize.
+            output_columns (list[BatchTransformOutputColumn]):  The output columns to add into the csv.
+            storage_bucket_folder_path_prefix (str): The prefix pattern for filtering files in the storage bucket.
+                Can be combined with target_file_name. Defaults to None.
+            target_file_name (str, optional): Specific file name to target.
+                If both target_file_name and storage_bucket_folder_path_prefix are provided, they will be combined (e.g., "data/file.csv").
+                If only target_file_name is provided, it will be used directly.
+                Only one file can be processed per batch transform job.
+            enable_web_search_grounding (Optional[bool]): Whether to enable web search. Defaults to False.
+            index_id (str): The id of the context index to search in, used in place of name if present
+            folder_key (str, optional): The folder key where the index resides. Defaults to None.
+            folder_path (str, optional): The folder path where the index resides. Defaults to None.
+
+        Returns:
+            BatchTransformCreationResponse: The batch transform task creation response.
+        """
+        if not (index_name or index_id):
+            raise ValueError("Index name or id is required")
+        if index_name and index_id:
+            raise ValueError("Index name or id are mutually exclusive")
+
+        if not index_id:
+            index = self.retrieve(
+                index_name, folder_key=folder_key, folder_path=folder_path
+            )
+            if index and index.in_progress_ingestion():
+                raise IngestionInProgressException(index_name=index_name)
+            index_id = index.id
+            folder_key = folder_key or index.folder_key
+
+        spec = self._batch_transform_creation_spec(
+            index_id=index_id,
+            name=name,
+            storage_bucket_folder_path_prefix=storage_bucket_folder_path_prefix,
+            target_file_name=target_file_name,
+            prompt=prompt,
+            output_columns=output_columns,
+            enable_web_search_grounding=enable_web_search_grounding,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_batch_transform_async", run_type="uipath")
+    async def start_batch_transform_async(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: Annotated[
+            str | None, Field(max_length=512)
+        ] = None,
+        target_file_name: Annotated[str | None, Field(max_length=512)] = None,
+        enable_web_search_grounding: bool = False,
+        index_name: str | None = None,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> BatchTransformCreationResponse:
+        """Asynchronously starts a Batch Transform, task on the targeted index.
+
+        Batch Transform tasks are processing and transforming csv files from the index.
+        Only one file can be processed per batch transform job.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            index_name (str): The name of the context index to search in.
+            prompt (str): Describe the task: what to research, what to synthesize.
+            output_columns (list[BatchTransformOutputColumn]):  The output columns to add into the csv.
+            storage_bucket_folder_path_prefix (str): The prefix pattern for filtering files in the storage bucket.
+                Can be combined with target_file_name. Defaults to None.
+            target_file_name (str, optional): Specific file name to target.
+                If both target_file_name and storage_bucket_folder_path_prefix are provided, they will be combined (e.g., "data/file.csv").
+                If only target_file_name is provided, it will be used directly.
+                Only one file can be processed per batch transform job.
+            enable_web_search_grounding (Optional[bool]): Whether to enable web search. Defaults to False.
+            index_id (str): The id of the context index to search in, used in place of name if present
+            folder_key (str, optional): The folder key where the index resides. Defaults to None.
+            folder_path (str, optional): The folder path where the index resides. Defaults to None.
+
+        Returns:
+            BatchTransformCreationResponse: The batch transform task creation response.
+        """
+        if not (index_name or index_id):
+            raise ValueError("Index name or id is required")
+        if index_name and index_id:
+            raise ValueError("Index name or id are mutually exclusive")
+
+        if not index_id:
+            index = await self.retrieve_async(
+                index_name, folder_key=folder_key, folder_path=folder_path
+            )
+            if index and index.in_progress_ingestion():
+                raise IngestionInProgressException(index_name=index_name)
+            index_id = index.id
+            folder_key = folder_key or index.folder_key
+
+        spec = self._batch_transform_creation_spec(
+            index_id=index_id,
+            name=name,
+            storage_bucket_folder_path_prefix=storage_bucket_folder_path_prefix,
+            target_file_name=target_file_name,
+            prompt=prompt,
+            output_columns=output_columns,
+            enable_web_search_grounding=enable_web_search_grounding,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_batch_transform", run_type="uipath")
+    async def start_batch_transform_ephemeral(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: Annotated[
+            str | None, Field(max_length=512)
+        ] = None,
+        enable_web_search_grounding: bool = False,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+    ) -> BatchTransformCreationResponse:
+        """Asynchronously starts a Batch Transform, task on the targeted index.
+
+        Batch Transform tasks are processing and transforming csv files from the index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            prompt (str): Describe the task: what to research, what to synthesize.
+            output_columns (list[BatchTransformOutputColumn]):  The output columns to add into the csv.
+            storage_bucket_folder_path_prefix (str): The prefix pattern for filtering files in the storage bucket. Use "*" to include all files. Defaults to "*".
+            enable_web_search_grounding (Optional[bool]): Whether to enable web search. Defaults to False.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            BatchTransformCreationResponse: The batch transform task creation response.
+        """
+        spec = self._batch_transform_ephemeral_creation_spec(
+            index_id=index_id,
+            name=name,
+            storage_bucket_folder_path_prefix=storage_bucket_folder_path_prefix,
+            prompt=prompt,
+            output_columns=output_columns,
+            enable_web_search_grounding=enable_web_search_grounding,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_batch_transform_async", run_type="uipath")
+    async def start_batch_transform_ephemeral_async(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: Annotated[
+            str | None, Field(max_length=512)
+        ] = None,
+        enable_web_search_grounding: bool = False,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+    ) -> BatchTransformCreationResponse:
+        """Asynchronously starts a Batch Transform, task on the targeted index.
+
+        Batch Transform tasks are processing and transforming csv files from the index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            prompt (str): Describe the task: what to research, what to synthesize.
+            output_columns (list[BatchTransformOutputColumn]):  The output columns to add into the csv.
+            storage_bucket_folder_path_prefix (str): The prefix pattern for filtering files in the storage bucket. Use "*" to include all files. Defaults to "*".
+            enable_web_search_grounding (Optional[bool]): Whether to enable web search. Defaults to False.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            BatchTransformCreationResponse: The batch transform task creation response.
+        """
+        spec = self._batch_transform_ephemeral_creation_spec(
+            index_id=index_id,
+            name=name,
+            storage_bucket_folder_path_prefix=storage_bucket_folder_path_prefix,
+            prompt=prompt,
+            output_columns=output_columns,
+            enable_web_search_grounding=enable_web_search_grounding,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_retrieve_batch_transform", run_type="uipath")
+    def retrieve_batch_transform(
+        self,
+        id: str,
+        *,
+        index_name: str | None = None,
+    ) -> BatchTransformResponse:
+        """Retrieves a Batch Transform task status.
+
+        Args:
+            id (str): The id of the Batch Transform task.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Returns:
+            BatchTransformResponse: The Batch Transform task response.
+        """
+        spec = self._batch_transform_retrieve_spec(id=id)
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_retrieve_batch_transform_async", run_type="uipath")
+    async def retrieve_batch_transform_async(
+        self,
+        id: str,
+        *,
+        index_name: str | None = None,
+    ) -> BatchTransformResponse:
+        """Asynchronously retrieves a Batch Transform task status.
+
+        Args:
+            id (str): The id of the Batch Transform task.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Returns:
+            BatchTransformResponse: The Batch Transform task response.
+        """
+        spec = self._batch_transform_retrieve_spec(id=id)
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+        return BatchTransformResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_download_batch_transform_result", run_type="uipath")
+    def download_batch_transform_result(
+        self,
+        id: str,
+        destination_path: str,
+        *,
+        validate_status: bool = True,
+        index_name: str | None = None,
+    ) -> None:
+        """Downloads the Batch Transform result file to the specified path.
+
+        Args:
+            id (str): The id of the Batch Transform task.
+            destination_path (str): The local file path where the result file will be saved.
+            validate_status (bool): Whether to validate the batch transform status before downloading. Defaults to True.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Raises:
+            BatchTransformNotCompleteException: If validate_status is True and the batch transform is not complete.
+        """
+        if validate_status:
+            batch_transform = self.retrieve_batch_transform(
+                id=id, index_name=index_name
+            )
+            if batch_transform.last_batch_rag_status == BatchTransformStatus.FAILED:
+                raise BatchTransformFailedException(
+                    batch_transform_id=id,
+                )
+            if batch_transform.last_batch_rag_status != BatchTransformStatus.SUCCESSFUL:
+                raise BatchTransformNotCompleteException(
+                    batch_transform_id=id,
+                    status=batch_transform.last_batch_rag_status,
+                )
+
+        spec = self._batch_transform_get_read_uri_spec(id=id)
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            headers=spec.headers,
+        )
+        uri_response = BatchTransformReadUriResponse.model_validate(response.json())
+
+        Path(destination_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # SAS uris can be downloaded without authentication
+        # encrypted artifacts require authenticated DownloadBlob endpoint
+        with open(destination_path, "wb") as file:
+            if uri_response.is_encrypted:
+                download_spec = self._batch_transform_download_blob_spec(id=id)
+                download_response = self.request(
+                    download_spec.method,
+                    download_spec.endpoint,
+                    headers=download_spec.headers,
+                )
+                file_content = download_response.content
+            else:
+                with httpx.Client(**get_httpx_client_kwargs()) as client:
+                    file_content = client.get(uri_response.uri).content
+            file.write(file_content)
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(
+        name="contextgrounding_download_batch_transform_result_async", run_type="uipath"
+    )
+    async def download_batch_transform_result_async(
+        self,
+        id: str,
+        destination_path: str,
+        *,
+        validate_status: bool = True,
+        index_name: str | None = None,
+    ) -> None:
+        """Asynchronously downloads the Batch Transform result file to the specified path.
+
+        Args:
+            id (str): The id of the Batch Transform task.
+            destination_path (str): The local file path where the result file will be saved.
+            validate_status (bool): Whether to validate the batch transform status before downloading. Defaults to True.
+            index_name (Optional[str]): Index name hint for resource override.
+
+        Raises:
+            BatchTransformNotCompleteException: If validate_status is True and the batch transform is not complete.
+        """
+        if validate_status:
+            batch_transform = await self.retrieve_batch_transform_async(
+                id=id, index_name=index_name
+            )
+            if batch_transform.last_batch_rag_status == BatchTransformStatus.FAILED:
+                raise BatchTransformFailedException(
+                    batch_transform_id=id,
+                )
+            if batch_transform.last_batch_rag_status != BatchTransformStatus.SUCCESSFUL:
+                raise BatchTransformNotCompleteException(
+                    batch_transform_id=id,
+                    status=batch_transform.last_batch_rag_status,
+                )
+
+        spec = self._batch_transform_get_read_uri_spec(id=id)
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            headers=spec.headers,
+        )
+        uri_response = BatchTransformReadUriResponse.model_validate(response.json())
+
+        # SAS uris can be downloaded without authentication
+        # encrypted artifacts require authenticated DownloadBlob endpoint
+        if uri_response.is_encrypted:
+            download_spec = self._batch_transform_download_blob_spec(id=id)
+            download_response = await self.request_async(
+                download_spec.method,
+                download_spec.endpoint,
+                headers=download_spec.headers,
+            )
+            file_content = download_response.content
+        else:
+            async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
+                download_response = await client.get(uri_response.uri)
+                file_content = download_response.content
+
+        Path(destination_path).parent.mkdir(parents=True, exist_ok=True)
+
+        with open(destination_path, "wb") as file:
+            file.write(file_content)
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_deep_rag", run_type="uipath")
+    def start_deep_rag(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        glob_pattern: Annotated[str, Field(max_length=512, default="*")] = "**",
+        citation_mode: CitationMode = CitationMode.SKIP,
+        index_name: Annotated[str, Field(max_length=512)] | None = None,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> DeepRagCreationResponse:
+        """Starts a Deep RAG task on the targeted index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            index_name (str): The name of the context index to search in.
+            prompt (str): Describe the task: what to research across documents, what to synthesize and how to cite sources.
+            glob_pattern (str): The glob pattern to search in the index. Defaults to "**".
+            citation_mode (CitationMode): The citation mode to use. Defaults to SKIP.
+            folder_key (str, optional): The folder key where the index resides. Defaults to None.
+            folder_path (str, optional): The folder path where the index resides. Defaults to None.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            DeepRagCreationResponse: The Deep RAG task creation response.
+        """
+        if not (index_name or index_id):
+            raise ValueError("Index name or id is required")
+        if index_name and index_id:
+            raise ValueError("Index name or id are mutually exclusive")
+
+        if not index_id:
+            index = self.retrieve(
+                index_name, folder_key=folder_key, folder_path=folder_path
+            )
+            if index and index.in_progress_ingestion():
+                raise IngestionInProgressException(index_name=index_name)
+            index_id = index.id
+            folder_key = folder_key or index.folder_key
+
+        spec = self._deep_rag_creation_spec(
+            index_id=index_id,
+            name=name,
+            glob_pattern=glob_pattern,
+            prompt=prompt,
+            citation_mode=citation_mode,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return DeepRagCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_deep_rag_async", run_type="uipath")
+    async def start_deep_rag_async(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        glob_pattern: Annotated[str, Field(max_length=512, default="*")] = "**",
+        citation_mode: CitationMode = CitationMode.SKIP,
+        index_name: Annotated[str, Field(max_length=512)] | None = None,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> DeepRagCreationResponse:
+        """Asynchronously starts a Deep RAG task on the targeted index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            index_name (str): The name of the context index to search in.
+            name (str): The name of the Deep RAG task.
+            prompt (str): Describe the task: what to research across documents, what to synthesize and how to cite sources.
+            glob_pattern (str): The glob pattern to search in the index. Defaults to "**".
+            citation_mode (CitationMode): The citation mode to use. Defaults to SKIP.
+            folder_key (str, optional): The folder key where the index resides. Defaults to None.
+            folder_path (str, optional): The folder path where the index resides. Defaults to None.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            DeepRagCreationResponse: The Deep RAG task creation response.
+        """
+        if not (index_name or index_id):
+            raise ValueError("Index name or id is required")
+        if index_name and index_id:
+            raise ValueError("Index name or id are mutually exclusive")
+
+        if not index_id:
+            index = await self.retrieve_async(
+                index_name, folder_key=folder_key, folder_path=folder_path
+            )
+            if index and index.in_progress_ingestion():
+                raise IngestionInProgressException(index_name=index_name)
+            index_id = index.id
+            folder_key = folder_key or index.folder_key
+
+        spec = self._deep_rag_creation_spec(
+            index_id=index_id,
+            name=name,
+            glob_pattern=glob_pattern,
+            prompt=prompt,
+            citation_mode=citation_mode,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return DeepRagCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_deep_rag", run_type="uipath")
+    async def start_deep_rag_ephemeral(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        glob_pattern: Annotated[str, Field(max_length=512, default="*")] = "**",
+        citation_mode: CitationMode = CitationMode.SKIP,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+    ) -> DeepRagCreationResponse:
+        """Asynchronously starts a Deep RAG task on the targeted index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            name (str): The name of the Deep RAG task.
+            prompt (str): Describe the task: what to research across documents, what to synthesize and how to cite sources.
+            glob_pattern (str): The glob pattern to search in the index. Defaults to "**".
+            citation_mode (CitationMode): The citation mode to use. Defaults to SKIP.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            DeepRagCreationResponse: The Deep RAG task creation response.
+        """
+        spec = self._deep_rag_ephemeral_creation_spec(
+            index_id=index_id,
+            name=name,
+            glob_pattern=glob_pattern,
+            prompt=prompt,
+            citation_mode=citation_mode,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return DeepRagCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index", resource_identifier="index_name")
+    @traced(name="contextgrounding_start_deep_rag_async", run_type="uipath")
+    async def start_deep_rag_ephemeral_async(
+        self,
+        name: str,
+        prompt: Annotated[str, Field(max_length=250000)],
+        glob_pattern: Annotated[str, Field(max_length=512, default="*")] = "**",
+        citation_mode: CitationMode = CitationMode.SKIP,
+        index_id: Annotated[str, Field(max_length=512)] | None = None,
+    ) -> DeepRagCreationResponse:
+        """Asynchronously starts a Deep RAG task on the targeted index.
+
+        Args:
+            name (str): The name of the Deep RAG task.
+            name (str): The name of the Deep RAG task.
+            prompt (str): Describe the task: what to research across documents, what to synthesize and how to cite sources.
+            glob_pattern (str): The glob pattern to search in the index. Defaults to "**".
+            citation_mode (CitationMode): The citation mode to use. Defaults to SKIP.
+            index_id (str): The id of the context index to search in, used in place of name if present
+
+        Returns:
+            DeepRagCreationResponse: The Deep RAG task creation response.
+        """
+        spec = self._deep_rag_ephemeral_creation_spec(
+            index_id=index_id,
+            name=name,
+            glob_pattern=glob_pattern,
+            prompt=prompt,
+            citation_mode=citation_mode,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return DeepRagCreationResponse.model_validate(response.json())
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_search", run_type="uipath")
+    @deprecated("Use unified_search instead.")
+    def search(
+        self,
+        name: str,
+        query: str,
+        number_of_results: int = 10,
+        threshold: Optional[float] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingQueryResponse]:
+        """Search for contextual information within a specific index.
+
+        This method is deprecated. Use unified_search instead.
+
+        This method performs a semantic search against the specified context index,
+        helping to find relevant information that can be used in automation processes.
+        The search is powered by AI and understands natural language queries.
+
+        Args:
+            name (str): The name of the context index to search in.
+            query (str): The search query in natural language.
+            number_of_results (int, optional): Maximum number of results to return.
+                Defaults to 10.
+            threshold (float): Minimum similarity threshold. Defaults to 0.0.
+
+        Returns:
+            List[ContextGroundingQueryResponse]: A list of search results, each containing
+                relevant contextual information and metadata.
+        """
+        index = self.retrieve(name, folder_key=folder_key, folder_path=folder_path)
+        if index and index.in_progress_ingestion():
+            raise IngestionInProgressException(index_name=name)
+
+        folder_key = folder_key or index.folder_key
+
+        spec = self._search_spec(
+            name,
+            query,
+            number_of_results,
+            threshold=threshold if threshold is not None else 0.0,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
+            response.json()
+        )
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_search", run_type="uipath")
+    @deprecated("Use unified_search_async instead.")
+    async def search_async(
+        self,
+        name: str,
+        query: str,
+        number_of_results: int = 10,
+        threshold: Optional[float] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingQueryResponse]:
+        """Search asynchronously for contextual information within a specific index.
+
+        This method is deprecated. Use unified_search_async instead.
+
+        This method performs a semantic search against the specified context index,
+        helping to find relevant information that can be used in automation processes.
+        The search is powered by AI and understands natural language queries.
+
+        Args:
+            name (str): The name of the context index to search in.
+            query (str): The search query in natural language.
+            number_of_results (int, optional): Maximum number of results to return.
+                Defaults to 10.
+            threshold (float): Minimum similarity threshold. Defaults to 0.0.
+
+        Returns:
+            List[ContextGroundingQueryResponse]: A list of search results, each containing
+                relevant contextual information and metadata.
+        """
+        index = self.retrieve(
+            name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        if index and index.in_progress_ingestion():
+            raise IngestionInProgressException(index_name=name)
+
+        folder_key = folder_key or index.folder_key
+
+        spec = self._search_spec(
+            name,
+            query,
+            number_of_results,
+            threshold=threshold if threshold is not None else 0.0,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
+            response.json()
+        )
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_unified_search", run_type="uipath")
+    def unified_search(
+        self,
+        name: str,
+        query: str,
+        search_mode: SearchMode = SearchMode.SEMANTIC,
+        number_of_results: int = 10,
+        threshold: float = 0.0,
+        scope: Optional[UnifiedSearchScope] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        include_system_indexes: bool = False,
+    ) -> UnifiedQueryResult:
+        """Perform a unified search on a context grounding index.
+
+        This method performs a unified search (v1.2) against the specified context index,
+        supporting both semantic and tabular search modes.
+
+        Args:
+            name (str): The name of the context index to search in.
+            query (str): The search query in natural language.
+            search_mode (SearchMode): The search mode to use. Defaults to SEMANTIC.
+            number_of_results (int): Maximum number of results to return. Defaults to 10.
+            threshold (float): Minimum similarity threshold. Defaults to 0.0.
+            scope (Optional[UnifiedSearchScope]): Optional search scope (folder, extension).
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            include_system_indexes (bool): If True, fall back to tenant-wide
+                system indexes when the index is not found in folder or
+                across-folders listings. Defaults to False.
+
+        Returns:
+            UnifiedQueryResult: The unified search result containing semantic and/or tabular results.
+        """
+        index = self.retrieve(
+            name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            include_system_indexes=include_system_indexes,
+        )
+
+        folder_key = folder_key or index.folder_key
+
+        spec = self._unified_search_spec(
+            index_id=index.id,
+            query=query,
+            search_mode=search_mode,
+            number_of_results=number_of_results,
+            threshold=threshold,
+            scope=scope,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return UnifiedQueryResult.model_validate(response.json())
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_unified_search", run_type="uipath")
+    async def unified_search_async(
+        self,
+        name: str,
+        query: str,
+        search_mode: SearchMode = SearchMode.SEMANTIC,
+        number_of_results: int = 10,
+        threshold: float = 0.0,
+        scope: Optional[UnifiedSearchScope] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        include_system_indexes: bool = False,
+    ) -> UnifiedQueryResult:
+        """Asynchronously perform a unified search on a context grounding index.
+
+        This method performs a unified search (v1.2) against the specified context index,
+        supporting both semantic and tabular search modes.
+
+        Args:
+            name (str): The name of the context index to search in.
+            query (str): The search query in natural language.
+            search_mode (SearchMode): The search mode to use. Defaults to SEMANTIC.
+            number_of_results (int): Maximum number of results to return. Defaults to 10.
+            threshold (float): Minimum similarity threshold. Defaults to 0.0.
+            scope (Optional[UnifiedSearchScope]): Optional search scope (folder, extension).
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+            include_system_indexes (bool): If True, fall back to tenant-wide
+                system indexes when the index is not found in folder or
+                across-folders listings. Defaults to False.
+
+        Returns:
+            UnifiedQueryResult: The unified search result containing semantic and/or tabular results.
+        """
+        index = await self.retrieve_async(
+            name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            include_system_indexes=include_system_indexes,
+        )
+        if index and index.in_progress_ingestion():
+            raise IngestionInProgressException(index_name=name)
+
+        folder_key = folder_key or index.folder_key
+
+        spec = self._unified_search_spec(
+            index_id=index.id,
+            query=query,
+            search_mode=search_mode,
+            number_of_results=number_of_results,
+            threshold=threshold,
+            scope=scope,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return UnifiedQueryResult.model_validate(response.json())
+
+    @traced(name="contextgrounding_ingest_data", run_type="uipath")
+    def ingest_data(
+        self,
+        index: ContextGroundingIndex,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Ingest data into the context grounding index.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
+        if not index.id:
+            return
+        spec = self._ingest_spec(
+            index.id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        try:
+            self.request(
+                spec.method,
+                spec.endpoint,
+                headers=spec.headers,
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code != 409:
+                raise e
+            raise IngestionInProgressException(
+                index_name=index.name, search_operation=False
+            ) from e
+
+    @traced(name="contextgrounding_ingest_data", run_type="uipath")
+    async def ingest_data_async(
+        self,
+        index: ContextGroundingIndex,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously ingest data into the context grounding index.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
+        if not index.id:
+            return
+        spec = self._ingest_spec(
+            index.id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        try:
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                headers=spec.headers,
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code != 409:
+                raise e
+            raise IngestionInProgressException(
+                index_name=index.name, search_operation=False
+            ) from e
+
+    @traced(name="contextgrounding_delete_index", run_type="uipath")
+    def delete_index(
+        self,
+        index: ContextGroundingIndex,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete a context grounding index.
+
+        This method removes the specified context grounding index from Orchestrator.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
+        if not index.id:
+            return
+        spec = self._delete_by_id_spec(
+            index.id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        self.request(
+            spec.method,
+            spec.endpoint,
+            headers=spec.headers,
+        )
+
+    @traced(name="contextgrounding_delete_index", run_type="uipath")
+    async def delete_index_async(
+        self,
+        index: ContextGroundingIndex,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously delete a context grounding index.
+
+        This method removes the specified context grounding index from Orchestrator.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
+        if not index.id:
+            return
+        spec = self._delete_by_id_spec(
+            index.id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        await self.request_async(
+            spec.method,
+            spec.endpoint,
+            headers=spec.headers,
+        )
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_list", run_type="uipath")
+    def list_indexes(
+        self,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """List all context grounding indexes in a folder.
+
+        If no folder_key or folder_path is provided and no folder context is
+        configured, falls back to listing across all folders.
+
+        Args:
+            folder_key (Optional[str]): The key of the folder to list indexes from.
+            folder_path (Optional[str]): The path of the folder to list indexes from.
+
+        Returns:
+            List[ContextGroundingIndex]: A list of all indexes in the folder.
+        """
+        resolved_folder_key = self._resolve_folder_key(folder_key, folder_path)
+        if not resolved_folder_key:
+            return self.retrieve_across_folders()
+
+        spec = self._list_spec(folder_key=resolved_folder_key)
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item)
+            for item in response.get("value", [])
+        ]
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_list", run_type="uipath")
+    async def list_indexes_async(
+        self,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[ContextGroundingIndex]:
+        """Asynchronously list all context grounding indexes in a folder.
+
+        If no folder_key or folder_path is provided and no folder context is
+        configured, falls back to listing across all folders.
+
+        Args:
+            folder_key (Optional[str]): The key of the folder to list indexes from.
+            folder_path (Optional[str]): The path of the folder to list indexes from.
+
+        Returns:
+            List[ContextGroundingIndex]: A list of all indexes in the folder.
+        """
+        resolved_folder_key = self._resolve_folder_key(folder_key, folder_path)
+        if not resolved_folder_key:
+            return await self.retrieve_across_folders_async()
+
+        spec = self._list_spec(folder_key=resolved_folder_key)
+
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        return [
+            ContextGroundingIndex.model_validate(item)
+            for item in response.get("value", [])
+        ]
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_delete_by_name", run_type="uipath")
+    def delete_by_name(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete a context grounding index by its name.
+
+        This method retrieves the index by name and then deletes it.
+
+        Args:
+            name (str): The name of the context index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            Exception: If no index with the given name is found.
+        """
+        index = self.retrieve(name, folder_key=folder_key, folder_path=folder_path)
+        self.delete_index(index, folder_key=folder_key, folder_path=folder_path)
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_delete_by_name", run_type="uipath")
+    async def delete_by_name_async(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously delete a context grounding index by its name.
+
+        This method retrieves the index by name and then deletes it.
+
+        Args:
+            name (str): The name of the context index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            Exception: If no index with the given name is found.
+        """
+        index = await self.retrieve_async(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+        await self.delete_index_async(
+            index, folder_key=folder_key, folder_path=folder_path
+        )
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_ingest_by_name", run_type="uipath")
+    def ingest_by_name(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Trigger ingestion on a context grounding index by its name.
+
+        This method retrieves the index by name and then triggers data ingestion.
+
+        Args:
+            name (str): The name of the context index to ingest.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            Exception: If no index with the given name is found.
+            IngestionInProgressException: If ingestion is already in progress.
+        """
+        index = self.retrieve(name, folder_key=folder_key, folder_path=folder_path)
+        self.ingest_data(index, folder_key=folder_key, folder_path=folder_path)
+
+    @resource_override(resource_type="index")
+    @traced(name="contextgrounding_ingest_by_name", run_type="uipath")
+    async def ingest_by_name_async(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously trigger ingestion on a context grounding index by its name.
+
+        This method retrieves the index by name and then triggers data ingestion.
+
+        Args:
+            name (str): The name of the context index to ingest.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            Exception: If no index with the given name is found.
+            IngestionInProgressException: If ingestion is already in progress.
+        """
+        index = await self.retrieve_async(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+        await self.ingest_data_async(
+            index, folder_key=folder_key, folder_path=folder_path
+        )
+
+    def _ingest_spec(
+        self,
+        key: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{key}/ingest"),
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    @staticmethod
+    def _odata_name_filter(name: str) -> str:
+        """Build an OData ``Name eq '<name>'`` filter with single quotes escaped.
+
+        OData string literals escape ``'`` by doubling it. URL encoding of the
+        resulting filter is handled by the HTTP client when params are passed
+        as a dict.
+        """
+        return "Name eq '{}'".format(name.replace("'", "''"))
+
+    def _retrieve_across_folders_spec(
+        self,
+        name: Optional[str] = None,
+    ) -> RequestSpec:
+        params: Dict[str, str] = {
+            "$expand": "dataSource",
+        }
+        if name:
+            params["$filter"] = self._odata_name_filter(name)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/ecs_/v2/indexes/allacrossfolders"),
+            params=params,
+            headers={**header_job_key()},
+        )
+
+    def _retrieve_system_indexes_spec(
+        self,
+        name: Optional[str] = None,
+    ) -> RequestSpec:
+        params: Dict[str, str] = {
+            "$expand": "dataSource",
+        }
+        if name:
+            params["$filter"] = self._odata_name_filter(name)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/ecs_/v2/indexes/allsystemindexes"),
+            params=params,
+            headers={**header_job_key()},
+        )
+
+    def _list_spec(
+        self,
+        folder_key: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/ecs_/v2/indexes"),
+            params={
+                "$expand": "dataSource",
+            },
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _retrieve_spec(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/ecs_/v2/indexes"),
+            params={
+                "$filter": self._odata_name_filter(name),
+                "$expand": "dataSource",
+            },
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _create_spec(
+        self,
+        name: str,
+        description: Optional[str],
+        source: SourceConfig,
+        extraction_strategy: Optional[str] = None,
+        embeddings_enabled: Optional[bool] = None,
+        is_encrypted: Optional[bool] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        """Create request spec for index creation.
+
+        Args:
+            name: Index name
+            description: Index description
+            source: Source configuration (typed model) with optional indexer
+            extraction_strategy: Extraction method - "NativeV1" or "LLMV4"
+            embeddings_enabled: Whether to generate embeddings
+            is_encrypted: Whether to encrypt the index
+            folder_key: Optional folder key
+            folder_path: Optional folder path
+
+        Returns:
+            RequestSpec for the create index request
+        """
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        data_source_dict = self._build_data_source(source)
+
+        # Add indexer from source config if present
+        if source.indexer:
+            data_source_dict["indexer"] = source.indexer.model_dump(by_alias=True)
+
+        payload = CreateIndexPayload(
+            name=name,
+            description=description or "",
+            data_source=data_source_dict,
+            extraction_strategy=extraction_strategy,
+            embeddings_enabled=embeddings_enabled,
+            is_encrypted=is_encrypted,
+        )
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/ecs_/v2/indexes/create"),
+            json=payload.model_dump(by_alias=True, exclude_none=True),
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _create_ephemeral_spec(
+        self,
+        usage: str,
+        attachments: List[str],
+        folder_key: str | None = None,
+    ) -> RequestSpec:
+        """Create request spec for ephemeral index creation.
+
+        Args:
+            usage (str): The task in which the ephemeral index will be used for
+            attachments (list[str]): The list of attachments ids from which the ephemeral index will be created
+            folder_key (Optional[str]): The folder key to scope the ephemeral index to.
+
+        Returns:
+            RequestSpec for the create index request
+        """
+        data_source_dict = self._build_ephemeral_data_source(attachments)
+
+        payload = CreateEphemeralIndexPayload(
+            usage=usage,
+            data_source=data_source_dict,
+        )
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/ecs_/v2/indexes/createephemeral"),
+            json=payload.model_dump(by_alias=True, exclude_none=True),
+            headers={**header_folder(folder_key, None), **header_job_key()},
+        )
+
+    def _build_data_source(self, source: SourceConfig) -> Dict[str, Any]:
+        """Build data source configuration from typed source config.
+
+        Args:
+            source: Typed source configuration model
+
+        Returns:
+            Dictionary with data source configuration for API
+        """
+        file_name_glob = f"**/*.{source.file_type}" if source.file_type else "**/*"
+
+        data_source: Union[
+            BucketDataSource,
+            GoogleDriveDataSource,
+            DropboxDataSource,
+            OneDriveDataSource,
+            ConfluenceDataSource,
+        ]
+
+        if isinstance(source, BucketSourceConfig):
+            data_source = BucketDataSource(
+                folder=source.folder_path,
+                bucketName=source.bucket_name,
+                fileNameGlob=file_name_glob,
+                directoryPath=source.directory_path,
+            )
+        elif isinstance(source, GoogleDriveSourceConfig):
+            data_source = GoogleDriveDataSource(
+                folder=source.folder_path,
+                connectionId=source.connection_id,
+                connectionName=source.connection_name,
+                leafFolderId=source.leaf_folder_id,
+                directoryPath=source.directory_path,
+                fileNameGlob=file_name_glob,
+            )
+        elif isinstance(source, DropboxSourceConfig):
+            data_source = DropboxDataSource(
+                folder=source.folder_path,
+                connectionId=source.connection_id,
+                connectionName=source.connection_name,
+                directoryPath=source.directory_path,
+                fileNameGlob=file_name_glob,
+            )
+        elif isinstance(source, OneDriveSourceConfig):
+            data_source = OneDriveDataSource(
+                folder=source.folder_path,
+                connectionId=source.connection_id,
+                connectionName=source.connection_name,
+                leafFolderId=source.leaf_folder_id,
+                directoryPath=source.directory_path,
+                fileNameGlob=file_name_glob,
+            )
+        elif isinstance(source, ConfluenceSourceConfig):
+            data_source = ConfluenceDataSource(
+                folder=source.folder_path,
+                connectionId=source.connection_id,
+                connectionName=source.connection_name,
+                directoryPath=source.directory_path,
+                fileNameGlob=file_name_glob,
+                spaceId=source.space_id,
+            )
+        else:
+            raise ValueError(
+                f"Unsupported source configuration type: {type(source).__name__}"
+            )
+
+        return data_source.model_dump(by_alias=True, exclude_none=True)
+
+    def _build_ephemeral_data_source(self, attachments: List[str]) -> Dict[str, Any]:
+        """Build data source configuration from typed source config.
+
+        Args:
+            attachments (list[str]): The list of attachments ids from which the ephemeral index will be created
+
+        Returns:
+            Dictionary with data source configuration for API
+        """
+        data_source = AttachmentsDataSource(attachments=attachments)
+        return data_source.model_dump(
+            by_alias=True,
+            exclude_none=True,
+            mode="json",
+        )
+
+    def _retrieve_by_id_spec(
+        self,
+        id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{id}"),
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _delete_by_id_spec(
+        self,
+        id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="DELETE",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{id}"),
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _search_spec(
+        self,
+        name: str,
+        query: str,
+        number_of_results: int = 10,
+        threshold: float = 0.0,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/ecs_/v1/search"),
+            json={
+                "query": {
+                    "query": query,
+                    "numberOfResults": number_of_results,
+                    "threshold": threshold,
+                },
+                "schema": {"name": name},
+            },
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _unified_search_spec(
+        self,
+        index_id: str,
+        query: str,
+        search_mode: SearchMode = SearchMode.SEMANTIC,
+        number_of_results: int = 10,
+        threshold: float = 0.0,
+        scope: Optional[UnifiedSearchScope] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        json_body: Dict[str, Any] = {
+            "searchMode": search_mode.value
+            if isinstance(search_mode, SearchMode)
+            else search_mode,
+            "query": query,
+            "semanticSearchOptions": {
+                "numberOfResults": number_of_results,
+                "threshold": threshold,
+            },
+        }
+
+        if scope is not None:
+            json_body["scope"] = scope.model_dump(by_alias=True, exclude_none=True)
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v1.2/search/{index_id}"),
+            json=json_body,
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _deep_rag_creation_spec(
+        self,
+        index_id: str,
+        name: str,
+        glob_pattern: str,
+        prompt: str,
+        citation_mode: CitationMode,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{index_id}/createDeepRag"),
+            json={
+                "name": name,
+                "prompt": prompt,
+                "globPattern": glob_pattern,
+                "citationMode": citation_mode.value,
+            },
+            params={
+                "$select": "id,lastDeepRagStatus,createdDate",
+            },
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _deep_rag_ephemeral_creation_spec(
+        self,
+        index_id: str | None,
+        name: str,
+        glob_pattern: str,
+        prompt: str,
+        citation_mode: CitationMode,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{index_id}/createDeepRag"),
+            json={
+                "name": name,
+                "prompt": prompt,
+                "globPattern": glob_pattern,
+                "citationMode": citation_mode.value,
+            },
+            params={
+                "$select": "id,lastDeepRagStatus,createdDate",
+            },
+            headers={**header_job_key()},
+        )
+
+    def _batch_transform_creation_spec(
+        self,
+        index_id: str,
+        name: str,
+        enable_web_search_grounding: bool,
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: str | None,
+        target_file_name: str | None,
+        prompt: str,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_key, folder_path)
+
+        # determine targetFileGlobPattern based on the provided parameters:
+        # 1. if both target_file_name and storage_bucket_folder_path_prefix are provided, combine them
+        # 2. if only target_file_name is provided, use it directly
+        # 3. if only storage_bucket_folder_path_prefix is provided, use it with wildcard
+        # 4. default to "**" if neither is provided
+        if target_file_name and storage_bucket_folder_path_prefix:
+            target_file_glob_pattern = (
+                f"{storage_bucket_folder_path_prefix}/{target_file_name}"
+            )
+        elif target_file_name:
+            target_file_glob_pattern = target_file_name
+        elif storage_bucket_folder_path_prefix:
+            if storage_bucket_folder_path_prefix.endswith("/*"):
+                target_file_glob_pattern = storage_bucket_folder_path_prefix
+            else:
+                target_file_glob_pattern = f"{storage_bucket_folder_path_prefix}/*"
+        else:
+            target_file_glob_pattern = "**"
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{index_id}/createBatchRag"),
+            json={
+                "name": name,
+                "prompt": prompt,
+                "targetFileGlobPattern": target_file_glob_pattern,
+                "useWebSearchGrounding": enable_web_search_grounding,
+                "outputColumns": [
+                    column.model_dump(by_alias=True) for column in output_columns
+                ],
+            },
+            headers={
+                **header_folder(folder_key, None),
+                **header_job_key(),
+            },
+        )
+
+    def _batch_transform_ephemeral_creation_spec(
+        self,
+        index_id: str | None,
+        name: str,
+        enable_web_search_grounding: bool,
+        output_columns: List[BatchTransformOutputColumn],
+        storage_bucket_folder_path_prefix: str | None,
+        prompt: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"/ecs_/v2/indexes/{index_id}/createBatchRag"),
+            json={
+                "name": name,
+                "prompt": prompt,
+                "targetFileGlobPattern": f"{storage_bucket_folder_path_prefix}/*"
+                if storage_bucket_folder_path_prefix
+                else "**",
+                "useWebSearchGrounding": enable_web_search_grounding,
+                "outputColumns": [
+                    column.model_dump(by_alias=True) for column in output_columns
+                ],
+            },
+            headers={**header_job_key()},
+        )
+
+    def _deep_rag_retrieve_spec(
+        self,
+        id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/ecs_/v2/deeprag/{id}"),
+            params={
+                "$expand": "content",
+            },
+            headers={**header_job_key()},
+        )
+
+    def _batch_transform_retrieve_spec(
+        self,
+        id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/ecs_/v2/batchRag/{id}"),
+            headers={**header_job_key()},
+        )
+
+    def _batch_transform_get_read_uri_spec(
+        self,
+        id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/ecs_/v2/batchRag/{id}/GetReadUri"),
+            headers={**header_job_key()},
+        )
+
+    def _batch_transform_download_blob_spec(
+        self,
+        id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/ecs_/v2/batchRag/{id}/DownloadBlob"),
+            headers={**header_job_key()},
+        )
+
+    def _resolve_folder_key(self, folder_key, folder_path):
+        if folder_key is None and folder_path is not None:
+            folder_key = self._folders_service.retrieve_key(folder_path=folder_path)
+
+        if folder_key is None and folder_path is None:
+            folder_key = self._folder_key or (
+                self._folders_service.retrieve_key(folder_path=self._folder_path)
+                if self._folder_path
+                else None
+            )
+
+        return folder_key
+
+    def _extract_bucket_info(self, index: ContextGroundingIndex) -> Tuple[str, str]:
+        """Extract bucket information from the index, validating it's a storage bucket data source.
+
+        Args:
+            index: The context grounding index
+
+        Returns:
+            Tuple of (bucket_name, folder_path)
+
+        Raises:
+            UnsupportedDataSourceException: If the data source is not an Orchestrator Storage Bucket
+        """
+        if not index.data_source:
+            raise UnsupportedDataSourceException("add_to_index")
+
+        # Check if the data source has the @odata.type field indicating it's a storage bucket
+        data_source_dict = (
+            index.data_source.model_dump(by_alias=True)
+            if hasattr(index.data_source, "model_dump")
+            else index.data_source.__dict__
+        )
+        odata_type = data_source_dict.get("@odata.type") or data_source_dict.get(
+            "odata.type"
+        )
+
+        if odata_type and odata_type != ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE:
+            raise UnsupportedDataSourceException("add_to_index", odata_type)
+
+        # Try to extract bucket information
+        bucket_name = getattr(index.data_source, "bucketName", None)
+        folder = getattr(index.data_source, "folder", None)
+
+        if not bucket_name or not folder:
+            raise UnsupportedDataSourceException("add_to_index")
+
+        return bucket_name, folder
diff --git a/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding.py b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding.py
new file mode 100644
index 000000000..c5c0915bb
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding.py
@@ -0,0 +1,306 @@
+"""Context Grounding response payload models."""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BatchTransformOutputColumn(BaseModel):
+    """Model representing a batch transform output column."""
+
+    name: str = Field(
+        min_length=1,
+        max_length=500,
+        pattern=r"^[\w\s\.,!?-]+$",
+    )
+    description: str = Field(..., min_length=1, max_length=20000)
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+
+class CitationMode(str, Enum):
+    """Enum representing possible citation modes."""
+
+    SKIP = "Skip"
+    INLINE = "Inline"
+
+
+class EphemeralIndexUsage(str, Enum):
+    """Enum representing possible ephemeral index usage types."""
+
+    DEEP_RAG = "DeepRAG"
+    BATCH_RAG = "BatchRAG"
+
+
+class DeepRagStatus(str, Enum):
+    """Enum representing possible deep RAG tasks status."""
+
+    QUEUED = "Queued"
+    IN_PROGRESS = "InProgress"
+    SUCCESSFUL = "Successful"
+    FAILED = "Failed"
+
+
+class IndexStatus(str, Enum):
+    """Enum representing possible index tasks status."""
+
+    QUEUED = "Queued"
+    IN_PROGRESS = "InProgress"
+    SUCCESSFUL = "Successful"
+    FAILED = "Failed"
+
+
+class Citation(BaseModel):
+    """Model representing a deep RAG citation."""
+
+    ordinal: int
+    page_number: int = Field(alias="pageNumber")
+    source: str
+    reference: str
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+
+class DeepRagContent(BaseModel):
+    """Model representing a deep RAG task content."""
+
+    text: str
+    citations: list[Citation]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+
+class DeepRagResponse(BaseModel):
+    """Model representing a deep RAG task response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    id: str
+    name: str
+    created_date: str = Field(alias="createdDate")
+    last_deep_rag_status: DeepRagStatus = Field(alias="lastDeepRagStatus")
+    content: DeepRagContent | None = Field(alias="content")
+    failure_reason: str | None = Field(alias="failureReason", default=None)
+
+
+class BatchTransformStatus(str, Enum):
+    """Enum representing possible batch transform status values."""
+
+    IN_PROGRESS = "InProgress"
+    SUCCESSFUL = "Successful"
+    QUEUED = "Queued"
+    FAILED = "Failed"
+
+
+class BatchTransformCreationResponse(BaseModel):
+    """Model representing a batch transform task creation response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+    )
+    id: str
+    last_batch_rag_status: DeepRagStatus = Field(alias="lastBatchRagStatus")
+    error_message: str | None = Field(alias="errorMessage", default=None)
+
+
+class BatchTransformResponse(BaseModel):
+    """Model representing a batch transform task response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+    )
+    id: str
+    name: str
+    last_batch_rag_status: BatchTransformStatus = Field(alias="lastBatchRagStatus")
+    prompt: str
+    target_file_glob_pattern: str = Field(alias="targetFileGlobPattern")
+    use_web_search_grounding: bool = Field(alias="useWebSearchGrounding")
+    output_columns: list[BatchTransformOutputColumn] = Field(alias="outputColumns")
+    created_date: str = Field(alias="createdDate")
+
+
+class BatchTransformReadUriResponse(BaseModel):
+    """Model representing a batch transform result file download URI response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+    )
+    uri: str
+    is_encrypted: bool = Field(alias="isEncrypted", default=False)
+
+
+class DeepRagCreationResponse(BaseModel):
+    """Model representing a deep RAG task creation response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    id: str
+    last_deep_rag_status: DeepRagStatus = Field(alias="lastDeepRagStatus")
+    created_date: str = Field(alias="createdDate")
+
+
+class ContextGroundingMetadata(BaseModel):
+    """Model representing metadata for a Context Grounding query response."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    operation_id: str = Field(alias="operation_id")
+    strategy: str = Field(alias="strategy")
+
+
+class ContextGroundingQueryResponse(BaseModel):
+    """Model representing a Context Grounding query response item."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    source: str = Field(alias="source")
+    page_number: str = Field(alias="page_number")
+    content: str = Field(alias="content")
+    metadata: ContextGroundingMetadata = Field(alias="metadata")
+    source_document_id: Optional[str] = Field(default=None, alias="source_document_id")
+    caption: Optional[str] = Field(default=None, alias="caption")
+    score: Optional[float] = Field(default=None, alias="score")
+    reference: Optional[str] = Field(default=None, alias="reference")
+
+
+class ContextGroundingSearchResultItem(BaseModel):
+    """Model representing a value item in a unified search (v1.2) semantic result."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    id: Optional[str | int] = Field(default=None, alias="id")
+    content: str = Field(alias="content")
+    source: str = Field(alias="source")
+    page_number: int | str = Field(alias="page_number")
+    score: Optional[float] = Field(default=None, alias="score")
+    reference: Optional[str] = Field(default=None, alias="reference")
+    source_document_id: Optional[str] = Field(default=None, alias="source_document_id")
+    dataset_id: Optional[str] = Field(default=None, alias="dataset_id")
+    datasource_id: Optional[str] = Field(default=None, alias="datasource_id")
+    source_document_sha256: Optional[str] = Field(
+        default=None, alias="source_document_sha256"
+    )
+    caption: Optional[str] = Field(default=None, alias="caption")
+
+
+class SearchMode(str, Enum):
+    """Enum representing possible unified search modes."""
+
+    SEMANTIC = "Semantic"
+
+
+class UnifiedSearchScope(BaseModel):
+    """Model representing the scope for a unified search request."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    folder: Optional[str] = Field(default=None)
+    extension: Optional[str] = Field(default=None)
+
+
+class SemanticSearchOptions(BaseModel):
+    """Model representing semantic search options for a unified search request."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    number_of_results: int = Field(default=3, alias="numberOfResults")
+    threshold: float = Field(default=0.0)
+
+
+class SemanticSearchResult(BaseModel):
+    """Model representing a semantic search result from a unified search."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    values: list[ContextGroundingSearchResultItem] = Field(
+        default_factory=list, alias="values"
+    )
+    metadata: Optional[ContextGroundingMetadata] = Field(default=None, alias="metadata")
+
+
+class UnifiedQueryResult(BaseModel):
+    """Model representing the result of a unified search query."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    semantic_results: Optional[SemanticSearchResult] = Field(
+        default=None, alias="semanticResults"
+    )
+    explanation: Optional[str] = Field(default=None)
diff --git a/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_index.py b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_index.py
new file mode 100644
index 000000000..a37f2e457
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_index.py
@@ -0,0 +1,94 @@
+"""Models for Context Grounding Index in the UiPath platform."""
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+
+class ContextGroundingDataSource(BaseModel):
+    """Model representing a data source in a Context Grounding Index."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    id: Optional[str] = Field(default=None, alias="id")
+    folder: Optional[str] = Field(default=None, alias="folder")
+    bucketName: Optional[str] = Field(default=None, alias="bucketName")
+
+
+class ContextGroundingIndexHealth(BaseModel):
+    """Model representing health metrics for a Context Grounding Index."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        extra="allow",
+    )
+
+    schema_id: Optional[str] = Field(default=None, alias="schemaId")
+    ingestion_reliability_score: Optional[float] = Field(
+        default=None, alias="ingestionReliabilityScore"
+    )
+    utilization_score: Optional[float] = Field(default=None, alias="utilizationScore")
+    overall_health_score: Optional[float] = Field(
+        default=None, alias="overallHealthScore"
+    )
+    health_status: Optional[str] = Field(default=None, alias="healthStatus")
+
+
+class ContextGroundingIndex(BaseModel):
+    """Model representing a Context Grounding Index in the UiPath platform."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    @field_serializer("last_ingested", "last_queried")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
+    id: Optional[str] = Field(default=None, alias="id")
+    name: Optional[str] = Field(default=None, alias="name")
+    description: Optional[str] = Field(default=None, alias="description")
+    is_encrypted: Optional[bool] = Field(default=None, alias="isEncrypted")
+    folder_fully_qualified_name: Optional[str] = Field(
+        default=None, alias="folderFullyQualifiedName"
+    )
+    memory_usage: Optional[int] = Field(default=None, alias="memoryUsage")
+    disk_usage: Optional[int] = Field(default=None, alias="diskUsage")
+    extraction_strategy: Optional[str] = Field(default=None, alias="extractionStrategy")
+    embeddings_enabled: Optional[bool] = Field(default=None, alias="embeddingsEnabled")
+    data_source: Optional[ContextGroundingDataSource] = Field(
+        default=None, alias="dataSource"
+    )
+    last_ingestion_status: Optional[str] = Field(
+        default=None, alias="lastIngestionStatus"
+    )
+    last_ingestion_failure_reason: Optional[str] = Field(
+        default=None, alias="lastIngestionFailureReason"
+    )
+    last_ingested: Optional[datetime] = Field(default=None, alias="lastIngested")
+    last_queried: Optional[datetime] = Field(default=None, alias="lastQueried")
+    folder_key: Optional[str] = Field(default=None, alias="folderKey")
+    index_health: Optional[ContextGroundingIndexHealth] = Field(
+        default=None, alias="indexHealth"
+    )
+
+    def in_progress_ingestion(self):
+        """Check if the last ingestion is in progress."""
+        return (
+            self.last_ingestion_status == "Queued"
+            or self.last_ingestion_status == "InProgress"
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_payloads.py b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_payloads.py
new file mode 100644
index 000000000..a28903462
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/context_grounding/context_grounding_payloads.py
@@ -0,0 +1,238 @@
+"""Payload models for context grounding index creation and configuration."""
+
+import re
+from typing import Any, Dict, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic.alias_generators import to_camel
+
+from uipath.platform.common.constants import (
+    CONFLUENCE_DATA_SOURCE_REQUEST,
+    DROPBOX_DATA_SOURCE_REQUEST,
+    GOOGLE_DRIVE_DATA_SOURCE_REQUEST,
+    ONEDRIVE_DATA_SOURCE_REQUEST,
+    ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE_REQUEST,
+)
+
+
+class BaseDataSource(BaseModel):
+    """Base model for data source configurations."""
+
+    folder: str = Field(alias="folder", description="Folder path")
+    file_name_glob: str = Field(
+        alias="fileNameGlob", description="File name glob pattern"
+    )
+    directory_path: str = Field(alias="directoryPath", description="Directory path")
+
+
+class BucketDataSource(BaseDataSource):
+    """Data source configuration for storage buckets."""
+
+    odata_type: str = Field(
+        alias="@odata.type",
+        default=ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE_REQUEST,
+    )
+    bucket_name: str = Field(alias="bucketName", description="Storage bucket name")
+
+
+class GoogleDriveDataSource(BaseDataSource):
+    """Data source configuration for Google Drive."""
+
+    odata_type: str = Field(
+        alias="@odata.type",
+        default=GOOGLE_DRIVE_DATA_SOURCE_REQUEST,
+    )
+    connection_id: str = Field(alias="connectionId", description="Connection ID")
+    connection_name: str = Field(alias="connectionName", description="Connection name")
+    leaf_folder_id: str = Field(alias="leafFolderId", description="Leaf folder ID")
+
+
+class DropboxDataSource(BaseDataSource):
+    """Data source configuration for Dropbox."""
+
+    odata_type: str = Field(
+        alias="@odata.type",
+        default=DROPBOX_DATA_SOURCE_REQUEST,
+    )
+    connection_id: str = Field(alias="connectionId", description="Connection ID")
+    connection_name: str = Field(alias="connectionName", description="Connection name")
+
+
+class OneDriveDataSource(BaseDataSource):
+    """Data source configuration for OneDrive."""
+
+    odata_type: str = Field(
+        alias="@odata.type",
+        default=ONEDRIVE_DATA_SOURCE_REQUEST,
+    )
+    connection_id: str = Field(alias="connectionId", description="Connection ID")
+    connection_name: str = Field(alias="connectionName", description="Connection name")
+    leaf_folder_id: str = Field(alias="leafFolderId", description="Leaf folder ID")
+
+
+class ConfluenceDataSource(BaseDataSource):
+    """Data source configuration for Confluence."""
+
+    odata_type: str = Field(
+        alias="@odata.type",
+        default=CONFLUENCE_DATA_SOURCE_REQUEST,
+    )
+    connection_id: str = Field(alias="connectionId", description="Connection ID")
+    connection_name: str = Field(alias="connectionName", description="Connection name")
+    space_id: str = Field(alias="spaceId", description="Space ID")
+
+
+class AttachmentsDataSource(BaseModel):
+    """Data source configuration for Attachments."""
+
+    attachments: list[str] = Field(description="List of attachment ids")
+
+
+class Indexer(BaseModel):
+    """Configuration for periodic indexing of data sources."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    cron_expression: str = Field(description="Cron expression for scheduling")
+    time_zone_id: str = Field(default="UTC", description="Time zone ID")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_cron(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate cron expression format."""
+        cron_expr = values.get("cron_expression") or values.get("cronExpression")
+        if not cron_expr:
+            return values
+
+        # Supports @aliases, @every syntax and standard cron expressions with 5-7 fields
+        cron_pattern = r"^(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*) ?){5,7})$"
+
+        if not re.match(cron_pattern, cron_expr.strip(), re.IGNORECASE):
+            raise ValueError(f"Invalid cron expression format: '{cron_expr}'")
+
+        return values
+
+
+class CreateIndexPayload(BaseModel):
+    """Payload for creating a context grounding index.
+
+    Note: data_source is Dict[str, Any] because it may contain additional
+    fields like 'indexer' that are added dynamically based on configuration.
+    The data source is still validated through the _build_data_source method
+    which uses typed models internally.
+    """
+
+    name: str = Field(description="Index name")
+    description: str = Field(default="", description="Index description")
+    data_source: Dict[str, Any] = Field(
+        alias="dataSource", description="Data source configuration"
+    )
+    extraction_strategy: Optional[str] = Field(
+        default=None,
+        alias="extractionStrategy",
+        description="Extraction method: 'NativeV1' or 'LLMV4'. Defaults to NativeV1",
+    )
+    embeddings_enabled: Optional[bool] = Field(
+        default=None,
+        alias="embeddingsEnabled",
+        description="Whether to generate embeddings. Defaults to true",
+    )
+    is_encrypted: Optional[bool] = Field(
+        default=None,
+        alias="isEncrypted",
+        description="Whether to encrypt the index. Defaults to false",
+    )
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class CreateEphemeralIndexPayload(BaseModel):
+    """Payload for creating an ephemeral context grounding index.
+
+    Note: data_source is Dict[str, Any] because it may contain additional
+    fields like 'indexer' that are added dynamically based on configuration.
+    The data source is still validated through the _build_data_source method
+    which uses typed models internally.
+    """
+
+    usage: str = Field(description="Index usage")
+    data_source: Dict[str, Any] = Field(
+        alias="dataSource", description="Data source configuration"
+    )
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+# user-facing source configuration models
+class BaseSourceConfig(BaseModel):
+    """Base configuration for all source types."""
+
+    folder_path: str = Field(description="Folder path in orchestrator")
+    directory_path: str = Field(description="Directory path")
+    file_type: Optional[str] = Field(
+        default=None, description="File type filter (e.g., 'pdf', 'txt')"
+    )
+    indexer: Optional[Indexer] = Field(
+        default=None, description="Optional indexer configuration for periodic updates"
+    )
+
+
+class ConnectionSourceConfig(BaseSourceConfig):
+    """Base configuration for sources that use connections."""
+
+    connection_id: str = Field(description="Connection ID")
+    connection_name: str = Field(description="Connection name")
+
+
+class BucketSourceConfig(BaseSourceConfig):
+    """Data source configuration for storage buckets."""
+
+    type: Literal["bucket"] = Field(
+        default="bucket", description="Source type identifier"
+    )
+    bucket_name: str = Field(description="Storage bucket name")
+    directory_path: str = Field(default="/", description="Directory path in bucket")
+
+
+class GoogleDriveSourceConfig(ConnectionSourceConfig):
+    """Data source configuration for Google Drive."""
+
+    type: Literal["google_drive"] = Field(
+        default="google_drive", description="Source type identifier"
+    )
+    leaf_folder_id: str = Field(description="Leaf folder ID in Google Drive")
+
+
+class DropboxSourceConfig(ConnectionSourceConfig):
+    """Data source configuration for Dropbox."""
+
+    type: Literal["dropbox"] = Field(
+        default="dropbox", description="Source type identifier"
+    )
+
+
+class OneDriveSourceConfig(ConnectionSourceConfig):
+    """Data source configuration for OneDrive."""
+
+    type: Literal["onedrive"] = Field(
+        default="onedrive", description="Source type identifier"
+    )
+    leaf_folder_id: str = Field(description="Leaf folder ID in OneDrive")
+
+
+class ConfluenceSourceConfig(ConnectionSourceConfig):
+    """Data source configuration for Confluence."""
+
+    type: Literal["confluence"] = Field(
+        default="confluence", description="Source type identifier"
+    )
+    space_id: str = Field(description="Confluence space ID")
+
+
+SourceConfig = Union[
+    BucketSourceConfig,
+    GoogleDriveSourceConfig,
+    DropboxSourceConfig,
+    OneDriveSourceConfig,
+    ConfluenceSourceConfig,
+]
diff --git a/packages/uipath-platform/src/uipath/platform/documents/__init__.py b/packages/uipath-platform/src/uipath/platform/documents/__init__.py
new file mode 100644
index 000000000..78f4b9156
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/documents/__init__.py
@@ -0,0 +1,50 @@
+"""UiPath Documents Models.
+
+This module contains models related to UiPath Document Understanding service.
+"""
+
+from ._documents_service import DocumentsService  # type: ignore[attr-defined]
+from .documents import (
+    ActionPriority,
+    ClassificationResponse,
+    ClassificationResult,
+    DocumentBounds,
+    ExtractionResponse,
+    ExtractionResponseIXP,
+    ExtractionResult,
+    FieldGroupValueProjection,
+    FieldType,
+    FieldValueProjection,
+    FileContent,
+    ProjectType,
+    Reference,
+    StartExtractionResponse,
+    StartExtractionValidationResponse,
+    StartOperationResponse,
+    ValidateClassificationAction,
+    ValidateExtractionAction,
+    ValidationAction,
+)
+
+__all__ = [
+    "DocumentsService",
+    "FieldType",
+    "ActionPriority",
+    "ProjectType",
+    "FieldValueProjection",
+    "FieldGroupValueProjection",
+    "ExtractionResult",
+    "ExtractionResponse",
+    "ExtractionResponseIXP",
+    "ValidationAction",
+    "ValidateClassificationAction",
+    "ValidateExtractionAction",
+    "Reference",
+    "DocumentBounds",
+    "ClassificationResult",
+    "ClassificationResponse",
+    "FileContent",
+    "StartExtractionResponse",
+    "StartOperationResponse",
+    "StartExtractionValidationResponse",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/documents/_documents_service.py b/packages/uipath-platform/src/uipath/platform/documents/_documents_service.py
new file mode 100644
index 000000000..2dd865cef
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/documents/_documents_service.py
@@ -0,0 +1,2566 @@
+# type: ignore # this is riddled with typing issues -- fix this later.
+import asyncio
+import time
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple, Union
+from uuid import UUID
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext
+from ..common._models import Endpoint
+from ..errors import OperationFailedException, OperationNotCompleteException
+from .documents import (
+    ActionPriority,
+    ClassificationResponse,
+    ClassificationResult,
+    ExtractionResponse,
+    ExtractionResponseIXP,
+    FileContent,
+    ProjectType,
+    StartExtractionResponse,
+    StartExtractionValidationResponse,
+    ValidateClassificationAction,
+    ValidateExtractionAction,
+)
+
+POLLING_INTERVAL = 2  # seconds
+POLLING_TIMEOUT = 300  # seconds
+
+
+def _must_not_be_provided(**kwargs: Any) -> None:
+    for name, value in kwargs.items():
+        if value is not None:
+            raise ValueError(f"`{name}` must not be provided")
+
+
+def _must_be_provided(**kwargs: Any) -> None:
+    for name, value in kwargs.items():
+        if value is None:
+            raise ValueError(f"`{name}` must be provided")
+
+
+def _exactly_one_must_be_provided(**kwargs: Any) -> None:
+    provided = [name for name, value in kwargs.items() if value is not None]
+    if len(provided) != 1:
+        raise ValueError(
+            f"Exactly one of `{', '.join(kwargs.keys())}` must be provided"
+        )
+
+
+def _validate_classify_params(
+    project_type: ProjectType,
+    tag: Optional[str],
+    version: Optional[int],
+    project_name: Optional[str],
+    file: Optional[FileContent],
+    file_path: Optional[str],
+) -> None:
+    _exactly_one_must_be_provided(file=file, file_path=file_path)
+    if project_type == ProjectType.PRETRAINED:
+        _must_not_be_provided(
+            project_name=project_name,
+            tag=tag,
+            version=version,
+        )
+    else:
+        _must_be_provided(
+            project_name=project_name,
+        )
+        _exactly_one_must_be_provided(tag=tag, version=version)
+
+
+def _validate_extract_params_and_get_project_type(
+    tag: Optional[str],
+    version: Optional[int],
+    project_name: Optional[str],
+    file: Optional[FileContent],
+    file_path: Optional[str],
+    classification_result: Optional[ClassificationResult],
+    project_type: Optional[ProjectType],
+    document_type_name: Optional[str],
+) -> ProjectType:
+    if file or file_path:
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+        _must_be_provided(project_type=project_type)
+        _must_not_be_provided(
+            classification_result=classification_result,
+        )
+
+        if project_type == ProjectType.PRETRAINED:
+            _must_not_be_provided(tag=tag, project_name=project_name, version=version)
+            _must_be_provided(document_type_name=document_type_name)
+        elif project_type == ProjectType.MODERN:
+            _must_be_provided(
+                project_name=project_name,
+                document_type_name=document_type_name,
+            )
+            _exactly_one_must_be_provided(version=version, tag=tag)
+        else:
+            _must_be_provided(project_name=project_name)
+            _exactly_one_must_be_provided(version=version, tag=tag)
+            _must_not_be_provided(document_type_name=document_type_name)
+    else:
+        _must_be_provided(classification_result=classification_result)
+        _must_not_be_provided(
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            project_type=project_type,
+            file=file,
+            file_path=file_path,
+            document_type_name=document_type_name,
+        )
+        project_type = classification_result.project_type
+
+    return project_type
+
+
+class DocumentsService(FolderContext, BaseService):
+    """Service for managing UiPath DocumentUnderstanding Document Operations.
+
+    This service provides methods to extract data from documents using UiPath's Document Understanding capabilities.
+
+    !!! warning "Preview Feature"
+        This function is currently experimental.
+        Behavior and parameters are subject to change in future versions.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        polling_interval: float = POLLING_INTERVAL,
+        polling_timeout: float = POLLING_TIMEOUT,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self.polling_interval = polling_interval
+        self.polling_timeout = polling_timeout
+
+    def _get_common_headers(self) -> Dict[str, str]:
+        return {
+            "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+        }
+
+    def _get_classifier_id(
+        self, project_type: ProjectType, project_id: str, version: Optional[int]
+    ) -> Optional[str]:
+        if project_type == ProjectType.PRETRAINED:
+            return "ml-classification"
+
+        if version is None:
+            return None
+
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/classifiers"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                classifier["id"]
+                for classifier in response.json().get("classifiers", [])
+                if classifier["projectVersion"] == version
+            )
+        except StopIteration:
+            raise ValueError(f"Classifier for version '{version}' not found.") from None
+
+    async def _get_classifier_id_async(
+        self, project_type: ProjectType, project_id: str, version: Optional[int]
+    ) -> Optional[str]:
+        if project_type == ProjectType.PRETRAINED:
+            return "ml-classification"
+
+        if version is None:
+            return None
+
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/classifiers"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                classifier["id"]
+                for classifier in response.json().get("classifiers", [])
+                if classifier["projectVersion"] == version
+            )
+        except StopIteration:
+            raise ValueError(f"Classifier for version '{version}' not found.") from None
+
+    def _get_extractor_id(
+        self,
+        project_id: str,
+        version: Optional[int],
+        document_type_id: str,
+        project_type: ProjectType,
+    ) -> str:
+        if project_type == ProjectType.PRETRAINED:
+            return document_type_id
+
+        if version is None:
+            return None
+
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/extractors"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("extractors", [])
+                if extractor["projectVersion"] == version
+                and extractor["documentTypeId"] == document_type_id
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Extractor for version '{version}' and document type id '{document_type_id}' not found."
+            ) from None
+
+    async def _get_extractor_id_async(
+        self,
+        project_id: str,
+        version: Optional[int],
+        document_type_id: str,
+        project_type: ProjectType,
+    ) -> str:
+        if project_type == ProjectType.PRETRAINED:
+            return document_type_id
+
+        if version is None:
+            return None
+
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/extractors"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("extractors", [])
+                if extractor["projectVersion"] == version
+                and extractor["documentTypeId"] == document_type_id
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Extractor for version '{version}' and document type id '{document_type_id}' not found."
+            ) from None
+
+    def _get_project_id(
+        self,
+        project_type: ProjectType,
+        project_name: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if project_type == ProjectType.PRETRAINED:
+            return str(UUID(int=0))
+
+        if classification_result is not None:
+            return classification_result.project_id
+
+        response = self.request(
+            "GET",
+            url=Endpoint("/du_/api/framework/projects"),
+            params={"api-version": 1.1, "type": project_type.value},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                project["id"]
+                for project in response.json()["projects"]
+                if project["name"] == project_name
+            )
+        except StopIteration:
+            raise ValueError(f"Project '{project_name}' not found.") from None
+
+    async def _get_project_id_async(
+        self,
+        project_type: ProjectType,
+        project_name: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if project_type == ProjectType.PRETRAINED:
+            return str(UUID(int=0))
+
+        if classification_result is not None:
+            return classification_result.project_id
+
+        response = await self.request_async(
+            "GET",
+            url=Endpoint("/du_/api/framework/projects"),
+            params={"api-version": 1.1, "type": project_type.value},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                project["id"]
+                for project in response.json()["projects"]
+                if project["name"] == project_name
+            )
+        except StopIteration:
+            raise ValueError(f"Project '{project_name}' not found.") from None
+
+    def _get_project_tags(self, project_id: str) -> Set[str]:
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/tags"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+        return {tag["name"] for tag in response.json().get("tags", [])}
+
+    async def _get_project_tags_async(self, project_id: str) -> Set[str]:
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/tags"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+        return {tag["name"] for tag in response.json().get("tags", [])}
+
+    def _get_document_id(
+        self,
+        project_id: Optional[str],
+        file: Optional[FileContent],
+        file_path: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if classification_result is not None:
+            return classification_result.document_id
+
+        document_id = self._start_digitization(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+        )
+        self._wait_for_digitization(
+            project_id=project_id,
+            document_id=document_id,
+        )
+
+        return document_id
+
+    async def _get_document_id_async(
+        self,
+        project_id: Optional[str],
+        file: Optional[FileContent],
+        file_path: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if classification_result is not None:
+            return classification_result.document_id
+
+        document_id = await self._start_digitization_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+        )
+        await self._wait_for_digitization_async(
+            project_id=project_id,
+            document_id=document_id,
+        )
+
+        return document_id
+
+    def _get_version(
+        self,
+        version: Optional[int],
+        project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
+    ) -> Optional[int]:
+        if project_type == ProjectType.PRETRAINED:
+            return None
+
+        if version is not None:
+            return version
+
+        if classification_result is None or classification_result.classifier_id is None:
+            return None
+
+        return self.request(
+            "GET",
+            url=Endpoint(
+                f"/du_/api/framework/projects/{classification_result.project_id}/classifiers/{classification_result.classifier_id}"
+            ),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        ).json()["projectVersion"]
+
+    async def _get_version_async(
+        self,
+        version: Optional[int],
+        project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
+    ) -> Optional[int]:
+        if project_type == ProjectType.PRETRAINED:
+            return None
+
+        if version is not None:
+            return version
+
+        if classification_result is None or classification_result.classifier_id is None:
+            return None
+
+        return (
+            await self.request_async(
+                "GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{classification_result.project_id}/classifiers/{classification_result.classifier_id}"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            )
+        ).json()["projectVersion"]
+
+    def _get_tag(
+        self,
+        project_type: ProjectType,
+        project_id: str,
+        tag: Optional[str],
+        version: Optional[int],
+        project_name: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> Optional[str]:
+        if project_type == ProjectType.PRETRAINED:
+            return None
+
+        if version is not None:
+            return None
+
+        if classification_result is not None:
+            return classification_result.tag
+
+        tags = self._get_project_tags(project_id)
+        if tag not in tags:
+            raise ValueError(
+                f"Tag '{tag}' not found in project '{project_name}'. Available tags: {tags}"
+            )
+
+        return tag
+
+    async def _get_tag_async(
+        self,
+        project_type: ProjectType,
+        project_id: str,
+        tag: Optional[str],
+        version: Optional[int],
+        project_name: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> Optional[str]:
+        if project_type == ProjectType.PRETRAINED:
+            return None
+
+        if version is not None:
+            return None
+
+        if classification_result is not None:
+            return classification_result.tag
+
+        tags = await self._get_project_tags_async(project_id)
+        if tag not in tags:
+            raise ValueError(
+                f"Tag '{tag}' not found in project '{project_name}'. Available tags: {tags}"
+            )
+
+        return tag
+
+    def _start_digitization(
+        self,
+        project_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> str:
+        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
+            return self.request(
+                "POST",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/digitization/start"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                files={"File": handle},
+            ).json()["documentId"]
+
+    async def _start_digitization_async(
+        self,
+        project_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> str:
+        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
+            return (
+                await self.request_async(
+                    "POST",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/digitization/start"
+                    ),
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                    files={"File": handle},
+                )
+            ).json()["documentId"]
+
+    def _wait_for_digitization(self, project_id: str, document_id: str) -> None:
+        def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = self.request(
+                method="GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/digitization/result/{document_id}"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+    async def _wait_for_digitization_async(
+        self, project_id: str, document_id: str
+    ) -> None:
+        async def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/digitization/result/{document_id}"
+                    ),
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                )
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+    def _get_document_type_id(
+        self,
+        project_id: str,
+        document_type_name: Optional[str],
+        project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if project_type == ProjectType.IXP:
+            return str(UUID(int=0))
+
+        if classification_result is not None:
+            return classification_result.document_type_id
+
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("documentTypes", [])
+                if extractor["name"].lower() == document_type_name.lower()
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Document type '{document_type_name}' not found."
+            ) from None
+
+    async def _get_document_type_id_async(
+        self,
+        project_id: str,
+        document_type_name: Optional[str],
+        project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if project_type == ProjectType.IXP:
+            return str(UUID(int=0))
+
+        if classification_result is not None:
+            return classification_result.document_type_id
+
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("documentTypes", [])
+                if extractor["name"].lower() == document_type_name.lower()
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Document type '{document_type_name}' not found."
+            ) from None
+
+    def _start_extraction(
+        self,
+        project_id: str,
+        extractor_id: str,
+        tag: Optional[str],
+        document_type_id: str,
+        document_id: str,
+    ) -> StartExtractionResponse:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/start"
+            )
+
+        operation_id = self.request(
+            "POST",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={"documentId": document_id},
+        ).json()["operationId"]
+
+        return StartExtractionResponse(
+            operation_id=operation_id,
+            document_id=document_id,
+            project_id=project_id,
+            tag=tag,
+        )
+
+    async def _start_extraction_async(
+        self,
+        project_id: str,
+        extractor_id: str,
+        tag: Optional[str],
+        document_type_id: str,
+        document_id: str,
+    ) -> StartExtractionResponse:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/start"
+            )
+
+        operation_id = (
+            await self.request_async(
+                "POST",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={"documentId": document_id},
+            )
+        ).json()["operationId"]
+
+        return StartExtractionResponse(
+            operation_id=operation_id,
+            document_id=document_id,
+            project_id=project_id,
+            tag=tag,
+        )
+
+    def _wait_for_operation(
+        self,
+        result_getter: Callable[[], Tuple[Any, Optional[Any], Optional[Any]]],
+        wait_statuses: List[str],
+        success_status: str,
+    ) -> Any:
+        start_time = time.monotonic()
+        status = wait_statuses[0]
+        result = None
+
+        while (
+            status in wait_statuses
+            and (time.monotonic() - start_time) < self.polling_timeout
+        ):
+            status, error, result = result_getter()
+            time.sleep(self.polling_interval)
+
+        if status != success_status:
+            if time.monotonic() - start_time >= self.polling_timeout:
+                raise TimeoutError("Operation timed out.")
+            raise RuntimeError(
+                f"Operation failed with status: {status}, error: {error}"
+            )
+
+        return result
+
+    async def _wait_for_operation_async(
+        self,
+        result_getter: Callable[
+            [], Awaitable[Tuple[Any, Optional[Any], Optional[Any]]]
+        ],
+        wait_statuses: List[str],
+        success_status: str,
+    ) -> Any:
+        start_time = time.monotonic()
+        status = wait_statuses[0]
+        result = None
+
+        while (
+            status in wait_statuses
+            and (time.monotonic() - start_time) < self.polling_timeout
+        ):
+            status, error, result = await result_getter()
+            await asyncio.sleep(self.polling_interval)
+
+        if status != success_status:
+            if time.monotonic() - start_time >= self.polling_timeout:
+                raise TimeoutError("Operation timed out.")
+            raise RuntimeError(
+                f"Operation failed with status: {status}, error: {error}"
+            )
+
+        return result
+
+    def _wait_for_extraction(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+        project_type: ProjectType,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        def result_getter() -> Tuple[str, str, Any]:
+            if tag is None:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/result/{operation_id}"
+                )
+            else:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/result/{operation_id}"
+                )
+
+            result = self.request(
+                method="GET",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        extraction_response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["extractorId"] = extractor_id
+        extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+        extraction_response["projectType"] = project_type
+
+        if project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(extraction_response)
+
+        return ExtractionResponse.model_validate(extraction_response)
+
+    async def _wait_for_extraction_async(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+        project_type: ProjectType,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        async def result_getter() -> Tuple[str, str, Any]:
+            if tag is None:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/result/{operation_id}"
+                )
+            else:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/result/{operation_id}"
+                )
+
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=url,
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                )
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        extraction_response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["extractorId"] = extractor_id
+        extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+        extraction_response["projectType"] = project_type
+
+        if project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(extraction_response)
+
+        return ExtractionResponse.model_validate(extraction_response)
+
+    def _start_classification(
+        self,
+        project_id: str,
+        tag: Optional[str],
+        classifier_id: Optional[str],
+        document_id: str,
+    ) -> str:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classification/start"
+            )
+
+        return self.request(
+            "POST",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={"documentId": document_id},
+        ).json()["operationId"]
+
+    async def _start_classification_async(
+        self,
+        project_id: str,
+        tag: Optional[str],
+        classifier_id: Optional[str],
+        document_id: str,
+    ) -> str:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classification/start"
+            )
+
+        return (
+            await self.request_async(
+                "POST",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={"documentId": document_id},
+            )
+        ).json()["operationId"]
+
+    def _wait_for_classification(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> List[ClassificationResult]:
+        def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            if tag is None:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/result/{operation_id}"
+                )
+            else:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/classification/result/{operation_id}"
+                )
+
+            result = self.request(
+                method="GET",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        classification_response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+        for classification_result in classification_response["classificationResults"]:
+            classification_result["ProjectId"] = project_id
+            classification_result["ProjectType"] = project_type
+            classification_result["ClassifierId"] = classifier_id
+            classification_result["Tag"] = tag
+
+        return ClassificationResponse.model_validate(
+            classification_response
+        ).classification_results
+
+    async def _wait_for_classification_async(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> List[ClassificationResult]:
+        async def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            if tag is None:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/result/{operation_id}"
+                )
+            else:
+                url = Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/classification/result/{operation_id}"
+                )
+
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=url,
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                )
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        classification_response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+        for classification_result in classification_response["classificationResults"]:
+            classification_result["ProjectId"] = project_id
+            classification_result["ProjectType"] = project_type
+            classification_result["ClassifierId"] = classifier_id
+            classification_result["Tag"] = tag
+
+        return ClassificationResponse.model_validate(
+            classification_response
+        ).classification_results
+
+    @traced(name="documents_classify", run_type="uipath")
+    def classify(
+        self,
+        project_type: ProjectType,
+        tag: Optional[str] = None,
+        version: Optional[int] = None,
+        project_name: Optional[str] = None,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> List[ClassificationResult]:
+        """Classify a document using a DU Modern project.
+
+        Args:
+            project_type (ProjectType): Type of the project.
+            project_name (str, optional): Name of the [DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project. Must be provided if `project_type` is not `ProjectType.PRETRAINED`.
+            tag (str, optional): Tag of the published project version. Must be provided if `project_type` is not `ProjectType.PRETRAINED`.
+            version (int, optional): Version of the published project. It can be used instead of `tag`.
+            file (FileContent, optional): The document file to be classified.
+            file_path (str, optional): Path to the document file to be classified.
+
+        Note:
+            Either `file` or `file_path` must be provided, but not both.
+
+        Returns:
+            List[ClassificationResult]: A list of classification results.
+
+        Examples:
+            ```python
+            Modern DU project:
+            with open("path/to/document.pdf", "rb") as file:
+                classification_results = service.classify(
+                    project_name="MyModernProjectName",
+                    tag="Production",
+                    file=file,
+                )
+
+            Pretrained project:
+            with open("path/to/document.pdf", "rb") as file:
+                classification_results = service.classify(
+                    project_type=ProjectType.PRETRAINED,
+                    file=file,
+                )
+            ```
+        """
+        _validate_classify_params(
+            project_type=project_type,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+        )
+
+        project_id = self._get_project_id(
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=None,
+        )
+
+        document_id = self._get_document_id(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=None,
+        )
+
+        classifier_id = self._get_classifier_id(
+            project_type=project_type, project_id=project_id, version=version
+        )
+
+        tag = self._get_tag(
+            project_type=project_type,
+            project_id=project_id,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            classification_result=None,
+        )
+
+        operation_id = self._start_classification(
+            project_id=project_id,
+            tag=tag,
+            classifier_id=classifier_id,
+            document_id=document_id,
+        )
+        return self._wait_for_classification(
+            project_id=project_id,
+            project_type=project_type,
+            classifier_id=classifier_id,
+            tag=tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_classify_async", run_type="uipath")
+    async def classify_async(
+        self,
+        project_type: ProjectType,
+        tag: Optional[str] = None,
+        version: Optional[int] = None,
+        project_name: Optional[str] = None,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> List[ClassificationResult]:
+        """Asynchronously version of the [`classify`][uipath.platform.documents._documents_service.DocumentsService.classify] method."""
+        _validate_classify_params(
+            project_type=project_type,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+        )
+
+        project_id = await self._get_project_id_async(
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=None,
+        )
+
+        document_id = await self._get_document_id_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=None,
+        )
+
+        classifier_id = await self._get_classifier_id_async(
+            project_type=project_type, project_id=project_id, version=version
+        )
+
+        tag = await self._get_tag_async(
+            project_type=project_type,
+            project_id=project_id,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            classification_result=None,
+        )
+
+        operation_id = await self._start_classification_async(
+            project_id=project_id,
+            tag=tag,
+            classifier_id=classifier_id,
+            document_id=document_id,
+        )
+        return await self._wait_for_classification_async(
+            project_id=project_id,
+            project_type=project_type,
+            classifier_id=classifier_id,
+            tag=tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_start_ixp_extraction", run_type="uipath")
+    def start_ixp_extraction(
+        self,
+        project_name: str,
+        tag: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> StartExtractionResponse:
+        """Start an IXP extraction process without waiting for results (non-blocking).
+
+        This method uploads the file as an attachment and starts the extraction process,
+        returning immediately without waiting for the extraction to complete.
+        Use this for async workflows where you want to receive results via callback/webhook.
+
+        Args:
+            project_name (str): Name of the IXP project.
+            tag (str): Tag of the published project version (e.g., "staging").
+            file (FileContent, optional): The document file to be processed.
+            file_path (str, optional): Path to the document file to be processed.
+
+        Note:
+            Either `file` or `file_path` must be provided, but not both.
+
+        Returns:
+            ExtractionStartResponse: Contains the operation_id, document_id, project_id, and tag
+
+        Examples:
+            ```python
+            start_response = uipath.documents.start_ixp_extraction(
+                project_name="MyIXPProjectName",
+                tag="staging",
+                file_path="path/to/document.pdf",
+            )
+            # start_response.operation_id can be used to poll for results later
+            ```
+        """
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+
+        project_id = self._get_project_id(
+            project_type=ProjectType.IXP,
+            project_name=project_name,
+            classification_result=None,
+        )
+
+        document_id = self._start_digitization(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+        )
+
+        return self._start_extraction(
+            project_id=project_id,
+            extractor_id=None,
+            tag=tag,
+            document_type_id=str(UUID(int=0)),
+            document_id=document_id,
+        )
+
+    @traced(name="documents_start_ixp_extraction_async", run_type="uipath")
+    async def start_ixp_extraction_async(
+        self,
+        project_name: str,
+        tag: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> StartExtractionResponse:
+        """Asynchronous version of the [`start_ixp_extraction`][uipath.platform.documents._documents_service.DocumentsService.start_ixp_extraction] method."""
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+
+        project_id = await self._get_project_id_async(
+            project_type=ProjectType.IXP,
+            project_name=project_name,
+            classification_result=None,
+        )
+
+        document_id = await self._start_digitization_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+        )
+
+        return await self._start_extraction_async(
+            project_id=project_id,
+            extractor_id=None,
+            tag=tag,
+            document_type_id=str(UUID(int=0)),
+            document_id=document_id,
+        )
+
+    def _retrieve_operation_result(
+        self,
+        url: Endpoint,
+        operation_id: str,
+        operation_name: str,
+    ) -> Dict:
+        response = self.request(
+            method="GET",
+            url=url,
+            params={"api-version": "1.1"},
+            headers=self._get_common_headers(),
+        ).json()
+
+        status = response.get("status")
+        if status in ["NotStarted", "Running"]:
+            raise OperationNotCompleteException(
+                operation_id=operation_id,
+                status=response.get("status"),
+                operation_name=operation_name,
+            )
+
+        if status != "Succeeded":
+            raise OperationFailedException(
+                operation_id=operation_id,
+                status=status,
+                error=response.get("error"),
+                operation_name=operation_name,
+            )
+        return response.get("result")
+
+    async def _retrieve_operation_result_async(
+        self,
+        url: Endpoint,
+        operation_id: str,
+        operation_name: str,
+    ) -> Dict:
+        response = (
+            await self.request_async(
+                method="GET",
+                url=url,
+                params={"api-version": "1.1"},
+                headers=self._get_common_headers(),
+            )
+        ).json()
+
+        status = response.get("status")
+        if status in ["NotStarted", "Running"]:
+            raise OperationNotCompleteException(
+                operation_id=operation_id,
+                status=response.get("status"),
+                operation_name=operation_name,
+            )
+
+        if status != "Succeeded":
+            raise OperationFailedException(
+                operation_id=operation_id,
+                status=status,
+                error=response.get("error"),
+                operation_name=operation_name,
+            )
+        return response.get("result")
+
+    @traced(name="documents_retrieve_ixp_extraction_result", run_type="uipath")
+    def retrieve_ixp_extraction_result(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> ExtractionResponseIXP:
+        """Retrieve the result of an IXP extraction operation (single-shot, non-blocking).
+
+        This method retrieves the result of an IXP extraction that was previously started
+        with `start_ixp_extraction`. It does not poll - it makes a single request and
+        returns the result if available, or raises an exception if not complete.
+
+        Args:
+            project_id (str): The ID of the IXP project.
+            tag (str): The tag of the published project version.
+            operation_id (str): The operation ID returned from `start_ixp_extraction`.
+
+        Returns:
+            ExtractionResponseIXP: The extraction response containing the extracted data.
+
+        Raises:
+            OperationNotCompleteException: If the extraction is not yet complete.
+            OperationFailedException: If the extraction operation failed.
+
+        Examples:
+            ```python
+            # After receiving a callback/webhook that extraction is complete:
+            result = service.retrieve_ixp_extraction_result(
+                project_id=start_response.project_id,
+                tag=start_response.tag,
+                operation_id=start_response.operation_id,
+            )
+            ```
+        """
+        document_type_id = str(UUID(int=0))
+
+        url = Endpoint(
+            f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/result/{operation_id}"
+        )
+
+        extraction_response = self._retrieve_operation_result(
+            url=url,
+            operation_id=operation_id,
+            operation_name="IXP extraction",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["extractorId"] = None
+        extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+        extraction_response["projectType"] = ProjectType.IXP
+
+        return ExtractionResponseIXP.model_validate(extraction_response)
+
+    @traced(name="documents_retrieve_ixp_extraction_result_async", run_type="uipath")
+    async def retrieve_ixp_extraction_result_async(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> ExtractionResponseIXP:
+        """Asynchronous version of the [`retrieve_ixp_extraction_result`][uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_result] method."""
+        document_type_id = str(UUID(int=0))
+
+        url = Endpoint(
+            f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/result/{operation_id}"
+        )
+
+        extraction_response = await self._retrieve_operation_result_async(
+            url=url,
+            operation_id=operation_id,
+            operation_name="IXP extraction",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["extractorId"] = None
+        extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+        extraction_response["projectType"] = ProjectType.IXP
+
+        return ExtractionResponseIXP.model_validate(extraction_response)
+
+    @traced(name="documents_extract", run_type="uipath")
+    def extract(
+        self,
+        tag: Optional[str] = None,
+        version: Optional[int] = None,
+        project_name: Optional[str] = None,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        classification_result: Optional[ClassificationResult] = None,
+        project_type: Optional[ProjectType] = None,
+        document_type_name: Optional[str] = None,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        """Extract predicted data from a document using an DU Modern/IXP project.
+
+        Args:
+            project_name (str, optional): Name of the [IXP](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project)/[DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project. Must be provided if `classification_result` is not provided.
+            tag (str): Tag of the published project version. Must be provided if `classification_result` is not provided and `project_type` is not `ProjectType.PRETRAINED`.
+            version (int, optional): Version of the published project. It can be used instead of `tag`.
+            file (FileContent, optional): The document file to be processed. Must be provided if `classification_result` is not provided.
+            file_path (str, optional): Path to the document file to be processed. Must be provided if `classification_result` is not provided.
+            project_type (ProjectType, optional): Type of the project. Must be provided if `project_name` is provided.
+            document_type_name (str, optional): Document type name associated with the extractor to be used for extraction. Required if `project_type` is `ProjectType.MODERN` and `project_name` is provided.
+            classification_result (ClassificationResult, optional): The classification result obtained from a previous classification step. If provided, `project_name`, `project_type`, `file`, `file_path`, and `document_type_name` must not be provided.
+
+        Note:
+            Either `file` or `file_path` must be provided, but not both.
+
+        Returns:
+            Union[ExtractionResponse, ExtractionResponseIXP]: The extraction response containing the extracted data.
+
+        Examples:
+            IXP projects:
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                extraction_response = service.extract(
+                    project_name="MyIXPProjectName",
+                    tag="live",
+                    file=file,
+                )
+            ```
+
+            DU Modern projects (providing document type name):
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                extraction_response = service.extract(
+                    project_name="MyModernProjectName",
+                    tag="Production",
+                    file=file,
+                    project_type=ProjectType.MODERN,
+                    document_type_name="Receipts",
+                )
+            ```
+
+            DU Modern projects (using existing classification result):
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                classification_results = uipath.documents.classify(
+                    tag="Production",
+                    project_name="MyModernProjectName",
+                    file=file,
+                )
+
+            extraction_result = uipath.documents.extract(
+                classification_result=max(classification_results, key=lambda result: result.confidence),
+            )
+            ```
+        """
+        project_type = _validate_extract_params_and_get_project_type(
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+            project_type=project_type,
+            document_type_name=document_type_name,
+        )
+
+        project_id = self._get_project_id(
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        version = self._get_version(
+            version=version,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        tag = self._get_tag(
+            project_type=project_type,
+            project_id=project_id,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            classification_result=classification_result,
+        )
+
+        document_id = self._get_document_id(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+        )
+
+        document_type_id = self._get_document_type_id(
+            project_id=project_id,
+            document_type_name=document_type_name,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        extractor_id = self._get_extractor_id(
+            project_id=project_id,
+            version=version,
+            document_type_id=document_type_id,
+            project_type=project_type,
+        )
+
+        operation_id = self._start_extraction(
+            project_id=project_id,
+            extractor_id=extractor_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            document_id=document_id,
+        ).operation_id
+
+        return self._wait_for_extraction(
+            project_id=project_id,
+            extractor_id=extractor_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            operation_id=operation_id,
+            project_type=project_type,
+        )
+
+    @traced(name="documents_extract_async", run_type="uipath")
+    async def extract_async(
+        self,
+        tag: Optional[str] = None,
+        version: Optional[int] = None,
+        project_name: Optional[str] = None,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        classification_result: Optional[ClassificationResult] = None,
+        project_type: Optional[ProjectType] = None,
+        document_type_name: Optional[str] = None,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        """Asynchronously version of the [`extract`][uipath.platform.documents._documents_service.DocumentsService.extract] method."""
+        project_type = _validate_extract_params_and_get_project_type(
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+            project_type=project_type,
+            document_type_name=document_type_name,
+        )
+
+        project_id = await self._get_project_id_async(
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        version = await self._get_version_async(
+            version=version,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        tag = await self._get_tag_async(
+            project_type=project_type,
+            project_id=project_id,
+            tag=tag,
+            version=version,
+            project_name=project_name,
+            classification_result=classification_result,
+        )
+
+        document_id = await self._get_document_id_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+        )
+
+        document_type_id = await self._get_document_type_id_async(
+            project_id=project_id,
+            document_type_name=document_type_name,
+            project_type=project_type,
+            classification_result=classification_result,
+        )
+
+        extractor_id = await self._get_extractor_id_async(
+            project_id=project_id,
+            version=version,
+            document_type_id=document_type_id,
+            project_type=project_type,
+        )
+
+        operation_id = (
+            await self._start_extraction_async(
+                project_id=project_id,
+                extractor_id=extractor_id,
+                tag=tag,
+                document_type_id=document_type_id,
+                document_id=document_id,
+            )
+        ).operation_id
+
+        return await self._wait_for_extraction_async(
+            project_id=project_id,
+            extractor_id=extractor_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            operation_id=operation_id,
+            project_type=project_type,
+        )
+
+    def _start_classification_validation(
+        self,
+        project_id: str,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        classification_results: List[ClassificationResult],
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> str:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/start"
+            )
+
+        return self.request(
+            "POST",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={
+                "classificationResults": [
+                    cr.model_dump() for cr in classification_results
+                ],
+                "documentId": classification_results[0].document_id,
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+        ).json()["operationId"]
+
+    async def _start_classification_validation_async(
+        self,
+        project_id: str,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        classification_results: List[ClassificationResult],
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> str:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/start"
+            )
+
+        return (
+            await self.request_async(
+                "POST",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={
+                    "classificationResults": [
+                        cr.model_dump() for cr in classification_results
+                    ],
+                    "documentId": classification_results[0].document_id,
+                    "actionTitle": action_title,
+                    "actionPriority": action_priority,
+                    "actionCatalog": action_catalog,
+                    "actionFolder": action_folder,
+                    "storageBucketName": storage_bucket_name,
+                    "storageBucketDirectoryPath": storage_bucket_directory_path,
+                },
+            )
+        ).json()["operationId"]
+
+    def _start_extraction_validation(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        action_title: str,
+        action_priority: Optional[ActionPriority],
+        action_catalog: Optional[str],
+        action_folder: Optional[str],
+        storage_bucket_name: Optional[str],
+        storage_bucket_directory_path: Optional[str],
+        extraction_response: ExtractionResponse,
+    ) -> StartExtractionValidationResponse:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/start"
+            )
+
+        operation_id = self.request(
+            "POST",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={
+                "extractionResult": extraction_response.extraction_result.model_dump(),
+                "documentId": extraction_response.extraction_result.document_id,
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+        ).json()["operationId"]
+
+        return StartExtractionValidationResponse(
+            operation_id=operation_id,
+            document_id=extraction_response.extraction_result.document_id,
+            project_id=project_id,
+            tag=tag,
+        )
+
+    async def _start_extraction_validation_async(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        action_title: str,
+        action_priority: Optional[ActionPriority],
+        action_catalog: Optional[str],
+        action_folder: Optional[str],
+        storage_bucket_name: Optional[str],
+        storage_bucket_directory_path: Optional[str],
+        extraction_response: ExtractionResponse,
+    ) -> StartExtractionValidationResponse:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/start"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/start"
+            )
+
+        operation_id = (
+            await self.request_async(
+                "POST",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={
+                    "extractionResult": extraction_response.extraction_result.model_dump(),
+                    "documentId": extraction_response.extraction_result.document_id,
+                    "actionTitle": action_title,
+                    "actionPriority": action_priority,
+                    "actionCatalog": action_catalog,
+                    "actionFolder": action_folder,
+                    "storageBucketName": storage_bucket_name,
+                    "allowChangeOfDocumentType": True,
+                    "storageBucketDirectoryPath": storage_bucket_directory_path,
+                },
+            )
+        ).json()["operationId"]
+
+        return StartExtractionValidationResponse(
+            operation_id=operation_id,
+            document_id=extraction_response.extraction_result.document_id,
+            project_id=project_id,
+            tag=tag,
+        )
+
+    @traced(name="documents_start_ixp_extraction_validation", run_type="uipath")
+    def start_ixp_extraction_validation(
+        self,
+        extraction_response: ExtractionResponseIXP,
+        action_title: str,
+        action_catalog: Optional[str] = None,
+        action_priority: Optional[ActionPriority] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> StartExtractionValidationResponse:
+        """Start an IXP extraction validation action without waiting for results (non-blocking).
+
+        Args:
+            extraction_response (ExtractionResponseIXP): The extraction response from the IXP extraction process.
+            action_title (str): The title of the validation action.
+            action_catalog (str, optional): The catalog of the validation action.
+            action_priority (ActionPriority, optional): The priority of the validation action.
+            action_folder (str, optional): The folder of the validation action.
+            storage_bucket_name (str, optional): The name of the storage bucket where validation data will be stored.
+            storage_bucket_directory_path (str, optional): The directory path within the storage bucket.
+
+        Returns:
+            StartExtractionValidationResponse: Contains the operation_id, document_id, project_id, and tag.
+
+        Examples:
+            ```python
+            start_operation_response = service.start_ixp_extraction_validation(
+                action_title="Validate IXP Extraction",
+                action_priority=ActionPriority.HIGH,
+                action_catalog="DefaultCatalog",
+                action_folder="Validations",
+                storage_bucket_name="my-storage-bucket",
+                storage_bucket_directory_path="validations/ixp",
+                extraction_response=extraction_response,
+            )
+            # start_operation_response can be used to poll for validation results later
+            ```
+        """
+        return self._start_extraction_validation(
+            project_id=extraction_response.project_id,
+            extractor_id=None,
+            tag=extraction_response.tag,
+            document_type_id=str(UUID(int=0)),
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            extraction_response=extraction_response,
+        )
+
+    @resource_override(
+        resource_type="bucket",
+        resource_identifier="storage_bucket_name",
+        folder_identifier="action_folder",
+    )
+    @traced(
+        name="documents_start_ixp_extraction_validation_async",
+        run_type="uipath",
+    )
+    async def start_ixp_extraction_validation_async(
+        self,
+        extraction_response: ExtractionResponseIXP,
+        action_title: str,
+        action_catalog: Optional[str] = None,
+        action_priority: Optional[ActionPriority] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> StartExtractionValidationResponse:
+        """Asynchronous version of the [`start_ixp_extraction_validation`][uipath.platform.documents._documents_service.DocumentsService.start_ixp_extraction_validation] method."""
+        return await self._start_extraction_validation_async(
+            project_id=extraction_response.project_id,
+            extractor_id=None,
+            tag=extraction_response.tag,
+            document_type_id=str(UUID(int=0)),
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            extraction_response=extraction_response,
+        )
+
+    @resource_override(
+        resource_type="bucket",
+        resource_identifier="storage_bucket_name",
+        folder_identifier="action_folder",
+    )
+    @traced(
+        name="documents_retrieve_ixp_extraction_validation_result",
+        run_type="uipath",
+    )
+    def retrieve_ixp_extraction_validation_result(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> ValidateExtractionAction:
+        """Retrieve the result of an IXP create validate extraction action operation (single-shot, non-blocking).
+
+        This method retrieves the result of an IXP create validate extraction action that was previously started
+        with `start_ixp_extraction_validation`. It does not poll - it makes a single request and
+        returns the result if available, or raises an exception if not complete.
+
+        Args:
+            operation_id (str): The operation ID returned from `start_ixp_extraction_validation`.
+            project_id (str): The ID of the IXP project.
+            tag (str): The tag of the published project version.
+
+        Returns:
+            ValidateExtractionAction: The validation action
+
+        Raises:
+            OperationNotCompleteException: If the validation action is not yet complete.
+            OperationFailedException: If the validation action has failed.
+
+        Examples:
+            ```python
+            # After receiving a callback/webhook that validation is complete:
+            validation_result = service.retrieve_ixp_extraction_validation_result(
+                operation_id=start_operation_response.operation_id,
+                project_id=start_operation_response.project_id,
+                tag=start_operation_response.tag,
+            )
+            ```
+        """
+        document_type_id = str(UUID(int=0))
+
+        url = Endpoint(
+            f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}"
+        )
+
+        result = self._retrieve_operation_result(
+            url=url,
+            operation_id=operation_id,
+            operation_name="IXP Create Validate Extraction Action",
+        )
+
+        result["projectId"] = project_id
+        result["projectType"] = ProjectType.IXP
+        result["extractorId"] = None
+        result["tag"] = tag
+        result["documentTypeId"] = str(UUID(int=0))
+        result["operationId"] = operation_id
+
+        return ValidateExtractionAction.model_validate(result)
+
+    @traced(
+        name="documents_retrieve_ixp_extraction_validation_result_async",
+        run_type="uipath",
+    )
+    async def retrieve_ixp_extraction_validation_result_async(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> ValidateExtractionAction:
+        """Asynchronous version of the [`retrieve_ixp_extraction_validation_result`][uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_validation_result] method."""
+        document_type_id = str(UUID(int=0))
+
+        url = Endpoint(
+            f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}"
+        )
+
+        result = await self._retrieve_operation_result_async(
+            url=url,
+            operation_id=operation_id,
+            operation_name="IXP Create Validate Extraction Action",
+        )
+
+        result["projectId"] = project_id
+        result["projectType"] = ProjectType.IXP
+        result["extractorId"] = None
+        result["tag"] = tag
+        result["documentTypeId"] = str(UUID(int=0))
+        result["operationId"] = operation_id
+
+        return ValidateExtractionAction.model_validate(result)
+
+    def _get_classification_validation_result(
+        self,
+        project_id: str,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> Dict:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/result/{operation_id}"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/result/{operation_id}"
+            )
+
+        return self.request(
+            method="GET",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        ).json()
+
+    async def _get_classification_validation_result_async(
+        self,
+        project_id: str,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> Dict:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/result/{operation_id}"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/result/{operation_id}"
+            )
+
+        return (
+            await self.request_async(
+                method="GET",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            )
+        ).json()
+
+    def _get_extraction_validation_result(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+    ) -> Dict:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/result/{operation_id}"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}"
+            )
+
+        return self.request(
+            method="GET",
+            url=url,
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        ).json()
+
+    async def _get_extraction_validation_result_async(
+        self,
+        project_id: str,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+    ) -> Dict:
+        if tag is None:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/result/{operation_id}"
+            )
+        else:
+            url = Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}"
+            )
+
+        return (
+            await self.request_async(
+                method="GET",
+                url=url,
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            )
+        ).json()
+
+    def _wait_for_create_validate_classification_action(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> ValidateClassificationAction:
+        def result_getter() -> Tuple[Any, Optional[Any], Optional[Any]]:
+            result = self._get_classification_validation_result(
+                project_id=project_id,
+                classifier_id=classifier_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["projectType"] = project_type
+        response["classifierId"] = classifier_id
+        response["tag"] = tag
+        response["operationId"] = operation_id
+        return ValidateClassificationAction.model_validate(response)
+
+    async def _wait_for_create_validate_classification_action_async(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        classifier_id: Optional[str],
+        tag: Optional[str],
+        operation_id: str,
+    ) -> ValidateClassificationAction:
+        async def result_getter() -> Tuple[Any, Optional[Any], Optional[Any]]:
+            result = await self._get_classification_validation_result_async(
+                project_id=project_id,
+                classifier_id=classifier_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["projectType"] = project_type
+        response["classifierId"] = classifier_id
+        response["tag"] = tag
+        response["operationId"] = operation_id
+        return ValidateClassificationAction.model_validate(response)
+
+    def _wait_for_create_validate_extraction_action(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+    ) -> ValidateExtractionAction:
+        def result_getter() -> Tuple[Any, Optional[Any], Optional[Any]]:
+            result = self._get_extraction_validation_result(
+                project_id=project_id,
+                extractor_id=extractor_id,
+                tag=tag,
+                document_type_id=document_type_id,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["projectType"] = project_type
+        response["extractorId"] = extractor_id
+        response["tag"] = tag
+        response["documentTypeId"] = document_type_id
+        response["operationId"] = operation_id
+        return ValidateExtractionAction.model_validate(response)
+
+    async def _wait_for_create_validate_extraction_action_async(
+        self,
+        project_id: str,
+        project_type: ProjectType,
+        extractor_id: Optional[str],
+        tag: Optional[str],
+        document_type_id: str,
+        operation_id: str,
+    ) -> ValidateExtractionAction:
+        async def result_getter_async() -> Tuple[Any, Optional[Any], Optional[Any]]:
+            result = await self._get_extraction_validation_result_async(
+                project_id=project_id,
+                extractor_id=extractor_id,
+                tag=tag,
+                document_type_id=document_type_id,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter_async,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["projectType"] = project_type
+        response["extractorId"] = extractor_id
+        response["tag"] = tag
+        response["documentTypeId"] = document_type_id
+        response["operationId"] = operation_id
+        return ValidateExtractionAction.model_validate(response)
+
+    @traced(name="documents_create_validate_classification_action", run_type="uipath")
+    def create_validate_classification_action(
+        self,
+        classification_results: List[ClassificationResult],
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> ValidateClassificationAction:
+        """Create a validate classification action for a document based on the classification results. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-classifications).
+
+        Args:
+            classification_results (List[ClassificationResult]): The classification results to be validated, typically obtained from the [`classify`][uipath.platform.documents._documents_service.DocumentsService.classify] method.
+            action_title (str): Title of the action.
+            action_priority (ActionPriority, optional): Priority of the action.
+            action_catalog (str, optional): Catalog of the action.
+            action_folder (str, optional): Folder of the action.
+            storage_bucket_name (str, optional): Name of the storage bucket.
+            storage_bucket_directory_path (str, optional): Directory path in the storage bucket.
+
+        Returns:
+            ValidateClassificationAction: The created validate classification action.
+
+        Examples:
+            ```python
+            validation_action = service.create_validate_classification_action(
+                action_title="Test Validation Action",
+                action_priority=ActionPriority.MEDIUM,
+                action_catalog="default_du_actions",
+                action_folder="Shared",
+                storage_bucket_name="du_storage_bucket",
+                storage_bucket_directory_path="TestDirectory",
+                classification_results=classification_results,
+            )
+            ```
+        """
+        if not classification_results:
+            raise ValueError("`classification_results` must not be empty")
+
+        operation_id = self._start_classification_validation(
+            project_id=classification_results[0].project_id,
+            classifier_id=classification_results[0].classifier_id,
+            tag=classification_results[0].tag,
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            classification_results=classification_results,
+        )
+
+        return self._wait_for_create_validate_classification_action(
+            project_id=classification_results[0].project_id,
+            project_type=classification_results[0].project_type,
+            classifier_id=classification_results[0].classifier_id,
+            tag=classification_results[0].tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_create_validate_classification_action", run_type="uipath")
+    async def create_validate_classification_action_async(
+        self,
+        classification_results: List[ClassificationResult],
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> ValidateClassificationAction:
+        """Asynchronous version of the [`create_validation_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_classification_action] method."""
+        if not classification_results:
+            raise ValueError("`classification_results` must not be empty")
+
+        operation_id = await self._start_classification_validation_async(
+            project_id=classification_results[0].project_id,
+            classifier_id=classification_results[0].classifier_id,
+            tag=classification_results[0].tag,
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            classification_results=classification_results,
+        )
+
+        return await self._wait_for_create_validate_classification_action_async(
+            project_id=classification_results[0].project_id,
+            project_type=classification_results[0].project_type,
+            classifier_id=classification_results[0].classifier_id,
+            tag=classification_results[0].tag,
+            operation_id=operation_id,
+        )
+
+    @resource_override(
+        resource_type="bucket",
+        resource_identifier="storage_bucket_name",
+        folder_identifier="action_folder",
+    )
+    @traced(name="documents_create_validate_extraction_action", run_type="uipath")
+    def create_validate_extraction_action(
+        self,
+        extraction_response: ExtractionResponse,
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> ValidateExtractionAction:
+        """Create a validate extraction action for a document based on the extraction response. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-extractions).
+
+        Args:
+            extraction_response (ExtractionResponse): The extraction result to be validated, typically obtained from the [`extract`][uipath.platform.documents._documents_service.DocumentsService.extract] method.
+            action_title (str): Title of the action.
+            action_priority (ActionPriority, optional): Priority of the action.
+            action_catalog (str, optional): Catalog of the action.
+            action_folder (str, optional): Folder of the action.
+            storage_bucket_name (str, optional): Name of the storage bucket.
+            storage_bucket_directory_path (str, optional): Directory path in the storage bucket.
+
+        Returns:
+            ValidateClassificationAction: The created validation action.
+
+        Examples:
+            ```python
+            validation_action = service.create_validate_extraction_action(
+                action_title="Test Validation Action",
+                action_priority=ActionPriority.MEDIUM,
+                action_catalog="default_du_actions",
+                action_folder="Shared",
+                storage_bucket_name="du_storage_bucket",
+                storage_bucket_directory_path="TestDirectory",
+                extraction_response=extraction_response,
+            )
+            ```
+        """
+        operation_id = self._start_extraction_validation(
+            project_id=extraction_response.project_id,
+            extractor_id=extraction_response.extractor_id,
+            tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            extraction_response=extraction_response,
+        ).operation_id
+
+        return self._wait_for_create_validate_extraction_action(
+            project_id=extraction_response.project_id,
+            project_type=extraction_response.project_type,
+            extractor_id=extraction_response.extractor_id,
+            tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
+            operation_id=operation_id,
+        )
+
+    @resource_override(
+        resource_type="bucket",
+        resource_identifier="storage_bucket_name",
+        folder_identifier="action_folder",
+    )
+    @traced(name="documents_create_validate_extraction_action_async", run_type="uipath")
+    async def create_validate_extraction_action_async(
+        self,
+        extraction_response: ExtractionResponse,
+        action_title: str,
+        action_priority: Optional[ActionPriority] = None,
+        action_catalog: Optional[str] = None,
+        action_folder: Optional[str] = None,
+        storage_bucket_name: Optional[str] = None,
+        storage_bucket_directory_path: Optional[str] = None,
+    ) -> ValidateExtractionAction:
+        """Asynchronous version of the [`create_validation_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_extraction_action] method."""
+        operation_id = (
+            await self._start_extraction_validation_async(
+                project_id=extraction_response.project_id,
+                extractor_id=extraction_response.extractor_id,
+                tag=extraction_response.tag,
+                document_type_id=extraction_response.document_type_id,
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=extraction_response,
+            )
+        ).operation_id
+
+        return await self._wait_for_create_validate_extraction_action_async(
+            project_id=extraction_response.project_id,
+            project_type=extraction_response.project_type,
+            extractor_id=extraction_response.extractor_id,
+            tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_get_validate_classification_result", run_type="uipath")
+    def get_validate_classification_result(
+        self, validation_action: ValidateClassificationAction
+    ) -> List[ClassificationResult]:
+        """Get the result of a validate classification action.
+
+        Note:
+            This method will block until the validation action is completed, meaning the user has completed the validation in UiPath Action Center.
+
+        Args:
+            validation_action (ValidateClassificationAction): The validation action to get the result for, typically obtained from the [`create_validate_classification_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_classification_action] method.
+
+        Returns:
+            List[ClassificationResult]: The validated classification results.
+
+        Examples:
+            ```python
+            validated_results = service.get_validate_classification_result(validate_classification_action)
+            ```
+        """
+
+        def result_getter() -> Tuple[str, None, Any]:
+            result = self._get_classification_validation_result(
+                project_id=validation_action.project_id,
+                classifier_id=validation_action.classifier_id,
+                tag=validation_action.tag,
+                operation_id=validation_action.operation_id,
+            )
+            return (result["result"]["actionStatus"], None, result["result"])
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+        classification_results = []
+        for cr in response["validatedClassificationResults"]:
+            cr["ProjectId"] = validation_action.project_id
+            cr["ProjectType"] = validation_action.project_type
+            cr["ClassifierId"] = validation_action.classifier_id
+            cr["Tag"] = validation_action.tag
+            classification_results.append(ClassificationResult.model_validate(cr))
+
+        return classification_results
+
+    @traced(
+        name="documents_get_validate_classification_result_async", run_type="uipath"
+    )
+    async def get_validate_classification_result_async(
+        self, validation_action: ValidateClassificationAction
+    ) -> List[ClassificationResult]:
+        """Asynchronous version of the [`get_validation_result`][uipath.platform.documents._documents_service.DocumentsService.get_validate_classification_result] method."""
+
+        async def result_getter() -> Tuple[str, None, Any]:
+            result = await self._get_classification_validation_result_async(
+                project_id=validation_action.project_id,
+                classifier_id=validation_action.classifier_id,
+                tag=validation_action.tag,
+                operation_id=validation_action.operation_id,
+            )
+            return (result["result"]["actionStatus"], None, result["result"])
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+        classification_results = []
+        for cr in response["validatedClassificationResults"]:
+            cr["ProjectId"] = validation_action.project_id
+            cr["ProjectType"] = validation_action.project_type
+            cr["ClassifierId"] = validation_action.classifier_id
+            cr["Tag"] = validation_action.tag
+            classification_results.append(ClassificationResult.model_validate(cr))
+
+        return classification_results
+
+    @traced(name="documents_get_validate_extraction_result", run_type="uipath")
+    def get_validate_extraction_result(
+        self, validation_action: ValidateExtractionAction
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        """Get the result of a validate extraction action.
+
+        Note:
+            This method will block until the validation action is completed, meaning the user has completed the validation in UiPath Action Center.
+
+        Args:
+            validation_action (ValidateClassificationAction): The validation action to get the result for, typically obtained from the [`create_validate_extraction_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_extraction_action] method.
+
+        Returns:
+            Union[ExtractionResponse, ExtractionResponseIXP]: The validated extraction response.
+
+        Examples:
+            ```python
+            validated_result = service.get_validate_extraction_result(validate_extraction_action)
+            ```
+        """
+
+        def result_getter() -> Tuple[str, None, Any]:
+            result = self._get_extraction_validation_result(
+                project_id=validation_action.project_id,
+                extractor_id=validation_action.extractor_id,
+                tag=validation_action.tag,
+                document_type_id=validation_action.document_type_id,
+                operation_id=validation_action.operation_id,
+            )
+            return (result["result"]["actionStatus"], None, result["result"])
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+        response["extractionResult"] = response.pop("validatedExtractionResults")
+        response["projectId"] = validation_action.project_id
+        response["extractorId"] = validation_action.extractor_id
+        response["tag"] = validation_action.tag
+        response["documentTypeId"] = validation_action.document_type_id
+        response["projectType"] = validation_action.project_type
+
+        if validation_action.project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(response)
+
+        return ExtractionResponse.model_validate(response)
+
+    @traced(name="documents_get_validate_extraction_result_async", run_type="uipath")
+    async def get_validate_extraction_result_async(
+        self, validation_action: ValidateExtractionAction
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        """Asynchronous version of the [`get_validation_result`][uipath.platform.documents._documents_service.DocumentsService.get_validate_extraction_result] method."""
+
+        async def result_getter() -> Tuple[str, None, Any]:
+            result = await self._get_extraction_validation_result_async(
+                project_id=validation_action.project_id,
+                extractor_id=validation_action.extractor_id,
+                tag=validation_action.tag,
+                document_type_id=validation_action.document_type_id,
+                operation_id=validation_action.operation_id,
+            )
+            return (result["result"]["actionStatus"], None, result["result"])
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+        response["extractionResult"] = response.pop("validatedExtractionResults")
+        response["projectId"] = validation_action.project_id
+        response["extractorId"] = validation_action.extractor_id
+        response["tag"] = validation_action.tag
+        response["documentTypeId"] = validation_action.document_type_id
+        response["projectType"] = validation_action.project_type
+
+        if validation_action.project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(response)
+
+        return ExtractionResponse.model_validate(response)
diff --git a/packages/uipath-platform/src/uipath/platform/documents/documents.py b/packages/uipath-platform/src/uipath/platform/documents/documents.py
new file mode 100644
index 000000000..7870635f9
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/documents/documents.py
@@ -0,0 +1,298 @@
+"""Document service payload models."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import IO, Any, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+FileContent = Union[IO[bytes], bytes, str]
+
+
+class FieldType(str, Enum):
+    """Field types supported by Document Understanding service."""
+
+    TEXT = "Text"
+    NUMBER = "Number"
+    DATE = "Date"
+    NAME = "Name"
+    ADDRESS = "Address"
+    KEYWORD = "Keyword"
+    SET = "Set"
+    BOOLEAN = "Boolean"
+    TABLE = "Table"
+    INTERNAL = "Internal"
+
+
+class ActionPriority(str, Enum):
+    """Priority levels for validation actions. More details can be found in the [official documentation](https://docs.uipath.com/action-center/automation-cloud/latest/user-guide/create-document-validation-action#configuration)."""
+
+    LOW = "Low"
+    """Low priority"""
+    MEDIUM = "Medium"
+    """Medium priority"""
+    HIGH = "High"
+    """High priority"""
+    CRITICAL = "Critical"
+    """Critical priority"""
+
+    @classmethod
+    def from_str(cls, value: str | None) -> ActionPriority:
+        """Creates an ActionPriority from a string."""
+        if not value:
+            return cls.MEDIUM
+        try:
+            return cls[value.upper()]
+        except (KeyError, AttributeError):
+            return cls.MEDIUM
+
+
+class ProjectType(str, Enum):
+    """Project types available and supported by Documents Service."""
+
+    IXP = "IXP"
+    """Represents an [IXP](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project) project type."""
+    MODERN = "Modern"
+    """Represents a [DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project type."""
+    PRETRAINED = "Pretrained"
+    """Represents a [Pretrained](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/out-of-the-box-pre-trained-ml-packages) project type."""
+
+
+class FieldValueProjection(BaseModel):
+    """A model representing a projection of a field value in a document extraction result."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    id: str
+    name: str
+    value: Optional[str]
+    unformatted_value: Optional[str] = Field(alias="unformattedValue")
+    confidence: Optional[float]
+    ocr_confidence: Optional[float] = Field(alias="ocrConfidence")
+    type: FieldType
+
+
+class FieldGroupValueProjection(BaseModel):
+    """A model representing a projection of a field group value in a document extraction result."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    field_group_name: str = Field(alias="fieldGroupName")
+    field_values: List[FieldValueProjection] = Field(alias="fieldValues")
+
+
+class ExtractionResult(BaseModel):
+    """A model representing the result of a document extraction process."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    document_id: str = Field(alias="DocumentId")
+    results_version: int = Field(alias="ResultsVersion")
+    results_document: dict[str, Any] = Field(alias="ResultsDocument")
+    extractor_payloads: Optional[List[dict[str, Any]]] = Field(
+        default=None, alias="ExtractorPayloads"
+    )
+    business_rules_results: Optional[List[dict[str, Any]]] = Field(
+        default=None, alias="BusinessRulesResults"
+    )
+
+
+class ExtractionResponse(BaseModel):
+    """A model representing the response from a document extraction process.
+
+    Attributes:
+        extraction_result (ExtractionResult): The result of the extraction process.
+        project_id (str): The ID of the project associated with the extraction.
+        tag (str): The tag associated with the published model version.
+        document_type_id (str): The ID of the document type associated with the extraction.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    extraction_result: ExtractionResult = Field(alias="extractionResult")
+    project_id: str = Field(alias="projectId")
+    project_type: ProjectType = Field(alias="projectType")
+    extractor_id: Optional[str] = Field(alias="extractorId", default=None)
+    tag: Optional[str]
+    document_type_id: str = Field(alias="documentTypeId")
+
+
+class ExtractionResponseIXP(ExtractionResponse):
+    """A model representing the response from a document extraction process for IXP projects.
+
+    Attributes:
+        data_projection (List[FieldGroupValueProjection]): A simplified projection of the extracted data.
+    """
+
+    data_projection: Optional[List[FieldGroupValueProjection]] = Field(
+        alias="dataProjection",
+        default=None,
+    )
+
+
+class ValidationAction(BaseModel):
+    """A model representing a validation action for a document.
+
+    Attributes:
+        action_data (dict): The data associated with the validation action.
+        action_status (str): The status of the validation action. Possible values can be found in the [official documentation](https://docs.uipath.com/action-center/automation-cloud/latest/user-guide/about-actions#action-statuses).
+        project_id (str): The ID of the project associated with the validation action.
+        tag (str): The tag associated with the published model version.
+        operation_id (str): The operation ID associated with the validation action.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    action_data: dict[str, Any] = Field(alias="actionData")
+    action_status: str = Field(alias="actionStatus")
+    project_id: str = Field(alias="projectId")
+    project_type: ProjectType = Field(alias="projectType")
+    tag: Optional[str]
+    operation_id: str = Field(alias="operationId")
+
+
+class ValidateClassificationAction(ValidationAction):
+    """A model representing a validation action for document classification."""
+
+    classifier_id: Optional[str] = Field(alias="classifierId")
+
+
+class ValidateExtractionAction(ValidationAction):
+    """A model representing a validation action for document extraction."""
+
+    extractor_id: Optional[str] = Field(alias="extractorId")
+    document_type_id: str = Field(alias="documentTypeId")
+    validated_extraction_result: Optional[ExtractionResult] = Field(
+        alias="validatedExtractionResults", default=None
+    )
+    data_projection: Optional[List[FieldGroupValueProjection]] = Field(
+        alias="dataProjection", default=None
+    )
+
+
+class Reference(BaseModel):
+    """A model representing a reference within a document."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    text_start_index: int = Field(alias="TextStartIndex")
+    text_length: int = Field(alias="TextLength")
+    tokens: List[str] = Field(alias="Tokens")
+
+
+class DocumentBounds(BaseModel):
+    """A model representing the bounds of a document in terms of pages and text."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    start_page: int = Field(alias="StartPage")
+    page_count: int = Field(alias="PageCount")
+    text_start_index: int = Field(alias="TextStartIndex")
+    text_length: int = Field(alias="TextLength")
+    page_range: str = Field(alias="PageRange")
+
+
+class ClassificationResult(BaseModel):
+    """A model representing the result of a document classification.
+
+    Attributes:
+        document_id (str): The ID of the classified document.
+        document_type_id (str): The ID of the predicted document type.
+        confidence (float): The confidence score of the classification.
+        ocr_confidence (float): The OCR confidence score of the document.
+        reference (Reference): The reference information for the classified document.
+        document_bounds (DocumentBounds): The bounds of the document in terms of pages and text.
+        classifier_name (str): The name of the classifier used.
+        project_id (str): The ID of the project associated with the classification.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    document_id: str = Field(alias="DocumentId")
+    document_type_id: str = Field(alias="DocumentTypeId")
+    confidence: float = Field(alias="Confidence")
+    ocr_confidence: float = Field(alias="OcrConfidence")
+    reference: Reference = Field(alias="Reference")
+    document_bounds: DocumentBounds = Field(alias="DocumentBounds")
+    classifier_name: str = Field(alias="ClassifierName")
+    project_id: str = Field(alias="ProjectId")
+    project_type: ProjectType = Field(alias="ProjectType")
+    classifier_id: Optional[str] = Field(alias="ClassifierId")
+    tag: Optional[str] = Field(alias="Tag")
+
+
+class ClassificationResponse(BaseModel):
+    """A model representing the response from a document classification process."""
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    classification_results: List[ClassificationResult] = Field(
+        alias="classificationResults"
+    )
+
+
+class StartOperationResponse(BaseModel):
+    """A model representing the response from starting an operation.
+
+    Attributes:
+        operation_id (str): The ID of the extraction operation, used to poll for results.
+        document_id (str): The ID of the digitized document.
+        project_id (str): The ID of the project.
+        tag (str): The tag of the published project version.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    operation_id: str = Field(alias="operationId")
+    document_id: str = Field(alias="documentId")
+    project_id: str = Field(alias="projectId")
+    tag: str | None = Field(default=None)
+
+
+class StartExtractionResponse(StartOperationResponse):
+    """A model representing the response from starting an extraction operation."""
+
+
+class StartExtractionValidationResponse(StartOperationResponse):
+    """A model representing the response from starting an extraction validation operation."""
diff --git a/packages/uipath-platform/src/uipath/platform/entities/__init__.py b/packages/uipath-platform/src/uipath/platform/entities/__init__.py
new file mode 100644
index 000000000..67572ec87
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/__init__.py
@@ -0,0 +1,82 @@
+"""UiPath Entities Models.
+
+This module contains models related to UiPath Entities service.
+"""
+
+from ._entities_service import EntitiesService
+from .entities import (
+    AggregateRow,
+    ChoiceSetValue,
+    DataFabricEntityItem,
+    Entity,
+    EntityAggregate,
+    EntityAggregateFunction,
+    EntityBinning,
+    EntityCreateFieldOptions,
+    EntityCreateOptions,
+    EntityField,
+    EntityFieldDataType,
+    EntityFieldMetadata,
+    EntityImportRecordsResponse,
+    EntityJoin,
+    EntityMetadataUpdateOptions,
+    EntityQueryFilter,
+    EntityQueryFilterGroup,
+    EntityQuerySortOption,
+    EntityRecord,
+    EntityRecordsBatchResponse,
+    EntityRecordsListResponse,
+    EntityRouting,
+    EntitySetResolution,
+    ExternalField,
+    ExternalObject,
+    ExternalSourceFields,
+    FailureRecord,
+    FieldDataType,
+    FieldMetadata,
+    LogicalOperator,
+    QueryFilterOperator,
+    QueryRoutingOverrideContext,
+    ReferenceType,
+    RetrieveEntityRecordsResponse,
+    SourceJoinCriteria,
+)
+
+__all__ = [
+    "AggregateRow",
+    "ChoiceSetValue",
+    "DataFabricEntityItem",
+    "EntitiesService",
+    "Entity",
+    "EntityAggregate",
+    "EntityAggregateFunction",
+    "EntityBinning",
+    "EntityCreateFieldOptions",
+    "EntityCreateOptions",
+    "EntityField",
+    "EntityFieldDataType",
+    "EntityFieldMetadata",
+    "EntityImportRecordsResponse",
+    "EntityJoin",
+    "EntityMetadataUpdateOptions",
+    "EntityQueryFilter",
+    "EntityQueryFilterGroup",
+    "EntityQuerySortOption",
+    "EntityRecord",
+    "EntityRecordsBatchResponse",
+    "EntityRecordsListResponse",
+    "EntityRouting",
+    "EntitySetResolution",
+    "ExternalField",
+    "ExternalObject",
+    "ExternalSourceFields",
+    "FailureRecord",
+    "FieldDataType",
+    "FieldMetadata",
+    "LogicalOperator",
+    "QueryFilterOperator",
+    "QueryRoutingOverrideContext",
+    "ReferenceType",
+    "RetrieveEntityRecordsResponse",
+    "SourceJoinCriteria",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py b/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py
new file mode 100644
index 000000000..fa3c0da9e
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py
@@ -0,0 +1,2229 @@
+"""Public facade for the Data Fabric entities surface.
+
+:class:`EntitiesService` keeps the existing ``sdk.entities.*`` API flat and
+unchanged from a caller's perspective while delegating each operation to the
+appropriate underlying service:
+
+* :class:`EntitySchemaService` — entity definitions, choice set listings,
+  create / delete / update-metadata lifecycle.
+* :class:`EntityDataService` — record CRUD (single and batch), structured
+  queries, attachments, choice-set values, bulk import, and federated SQL
+  queries.
+
+The facade additionally owns cross-cutting concerns such as agent entity-set
+resolution.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from httpx import Response
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import _resource_overwrites
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..orchestrator._folder_service import FolderService
+from ._entity_data_service import EntityDataService, FileContent
+from ._entity_resolution import (
+    build_resolution_service,
+    create_resolution_plan,
+    create_resolution_plan_async,
+    create_routing_strategy,
+    fetch_resolved_entities,
+    fetch_resolved_entities_async,
+)
+from ._entity_schema_service import EntitySchemaService
+from .entities import (
+    ChoiceSetValue,
+    DataFabricEntityItem,
+    Entity,
+    EntityAggregate,
+    EntityBinning,
+    EntityCreateFieldOptions,
+    EntityCreateOptions,
+    EntityImportRecordsResponse,
+    EntityJoin,
+    EntityMetadataUpdateOptions,
+    EntityQueryFilterGroup,
+    EntityQuerySortOption,
+    EntityRecord,
+    EntityRecordsBatchResponse,
+    EntityRecordsListResponse,
+    EntitySetResolution,
+    QueryRoutingOverrideContext,
+    RetrieveEntityRecordsResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class EntitiesService(BaseService):
+    """Service for managing UiPath Data Service entities.
+
+    Entities are database tables in UiPath Data Service that store structured
+    data for automation processes. This service is the unified entry point for
+    every entity operation: schema management, record CRUD, structured and
+    SQL queries, file attachments, choice sets, and bulk import.
+
+    See Also:
+        https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/introduction
+
+    !!! warning "Preview Feature"
+        This service is currently experimental. Behavior and parameters are
+        subject to change in future versions.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: Optional[FolderService] = None,
+        folders_map: Optional[Dict[str, str]] = None,
+        entity_name_overrides: Optional[Dict[str, str]] = None,
+        routing_context: Optional[QueryRoutingOverrideContext] = None,
+    ) -> None:
+        """Initialise the facade and its underlying schema and data services."""
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+        self._routing_strategy = create_routing_strategy(
+            folders_map=folders_map,
+            effective_entity_names=entity_name_overrides,
+            routing_context=routing_context,
+            folders_service=folders_service,
+        )
+        self._schema = EntitySchemaService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+        )
+        self._data = EntityDataService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+            routing_strategy=self._routing_strategy,
+        )
+
+    # ------------------------------------------------------------------
+    # Schema operations — delegate to EntitySchemaService
+    # ------------------------------------------------------------------
+
+    @traced(name="entity_retrieve", run_type="uipath")
+    def retrieve(self, entity_key: str) -> Entity:
+        """Retrieve an entity by its key.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+
+        Returns:
+            Entity: The entity with all its metadata and field definitions, including:
+                - name: Entity name
+                - display_name: Human-readable display name
+                - fields: List of field metadata (field names, types, constraints)
+                - record_count: Number of records in the entity
+                - storage_size_in_mb: Storage size used by the entity
+
+        Examples:
+            Basic usage::
+
+                # Retrieve entity metadata
+                entity = entities_service.retrieve("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+                print(f"Entity: {entity.display_name}")
+                print(f"Records: {entity.record_count}")
+
+            Inspecting entity fields::
+
+                entity = entities_service.retrieve("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # List all fields and their types
+                for field in entity.fields:
+                    print(f"{field.name} ({field.sql_type.name})")
+                    print(f"  Required: {field.is_required}")
+                    print(f"  Primary Key: {field.is_primary_key}")
+        """
+        return self._schema.retrieve(entity_key)
+
+    @traced(name="entity_retrieve", run_type="uipath")
+    async def retrieve_async(self, entity_key: str) -> Entity:
+        """Asynchronously retrieve an entity by its key.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+
+        Returns:
+            Entity: The entity with all its metadata and field definitions, including:
+                - name: Entity name
+                - display_name: Human-readable display name
+                - fields: List of field metadata (field names, types, constraints)
+                - record_count: Number of records in the entity
+                - storage_size_in_mb: Storage size used by the entity
+
+        Examples:
+            Basic usage::
+
+                # Retrieve entity metadata
+                entity = await entities_service.retrieve_async("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+                print(f"Entity: {entity.display_name}")
+                print(f"Records: {entity.record_count}")
+
+            Inspecting entity fields::
+
+                entity = await entities_service.retrieve_async("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # List all fields and their types
+                for field in entity.fields:
+                    print(f"{field.name} ({field.sql_type.name})")
+                    print(f"  Required: {field.is_required}")
+                    print(f"  Primary Key: {field.is_primary_key}")
+        """
+        return await self._schema.retrieve_async(entity_key)
+
+    @traced(name="entity_retrieve_by_name", run_type="uipath")
+    def retrieve_by_name(
+        self, entity_name: str, folder_key: Optional[str] = None
+    ) -> Entity:
+        """Retrieve an entity by its name.
+
+        The server resolves the entity within the folder identified by
+        ``folder_key``.  When omitted the default folder from the
+        execution context is used.
+
+        Args:
+            entity_name: The name of the entity.
+            folder_key: Optional folder key for disambiguation.
+        """
+        return self._schema.retrieve_by_name(entity_name, folder_key=folder_key)
+
+    @traced(name="entity_retrieve_by_name", run_type="uipath")
+    async def retrieve_by_name_async(
+        self, entity_name: str, folder_key: Optional[str] = None
+    ) -> Entity:
+        """Asynchronously retrieve an entity by its name.
+
+        The server resolves the entity within the folder identified by
+        ``folder_key``.  When omitted the default folder from the
+        execution context is used.
+
+        Args:
+            entity_name: The name of the entity.
+            folder_key: Optional folder key for disambiguation.
+        """
+        return await self._schema.retrieve_by_name_async(
+            entity_name, folder_key=folder_key
+        )
+
+    @traced(name="list_entities", run_type="uipath")
+    def list_entities(self) -> List[Entity]:
+        """List all entities in Data Service.
+
+        Returns:
+            List[Entity]: A list of all entities with their metadata and field definitions.
+                Each entity includes name, display name, fields, record count, and storage information.
+
+        Examples:
+            List all entities::
+
+                # Get all entities in the Data Service
+                entities = entities_service.list_entities()
+                for entity in entities:
+                    print(f"{entity.display_name} ({entity.name})")
+
+            Find entities with RBAC enabled::
+
+                entities = entities_service.list_entities()
+
+                # Filter to entities with row-based access control
+                rbac_entities = [
+                    e for e in entities
+                    if e.is_rbac_enabled
+                ]
+
+            Summary report::
+
+                entities = entities_service.list_entities()
+
+                total_records = sum(e.record_count or 0 for e in entities)
+                total_storage = sum(e.storage_size_in_mb or 0 for e in entities)
+
+                print(f"Total entities: {len(entities)}")
+                print(f"Total records: {total_records}")
+                print(f"Total storage: {total_storage:.2f} MB")
+        """
+        return self._schema.list_entities()
+
+    @traced(name="list_entities", run_type="uipath")
+    async def list_entities_async(self) -> List[Entity]:
+        """Asynchronously list all entities in the Data Service.
+
+        Returns:
+            List[Entity]: A list of all entities with their metadata and field definitions.
+                Each entity includes name, display name, fields, record count, and storage information.
+
+        Examples:
+            List all entities::
+
+                # Get all entities in the Data Service
+                entities = await entities_service.list_entities_async()
+                for entity in entities:
+                    print(f"{entity.display_name} ({entity.name})")
+
+            Find entities with RBAC enabled::
+
+                entities = await entities_service.list_entities_async()
+
+                # Filter to entities with row-based access control
+                rbac_entities = [
+                    e for e in entities
+                    if e.is_rbac_enabled
+                ]
+
+            Summary report::
+
+                entities = await entities_service.list_entities_async()
+
+                total_records = sum(e.record_count or 0 for e in entities)
+                total_storage = sum(e.storage_size_in_mb or 0 for e in entities)
+
+                print(f"Total entities: {len(entities)}")
+                print(f"Total records: {total_records}")
+                print(f"Total storage: {total_storage:.2f} MB")
+        """
+        return await self._schema.list_entities_async()
+
+    @traced(name="list_choicesets", run_type="uipath")
+    def list_choicesets(self) -> List[Entity]:
+        """List all choice sets in Data Service.
+
+        Returns:
+            List[Entity]: A list of all choice set entities.
+
+        Examples:
+            List all choice sets::
+
+                choicesets = entities_service.list_choicesets()
+                for cs in choicesets:
+                    print(f"{cs.display_name} ({cs.id})")
+        """
+        return self._schema.list_choicesets()
+
+    @traced(name="list_choicesets", run_type="uipath")
+    async def list_choicesets_async(self) -> List[Entity]:
+        """Asynchronously list all choice sets in Data Service.
+
+        Returns:
+            List[Entity]: A list of all choice set entities.
+        """
+        return await self._schema.list_choicesets_async()
+
+    @traced(name="entity_create", run_type="uipath")
+    def create_entity(
+        self,
+        name: str,
+        fields: List[EntityCreateFieldOptions],
+        options: Optional[EntityCreateOptions] = None,
+    ) -> str:
+        """Create a new entity with the given schema and return its id.
+
+        Args:
+            name (str): Entity name. Must start with a letter and contain
+                only letters, digits, and underscores (3-100 characters).
+            fields (List[EntityCreateFieldOptions]): Field definitions for
+                the new entity. Each entry declares the field's name, type,
+                and optional constraints such as ``length_limit``,
+                ``decimal_precision``, ``is_required``, ``is_unique``, etc.
+            options (Optional[EntityCreateOptions]): Optional entity-level
+                settings such as display name, description, folder
+                placement, and RBAC / analytics flags.
+
+        Returns:
+            str: The id (UUID) of the newly created entity.
+
+        Raises:
+            ValueError: If the entity name or any field name fails the
+                client-side validation (regex / length / reserved names) or
+                if a per-field constraint is not supported for that field
+                type or is out of range.
+
+        Examples:
+            Create a simple entity::
+
+                from uipath.platform.entities import (
+                    EntityCreateFieldOptions,
+                    EntityCreateOptions,
+                    EntityFieldDataType,
+                )
+
+                entity_id = entities_service.create_entity(
+                    "ProductCatalog",
+                    [
+                        EntityCreateFieldOptions(
+                            field_name="product_name",
+                            type=EntityFieldDataType.STRING,
+                            is_required=True,
+                            is_unique=True,
+                        ),
+                        EntityCreateFieldOptions(
+                            field_name="price",
+                            type=EntityFieldDataType.DECIMAL,
+                            decimal_precision=2,
+                        ),
+                    ],
+                    options=EntityCreateOptions(
+                        display_name="Product Catalog",
+                        description="Inventory of available products",
+                        is_rbac_enabled=True,
+                    ),
+                )
+        """
+        return self._schema.create_entity(name, fields, options)
+
+    @traced(name="entity_create", run_type="uipath")
+    async def create_entity_async(
+        self,
+        name: str,
+        fields: List[EntityCreateFieldOptions],
+        options: Optional[EntityCreateOptions] = None,
+    ) -> str:
+        """Asynchronously create a new entity with the given schema.
+
+        Args:
+            name (str): Entity name; same validation rules as :meth:`create_entity`.
+            fields (List[EntityCreateFieldOptions]): Field definitions.
+            options (Optional[EntityCreateOptions]): Optional entity-level settings.
+
+        Returns:
+            str: The id (UUID) of the newly created entity.
+
+        Raises:
+            ValueError: For client-side validation failures.
+
+        Examples:
+            Create a simple entity::
+
+                from uipath.platform.entities import (
+                    EntityCreateFieldOptions,
+                    EntityFieldDataType,
+                )
+
+                entity_id = await entities_service.create_entity_async(
+                    "ProductCatalog",
+                    [
+                        EntityCreateFieldOptions(
+                            field_name="product_name",
+                            type=EntityFieldDataType.STRING,
+                            is_required=True,
+                        ),
+                    ],
+                )
+        """
+        return await self._schema.create_entity_async(name, fields, options)
+
+    @traced(name="entity_delete", run_type="uipath")
+    def delete_entity(self, entity_id: str) -> None:
+        """Delete an entity and all of its records.
+
+        Args:
+            entity_id (str): The unique identifier of the entity to delete.
+
+        Examples:
+            Delete an entity by id::
+
+                entities_service.delete_entity("a1b2c3d4-...")
+        """
+        self._schema.delete_entity(entity_id)
+
+    @traced(name="entity_delete", run_type="uipath")
+    async def delete_entity_async(self, entity_id: str) -> None:
+        """Asynchronously delete an entity and all of its records.
+
+        Args:
+            entity_id (str): The unique identifier of the entity to delete.
+
+        Examples:
+            Delete an entity by id::
+
+                await entities_service.delete_entity_async("a1b2c3d4-...")
+        """
+        await self._schema.delete_entity_async(entity_id)
+
+    @traced(name="entity_update_metadata", run_type="uipath")
+    def update_entity_metadata(
+        self,
+        entity_id: str,
+        metadata: EntityMetadataUpdateOptions | Dict[str, Any],
+    ) -> None:
+        """Update an entity's display name, description, and/or RBAC flag.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            metadata (EntityMetadataUpdateOptions | Dict[str, Any]):
+                An :class:`EntityMetadataUpdateOptions` instance or a dict
+                with any of ``display_name``, ``description``,
+                ``is_rbac_enabled``. Dict keys may be snake_case
+                (``display_name``) or camelCase (``displayName``); both
+                serialize correctly to the API.
+
+        Examples:
+            Rename and update description::
+
+                from uipath.platform.entities import EntityMetadataUpdateOptions
+
+                entities_service.update_entity_metadata(
+                    "a1b2c3d4-...",
+                    EntityMetadataUpdateOptions(
+                        display_name="New Display Name",
+                        description="Refreshed description",
+                    ),
+                )
+
+            From a plain dict::
+
+                entities_service.update_entity_metadata(
+                    "a1b2c3d4-...",
+                    {"display_name": "X", "is_rbac_enabled": True},
+                )
+        """
+        self._schema.update_entity_metadata(entity_id, metadata)
+
+    @traced(name="entity_update_metadata", run_type="uipath")
+    async def update_entity_metadata_async(
+        self,
+        entity_id: str,
+        metadata: EntityMetadataUpdateOptions | Dict[str, Any],
+    ) -> None:
+        """Asynchronously update an entity's display name, description, and/or RBAC flag.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            metadata (EntityMetadataUpdateOptions | Dict[str, Any]):
+                An :class:`EntityMetadataUpdateOptions` instance or a dict
+                with any of ``display_name``, ``description``,
+                ``is_rbac_enabled``.
+
+        Examples:
+            Rename::
+
+                from uipath.platform.entities import EntityMetadataUpdateOptions
+
+                await entities_service.update_entity_metadata_async(
+                    "a1b2c3d4-...",
+                    EntityMetadataUpdateOptions(display_name="Renamed Entity"),
+                )
+        """
+        await self._schema.update_entity_metadata_async(entity_id, metadata)
+
+    # ------------------------------------------------------------------
+    # Data operations — delegate to EntityDataService
+    # ------------------------------------------------------------------
+
+    @traced(name="get_choiceset_values", run_type="uipath")
+    def get_choiceset_values(
+        self,
+        choiceset_id: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[ChoiceSetValue]:
+        """Get the values of a choice set by its ID.
+
+        Args:
+            choiceset_id: The unique identifier of the choice set.
+            start: Optional offset for pagination.
+            limit: Optional page size for pagination.
+
+        Returns:
+            List[ChoiceSetValue]: The values in the choice set, each containing
+                id, name, display_name, and number_id.
+
+        Examples:
+            Get all values in a choice set::
+
+                values = entities_service.get_choiceset_values("choiceset-id")
+                for v in values:
+                    print(f"{v.number_id}: {v.display_name}")
+        """
+        return self._data.get_choiceset_values(choiceset_id, start=start, limit=limit)
+
+    @traced(name="get_choiceset_values", run_type="uipath")
+    async def get_choiceset_values_async(
+        self,
+        choiceset_id: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[ChoiceSetValue]:
+        """Asynchronously get the values of a choice set by its ID.
+
+        Args:
+            choiceset_id: The unique identifier of the choice set.
+            start: Optional offset for pagination.
+            limit: Optional page size for pagination.
+
+        Returns:
+            List[ChoiceSetValue]: The values in the choice set.
+        """
+        return await self._data.get_choiceset_values_async(
+            choiceset_id, start=start, limit=limit
+        )
+
+    @traced(name="entity_list_records", run_type="uipath")
+    def list_records(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+        expansion_level: Optional[int] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        select: Optional[List[str]] = None,
+        expand: Optional[List[str]] = None,
+    ) -> EntityRecordsListResponse:
+        """List records from an entity with optional pagination and schema validation.
+
+        The schema parameter enables type-safe access to entity records by validating the
+        data against a user-defined class with type annotations. When provided, each record
+        is validated against the schema's field definitions before being returned.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            schema (Optional[Type[Any]]): Optional schema class for validation. This should be
+                a Python class with type-annotated fields that match the entity's structure.
+
+                Field Validation Rules:
+                - Required fields: Use standard type annotations (e.g., `name: str`)
+                - Optional fields: Use `Optional` or union with None (e.g., `age: Optional[int]` or `age: int | None`)
+                - Field names must match the entity's field names (case-sensitive)
+                - The 'Id' field is automatically validated and does not need to be included
+
+                Example schema class::
+
+                    class CustomerRecord:
+                        name: str  # Required field
+                        email: str  # Required field
+                        age: Optional[int]  # Optional field
+                        phone: str | None  # Optional field (Python 3.10+ syntax)
+
+                Benefits of using schema:
+                - Type safety: Ensures records match expected structure
+                - Early validation: Catches data issues before processing
+                - Documentation: Schema serves as clear contract for record structure
+                - IDE support: Enables better autocomplete and type checking
+
+                When schema validation fails, a `ValueError` is raised with details about
+                the validation error (e.g., missing required fields, type mismatches).
+
+            start (Optional[int]): Starting index for pagination (0-based).
+            limit (Optional[int]): Maximum number of records to return.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in the
+                response (``0`` means no expansion). Higher values inline related
+                records up to that many hops.
+            filter (Optional[str]): OData ``$filter`` expression
+                (e.g. ``"status eq 'active'"``).
+            orderby (Optional[str]): OData ``$orderby`` expression
+                (e.g. ``"created_at desc"``).
+            select (Optional[List[str]]): Column projection — field names to
+                include (rendered as ``$select``).
+            expand (Optional[List[str]]): Relationship names to expand inline
+                (rendered as ``$expand``).
+
+        Returns:
+            EntityRecordsListResponse: A list-compatible response with
+                ``total_count``, ``has_next_page`` and ``next_cursor`` pagination
+                metadata. Iteration, indexing, and ``len()`` continue to work
+                like a plain list of :class:`EntityRecord`.
+
+        Raises:
+            ValueError: If schema validation fails for any record, including cases where
+                required fields are missing or field types don't match the schema.
+
+        Examples:
+            Basic usage without schema::
+
+                # Retrieve all records from an entity
+                records = entities_service.list_records("Customers")
+                for record in records:
+                    print(record.id)
+
+            With pagination::
+
+                # Get first 50 records
+                records = entities_service.list_records("Customers", start=0, limit=50)
+                print(f"Showing {len(records)} of {records.total_count} total")
+                if records.has_next_page:
+                    next_page = entities_service.list_records(
+                        "Customers", start=50, limit=50
+                    )
+
+            With OData filter, sorting, projection, and expansion::
+
+                records = entities_service.list_records(
+                    "Customers",
+                    filter="status eq 'active'",
+                    orderby="created_at desc",
+                    select=["name", "email", "status"],
+                    expand=["company"],
+                    expansion_level=1,
+                )
+
+            With schema validation::
+
+                class CustomerRecord:
+                    name: str
+                    email: str
+                    age: Optional[int]
+                    is_active: bool
+
+                # Records are validated against CustomerRecord schema
+                records = entities_service.list_records(
+                    "Customers",
+                    schema=CustomerRecord
+                )
+
+                # Safe to access fields knowing they match the schema
+                for record in records:
+                    print(f"{record.name}: {record.email}")
+        """
+        return self._data.list_records(
+            entity_key,
+            schema=schema,
+            start=start,
+            limit=limit,
+            expansion_level=expansion_level,
+            filter=filter,
+            orderby=orderby,
+            select=select,
+            expand=expand,
+        )
+
+    @traced(name="entity_list_records", run_type="uipath")
+    async def list_records_async(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+        expansion_level: Optional[int] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        select: Optional[List[str]] = None,
+        expand: Optional[List[str]] = None,
+    ) -> EntityRecordsListResponse:
+        """Asynchronously list records from an entity with optional pagination and schema validation.
+
+        The schema parameter enables type-safe access to entity records by validating the
+        data against a user-defined class with type annotations. When provided, each record
+        is validated against the schema's field definitions before being returned.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            schema (Optional[Type[Any]]): Optional schema class for validation. This should be
+                a Python class with type-annotated fields that match the entity's structure.
+
+                Field Validation Rules:
+                - Required fields: Use standard type annotations (e.g., `name: str`)
+                - Optional fields: Use `Optional` or union with None (e.g., `age: Optional[int]` or `age: int | None`)
+                - Field names must match the entity's field names (case-sensitive)
+                - The 'Id' field is automatically validated and does not need to be included
+
+                Example schema class::
+
+                    class CustomerRecord:
+                        name: str  # Required field
+                        email: str  # Required field
+                        age: Optional[int]  # Optional field
+                        phone: str | None  # Optional field (Python 3.10+ syntax)
+
+                Benefits of using schema:
+                - Type safety: Ensures records match expected structure
+                - Early validation: Catches data issues before processing
+                - Documentation: Schema serves as clear contract for record structure
+                - IDE support: Enables better autocomplete and type checking
+
+                When schema validation fails, a `ValueError` is raised with details about
+                the validation error (e.g., missing required fields, type mismatches).
+
+            start (Optional[int]): Starting index for pagination (0-based).
+            limit (Optional[int]): Maximum number of records to return.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in the
+                response (``0`` means no expansion). Higher values inline related
+                records up to that many hops.
+            filter (Optional[str]): OData ``$filter`` expression
+                (e.g. ``"status eq 'active'"``).
+            orderby (Optional[str]): OData ``$orderby`` expression
+                (e.g. ``"created_at desc"``).
+            select (Optional[List[str]]): Column projection — field names to
+                include (rendered as ``$select``).
+            expand (Optional[List[str]]): Relationship names to expand inline
+                (rendered as ``$expand``).
+
+        Returns:
+            EntityRecordsListResponse: A list-compatible response with
+                ``total_count``, ``has_next_page`` and ``next_cursor`` pagination
+                metadata. Iteration, indexing, and ``len()`` continue to work
+                like a plain list of :class:`EntityRecord`.
+
+        Raises:
+            ValueError: If schema validation fails for any record, including cases where
+                required fields are missing or field types don't match the schema.
+
+        Examples:
+            Basic usage without schema::
+
+                # Retrieve all records from an entity
+                records = await entities_service.list_records_async("Customers")
+                for record in records:
+                    print(record.id)
+
+            With pagination::
+
+                # Get first 50 records
+                records = await entities_service.list_records_async("Customers", start=0, limit=50)
+                print(f"Showing {len(records)} of {records.total_count} total")
+                if records.has_next_page:
+                    next_page = await entities_service.list_records_async(
+                        "Customers", start=50, limit=50
+                    )
+
+            With OData filter, sorting, projection, and expansion::
+
+                records = await entities_service.list_records_async(
+                    "Customers",
+                    filter="status eq 'active'",
+                    orderby="created_at desc",
+                    select=["name", "email", "status"],
+                    expand=["company"],
+                    expansion_level=1,
+                )
+
+            With schema validation::
+
+                class CustomerRecord:
+                    name: str
+                    email: str
+                    age: Optional[int]
+                    is_active: bool
+
+                # Records are validated against CustomerRecord schema
+                records = await entities_service.list_records_async(
+                    "Customers",
+                    schema=CustomerRecord
+                )
+
+                # Safe to access fields knowing they match the schema
+                for record in records:
+                    print(f"{record.name}: {record.email}")
+        """
+        return await self._data.list_records_async(
+            entity_key,
+            schema=schema,
+            start=start,
+            limit=limit,
+            expansion_level=expansion_level,
+            filter=filter,
+            orderby=orderby,
+            select=select,
+            expand=expand,
+        )
+
+    @traced(name="entity_insert_record", run_type="uipath")
+    def insert_record(
+        self,
+        entity_key: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Insert a single record into an entity and return the inserted row.
+
+        Note:
+            Unlike :meth:`insert_records` (batch), this single-record endpoint
+            fires Data Fabric trigger events. Use this method when triggers
+            attached to the entity must run.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            data (Any): Record payload — a dict, a Pydantic model, an
+                :class:`EntityRecord`, or any object exposing ``__dict__``.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+
+        Returns:
+            EntityRecord: The inserted record with its server-assigned ``Id``
+                plus any expanded relationships.
+
+        Examples:
+            Insert from a dict::
+
+                record = entities_service.insert_record(
+                    "Customers",
+                    {"name": "Alice", "email": "alice@example.com"},
+                )
+                print(record.id)
+
+            Insert from a Pydantic model::
+
+                class CustomerInput(BaseModel):
+                    name: str
+                    email: str
+
+                record = entities_service.insert_record(
+                    "Customers",
+                    CustomerInput(name="Bob", email="bob@example.com"),
+                    expansion_level=1,
+                )
+        """
+        return self._data.insert_record(
+            entity_key, data, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_insert_record", run_type="uipath")
+    async def insert_record_async(
+        self,
+        entity_key: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Asynchronously insert a single record into an entity.
+
+        Note:
+            Unlike :meth:`insert_records_async` (batch), this single-record
+            endpoint fires Data Fabric trigger events. Use this method when
+            triggers attached to the entity must run.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            data (Any): Record payload — a dict, a Pydantic model, an
+                :class:`EntityRecord`, or any object exposing ``__dict__``.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+
+        Returns:
+            EntityRecord: The inserted record with its server-assigned ``Id``.
+
+        Examples:
+            Insert from a dict::
+
+                record = await entities_service.insert_record_async(
+                    "Customers",
+                    {"name": "Alice", "email": "alice@example.com"},
+                )
+                print(record.id)
+        """
+        return await self._data.insert_record_async(
+            entity_key, data, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_get_record", run_type="uipath")
+    def get_record(
+        self,
+        entity_key: str,
+        record_id: str,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Fetch a single entity record by its id.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to fetch.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+
+        Returns:
+            EntityRecord: The record, with optional expanded relationships.
+
+        Examples:
+            Basic usage::
+
+                record = entities_service.get_record("Customers", "rec-1")
+                print(record.id, record.name)
+
+            With FK expansion::
+
+                # Inline the related Company record on the returned Customer
+                record = entities_service.get_record(
+                    "Customers", "rec-1", expansion_level=1
+                )
+        """
+        return self._data.get_record(
+            entity_key, record_id, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_get_record", run_type="uipath")
+    async def get_record_async(
+        self,
+        entity_key: str,
+        record_id: str,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Asynchronously fetch a single entity record by its id.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to fetch.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+
+        Returns:
+            EntityRecord: The record.
+
+        Examples:
+            Basic usage::
+
+                record = await entities_service.get_record_async("Customers", "rec-1")
+                print(record.id, record.name)
+        """
+        return await self._data.get_record_async(
+            entity_key, record_id, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_update_record", run_type="uipath")
+    def update_record(
+        self,
+        entity_key: str,
+        record_id: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Update a single record by id and return the updated row.
+
+        Note:
+            Unlike :meth:`update_records` (batch), this single-record endpoint
+            fires Data Fabric trigger events. Use this method when triggers
+            attached to the entity must run.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to update.
+            data (Any): Fields to update — a dict, a Pydantic model, or any
+                object exposing ``__dict__``. Fields explicitly set to
+                ``None`` are sent through; unset fields are omitted.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+
+        Returns:
+            EntityRecord: The updated record.
+
+        Examples:
+            Partial update from a dict::
+
+                record = entities_service.update_record(
+                    "Customers",
+                    "rec-1",
+                    {"email": "alice.new@example.com"},
+                )
+
+            Clear a field by passing an explicit ``None``::
+
+                # Note: unset fields are omitted; explicit None values are sent.
+                record = entities_service.update_record(
+                    "Customers",
+                    "rec-1",
+                    {"middle_name": None},
+                )
+        """
+        return self._data.update_record(
+            entity_key, record_id, data, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_update_record", run_type="uipath")
+    async def update_record_async(
+        self,
+        entity_key: str,
+        record_id: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Asynchronously update a single record by id.
+
+        Note:
+            Unlike :meth:`update_records_async` (batch), this single-record
+            endpoint fires Data Fabric trigger events.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to update.
+            data (Any): Fields to update — a dict, a Pydantic model, or any
+                object exposing ``__dict__``.
+            expansion_level (Optional[int]): Depth of foreign-key expansion.
+
+        Returns:
+            EntityRecord: The updated record.
+
+        Examples:
+            Partial update::
+
+                record = await entities_service.update_record_async(
+                    "Customers",
+                    "rec-1",
+                    {"email": "alice.new@example.com"},
+                )
+        """
+        return await self._data.update_record_async(
+            entity_key, record_id, data, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_delete_record", run_type="uipath")
+    def delete_record(self, entity_key: str, record_id: str) -> None:
+        """Delete a single record by id.
+
+        Note:
+            Unlike :meth:`delete_records` (batch), this single-record endpoint
+            fires Data Fabric trigger events. Use this method when triggers
+            attached to the entity must run on delete.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to delete.
+
+        Examples:
+            Delete by id::
+
+                entities_service.delete_record("Customers", "rec-1")
+        """
+        self._data.delete_record(entity_key, record_id)
+
+    @traced(name="entity_delete_record", run_type="uipath")
+    async def delete_record_async(self, entity_key: str, record_id: str) -> None:
+        """Asynchronously delete a single record by id.
+
+        Note:
+            Unlike :meth:`delete_records_async` (batch), this single-record
+            endpoint fires Data Fabric trigger events.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_id (str): The unique identifier of the record to delete.
+
+        Examples:
+            Delete by id::
+
+                await entities_service.delete_record_async("Customers", "rec-1")
+        """
+        await self._data.delete_record_async(entity_key, record_id)
+
+    @traced(name="entity_record_insert_batch", run_type="uipath")
+    def insert_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Insert multiple records into an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to insert. Each record may be
+                a dict, a Pydantic model, an :class:`EntityRecord`, or any
+                object exposing ``__dict__``.
+            schema (Optional[Type[Any]]): Optional schema class for validation. When provided,
+                validates that each record in the response matches the schema structure.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully inserted :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Insert records without schema::
+
+                class Customer:
+                    def __init__(self, name, email, age):
+                        self.name = name
+                        self.email = email
+                        self.age = age
+
+                customers = [
+                    Customer("John Doe", "john@example.com", 30),
+                    Customer("Jane Smith", "jane@example.com", 25),
+                ]
+
+                response = entities_service.insert_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    customers
+                )
+
+                print(f"Inserted: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Insert with FK expansion and fail-fast::
+
+                response = entities_service.insert_records(
+                    "Orders",
+                    [{"product_id": "p-1", "qty": 3}, {"product_id": "p-2", "qty": 1}],
+                    expansion_level=1,    # inline the related Product on each response record
+                    fail_on_first=True,   # abort the batch at the first error
+                )
+
+            Insert with schema validation::
+
+                class CustomerSchema:
+                    name: str
+                    email: str
+                    age: int
+
+                class Customer:
+                    def __init__(self, name, email, age):
+                        self.name = name
+                        self.email = email
+                        self.age = age
+
+                customers = [Customer("Alice Brown", "alice@example.com", 28)]
+
+                response = entities_service.insert_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    customers,
+                    schema=CustomerSchema
+                )
+
+                # Access inserted records with validated structure
+                for record in response.success_records:
+                    print(f"Inserted: {record.name} (ID: {record.id})")
+        """
+        return self._data.insert_records(
+            entity_key,
+            records,
+            schema=schema,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+    @traced(name="entity_record_insert_batch", run_type="uipath")
+    async def insert_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously insert multiple records into an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to insert. Each record may be
+                a dict, a Pydantic model, an :class:`EntityRecord`, or any
+                object exposing ``__dict__``.
+            schema (Optional[Type[Any]]): Optional schema class for validation. When provided,
+                validates that each record in the response matches the schema structure.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully inserted :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Insert records without schema::
+
+                class Customer:
+                    def __init__(self, name, email, age):
+                        self.name = name
+                        self.email = email
+                        self.age = age
+
+                customers = [
+                    Customer("John Doe", "john@example.com", 30),
+                    Customer("Jane Smith", "jane@example.com", 25),
+                ]
+
+                response = await entities_service.insert_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    customers
+                )
+
+                print(f"Inserted: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Insert with schema validation::
+
+                class CustomerSchema:
+                    name: str
+                    email: str
+                    age: int
+
+                class Customer:
+                    def __init__(self, name, email, age):
+                        self.name = name
+                        self.email = email
+                        self.age = age
+
+                customers = [Customer("Alice Brown", "alice@example.com", 28)]
+
+                response = await entities_service.insert_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    customers,
+                    schema=CustomerSchema
+                )
+
+                # Access inserted records with validated structure
+                for record in response.success_records:
+                    print(f"Inserted: {record.name} (ID: {record.id})")
+        """
+        return await self._data.insert_records_async(
+            entity_key,
+            records,
+            schema=schema,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+    @traced(name="entity_record_update_batch", run_type="uipath")
+    def update_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Update multiple records in an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to update. Each record must
+                include its ``Id`` field. A record may be a dict, a Pydantic
+                model, an :class:`EntityRecord`, or any object exposing
+                ``__dict__``.
+            schema (Optional[Type[Any]]): Optional schema class for validation. When provided,
+                validates that each record in the request and response matches the schema structure.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully updated :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Update records::
+
+                # First, retrieve records to update
+                records = entities_service.list_records("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # Modify the records
+                for record in records:
+                    if record.name == "John Doe":
+                        record.age = 31
+
+                # Update the modified records
+                response = entities_service.update_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    records
+                )
+
+                print(f"Updated: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Update with schema validation::
+
+                class CustomerSchema:
+                    name: str
+                    email: str
+                    age: int
+
+                # Retrieve and update
+                records = entities_service.list_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    schema=CustomerSchema
+                )
+
+                # Modify specific records
+                for record in records:
+                    if record.age < 30:
+                        record.is_active = True
+
+                response = entities_service.update_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    records,
+                    schema=CustomerSchema
+                )
+
+                for record in response.success_records:
+                    print(f"Updated: {record.name}")
+        """
+        return self._data.update_records(
+            entity_key,
+            records,
+            schema=schema,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+    @traced(name="entity_record_update_batch", run_type="uipath")
+    async def update_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously update multiple records in an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to update. Each record must
+                include its ``Id`` field. A record may be a dict, a Pydantic
+                model, an :class:`EntityRecord`, or any object exposing
+                ``__dict__``.
+            schema (Optional[Type[Any]]): Optional schema class for validation. When provided,
+                validates that each record in the request and response matches the schema structure.
+            expansion_level (Optional[int]): Depth of foreign-key expansion in
+                the response (``0`` means no expansion).
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully updated :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Update records::
+
+                # First, retrieve records to update
+                records = await entities_service.list_records_async("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # Modify the records
+                for record in records:
+                    if record.name == "John Doe":
+                        record.age = 31
+
+                # Update the modified records
+                response = await entities_service.update_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    records
+                )
+
+                print(f"Updated: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Update with schema validation::
+
+                class CustomerSchema:
+                    name: str
+                    email: str
+                    age: int
+
+                # Retrieve and update
+                records = await entities_service.list_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    schema=CustomerSchema
+                )
+
+                # Modify specific records
+                for record in records:
+                    if record.age < 30:
+                        record.is_active = True
+
+                response = await entities_service.update_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    records,
+                    schema=CustomerSchema
+                )
+
+                for record in response.success_records:
+                    print(f"Updated: {record.name}")
+        """
+        return await self._data.update_records_async(
+            entity_key,
+            records,
+            schema=schema,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+    @traced(name="entity_record_delete_batch", run_type="uipath")
+    def delete_records(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Delete multiple records from an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_ids (List[str]): List of record IDs (GUIDs) to delete.
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully deleted :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Delete specific records by ID::
+
+                # Delete records by their IDs
+                record_ids = [
+                    "12345678-1234-1234-1234-123456789012",
+                    "87654321-4321-4321-4321-210987654321",
+                ]
+
+                response = entities_service.delete_records(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    record_ids
+                )
+
+                print(f"Deleted: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Delete records matching a condition::
+
+                # Get all records
+                records = entities_service.list_records("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # Filter records to delete (e.g., inactive customers)
+                ids_to_delete = [
+                    record.id for record in records
+                    if not getattr(record, 'is_active', True)
+                ]
+
+                if ids_to_delete:
+                    response = entities_service.delete_records(
+                        "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                        ids_to_delete
+                    )
+                    print(f"Deleted {len(response.success_records)} inactive records")
+        """
+        return self._data.delete_records(
+            entity_key, record_ids, fail_on_first=fail_on_first
+        )
+
+    @traced(name="entity_record_delete_batch", run_type="uipath")
+    async def delete_records_async(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously delete multiple records from an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_ids (List[str]): List of record IDs (GUIDs) to delete.
+            fail_on_first (Optional[bool]): When ``True``, stop the batch on
+                the first per-record failure. When ``False`` (default), all
+                records are attempted and the response lists both
+                ``success_records`` and ``failure_records``.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+                - success_records: List of successfully deleted :class:`EntityRecord` objects
+                - failure_records: List of :class:`FailureRecord` describing per-record errors
+
+        Examples:
+            Delete specific records by ID::
+
+                # Delete records by their IDs
+                record_ids = [
+                    "12345678-1234-1234-1234-123456789012",
+                    "87654321-4321-4321-4321-210987654321",
+                ]
+
+                response = await entities_service.delete_records_async(
+                    "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    record_ids
+                )
+
+                print(f"Deleted: {len(response.success_records)}")
+                print(f"Failed: {len(response.failure_records)}")
+
+            Delete records matching a condition::
+
+                # Get all records
+                records = await entities_service.list_records_async("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+                # Filter records to delete (e.g., inactive customers)
+                ids_to_delete = [
+                    record.id for record in records
+                    if not getattr(record, 'is_active', True)
+                ]
+
+                if ids_to_delete:
+                    response = await entities_service.delete_records_async(
+                        "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                        ids_to_delete
+                    )
+                    print(f"Deleted {len(response.success_records)} inactive records")
+        """
+        return await self._data.delete_records_async(
+            entity_key, record_ids, fail_on_first=fail_on_first
+        )
+
+    @traced(name="entity_retrieve_records", run_type="uipath")
+    def retrieve_records(
+        self,
+        entity_key: str,
+        filter_group: Optional[EntityQueryFilterGroup] = None,
+        sort_options: Optional[List[EntityQuerySortOption]] = None,
+        selected_fields: Optional[List[str]] = None,
+        expansions: Optional[List[Any]] = None,
+        expansion_level: Optional[int] = None,
+        aggregates: Optional[List[EntityAggregate]] = None,
+        group_by: Optional[List[str]] = None,
+        joins: Optional[List[EntityJoin]] = None,
+        binnings: Optional[List[EntityBinning]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RetrieveEntityRecordsResponse:
+        """Retrieve records with structured filters, sorting, expansion, joins, and aggregates.
+
+        Routes to the V2 endpoint when ``binnings`` is provided (numeric/date
+        binning is gated by the ``enable-binning-on-query`` feature flag on
+        the backend).
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            filter_group (Optional[EntityQueryFilterGroup]): Nested filter
+                conditions combined with AND/OR.
+            sort_options (Optional[List[EntityQuerySortOption]]): Sort fields
+                and direction.
+            selected_fields (Optional[List[str]]): Column projection — field
+                names to include; omit to return all fields.
+            expansions (Optional[List[Any]]): Foreign-key relationships to
+                expand inline on each result record.
+            expansion_level (Optional[int]): Depth of expansion (sent as a
+                URL query param).
+            aggregates (Optional[List[EntityAggregate]]): Aggregate
+                expressions (``COUNT`` / ``SUM`` / ``AVG`` / ``MIN`` /
+                ``MAX``). Maximum 5 per query.
+            group_by (Optional[List[str]]): Fields to group aggregate results
+                by. Maximum 5; required when both ``aggregates`` and
+                ``selected_fields`` are supplied.
+            joins (Optional[List[EntityJoin]]): Cross-entity joins. Maximum
+                3, all of the same type.
+            binnings (Optional[List[EntityBinning]]): Bucket numeric or date
+                group-by fields. Each entry's field must also appear in
+                ``group_by``.
+            start (Optional[int]): Records to skip (pagination offset).
+            limit (Optional[int]): Maximum number of records to return.
+
+        Returns:
+            RetrieveEntityRecordsResponse: A response with ``items``,
+                ``total_count``, ``has_next_page``, and ``next_cursor``.
+                ``items`` is a list of :class:`EntityRecord` for plain
+                queries, or :class:`AggregateRow` when ``aggregates``,
+                ``group_by``, or ``binnings`` are used. ``next_cursor`` is
+                populated only when the backend returns one; otherwise
+                paginate by passing the next ``start``.
+
+        Examples:
+            Filter + sort + projection::
+
+                from uipath.platform.entities import (
+                    EntityQueryFilter,
+                    EntityQueryFilterGroup,
+                    EntityQuerySortOption,
+                    LogicalOperator,
+                    QueryFilterOperator,
+                )
+
+                result = entities_service.retrieve_records(
+                    "Customers",
+                    filter_group=EntityQueryFilterGroup(
+                        logical_operator=LogicalOperator.And,
+                        query_filters=[
+                            EntityQueryFilter(
+                                field_name="status",
+                                operator=QueryFilterOperator.Equals,
+                                value="active",
+                            )
+                        ],
+                    ),
+                    sort_options=[
+                        EntityQuerySortOption(field_name="created_at", is_descending=True)
+                    ],
+                    selected_fields=["Id", "name", "email"],
+                    start=0,
+                    limit=50,
+                )
+                print(f"Found {result.total_count} customers")
+
+            Aggregates and group-by (counts per status)::
+
+                from uipath.platform.entities import (
+                    EntityAggregate,
+                    EntityAggregateFunction,
+                )
+
+                result = entities_service.retrieve_records(
+                    "Customers",
+                    selected_fields=["status"],
+                    group_by=["status"],
+                    aggregates=[
+                        EntityAggregate(
+                            function=EntityAggregateFunction.Count,
+                            field="Id",
+                            alias="total",
+                        )
+                    ],
+                )
+                for row in result.items:
+                    print(row.status, row.total)
+        """
+        return self._data.retrieve_records(
+            entity_key,
+            filter_group=filter_group,
+            sort_options=sort_options,
+            selected_fields=selected_fields,
+            expansions=expansions,
+            expansion_level=expansion_level,
+            aggregates=aggregates,
+            group_by=group_by,
+            joins=joins,
+            binnings=binnings,
+            start=start,
+            limit=limit,
+        )
+
+    @traced(name="entity_retrieve_records", run_type="uipath")
+    async def retrieve_records_async(
+        self,
+        entity_key: str,
+        filter_group: Optional[EntityQueryFilterGroup] = None,
+        sort_options: Optional[List[EntityQuerySortOption]] = None,
+        selected_fields: Optional[List[str]] = None,
+        expansions: Optional[List[Any]] = None,
+        expansion_level: Optional[int] = None,
+        aggregates: Optional[List[EntityAggregate]] = None,
+        group_by: Optional[List[str]] = None,
+        joins: Optional[List[EntityJoin]] = None,
+        binnings: Optional[List[EntityBinning]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RetrieveEntityRecordsResponse:
+        """Asynchronously retrieve records with structured filters, sorting, expansion, joins, and aggregates.
+
+        Routes to the V2 endpoint when ``binnings`` is provided (numeric/date
+        binning is gated by the ``enable-binning-on-query`` feature flag on
+        the backend).
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            filter_group (Optional[EntityQueryFilterGroup]): Nested filter
+                conditions combined with AND/OR.
+            sort_options (Optional[List[EntityQuerySortOption]]): Sort fields
+                and direction.
+            selected_fields (Optional[List[str]]): Column projection — field
+                names to include; omit to return all fields.
+            expansions (Optional[List[Any]]): Foreign-key relationships to
+                expand inline on each result record.
+            expansion_level (Optional[int]): Depth of expansion.
+            aggregates (Optional[List[EntityAggregate]]): Aggregate
+                expressions. Maximum 5 per query.
+            group_by (Optional[List[str]]): Fields to group aggregate results
+                by. Maximum 5; required when both ``aggregates`` and
+                ``selected_fields`` are supplied.
+            joins (Optional[List[EntityJoin]]): Cross-entity joins. Maximum
+                3, all of the same type.
+            binnings (Optional[List[EntityBinning]]): Bucket numeric or date
+                group-by fields.
+            start (Optional[int]): Records to skip (pagination offset).
+            limit (Optional[int]): Maximum number of records to return.
+
+        Returns:
+            RetrieveEntityRecordsResponse: A response with ``items``,
+                ``total_count``, ``has_next_page``, and ``next_cursor``.
+
+        Examples:
+            Filter + sort + pagination::
+
+                from uipath.platform.entities import (
+                    EntityQueryFilter,
+                    EntityQueryFilterGroup,
+                    QueryFilterOperator,
+                )
+
+                result = await entities_service.retrieve_records_async(
+                    "Customers",
+                    filter_group=EntityQueryFilterGroup(
+                        query_filters=[
+                            EntityQueryFilter(
+                                field_name="status",
+                                operator=QueryFilterOperator.Equals,
+                                value="active",
+                            )
+                        ],
+                    ),
+                    start=0,
+                    limit=25,
+                )
+                print(f"{len(result.items)} of {result.total_count} customers")
+        """
+        return await self._data.retrieve_records_async(
+            entity_key,
+            filter_group=filter_group,
+            sort_options=sort_options,
+            selected_fields=selected_fields,
+            expansions=expansions,
+            expansion_level=expansion_level,
+            aggregates=aggregates,
+            group_by=group_by,
+            joins=joins,
+            binnings=binnings,
+            start=start,
+            limit=limit,
+        )
+
+    @traced(name="entity_query_records", run_type="uipath")
+    def query_entity_records(self, sql_query: str) -> List[Dict[str, Any]]:
+        """Query entity records using a validated SQL query.
+
+        PREVIEW: This method is in preview and may change in future releases.
+
+        Args:
+            sql_query (str): A SQL SELECT query to execute against Data Service entities.
+                Only SELECT statements are allowed. Queries without WHERE must include
+                a LIMIT clause. Subqueries and multi-statement queries are not permitted.
+
+        Notes:
+            A routing context is always derived from the configured ``folders_map``
+            when present and included in the request body.
+
+        Returns:
+            List[Dict[str, Any]]: A list of result records as dictionaries.
+
+        Raises:
+            ValueError: If the SQL query fails validation (e.g., non-SELECT, missing
+                WHERE/LIMIT, forbidden keywords, subqueries).
+        """
+        return self._data.query_entity_records(sql_query)
+
+    @traced(name="entity_query_records", run_type="uipath")
+    async def query_entity_records_async(self, sql_query: str) -> List[Dict[str, Any]]:
+        """Asynchronously query entity records using a validated SQL query.
+
+        PREVIEW: This method is in preview and may change in future releases.
+
+        Args:
+            sql_query (str): A SQL SELECT query to execute against Data Service entities.
+                Only SELECT statements are allowed. Queries without WHERE must include
+                a LIMIT clause. Subqueries and multi-statement queries are not permitted.
+
+        Notes:
+            A routing context is always derived from the configured ``folders_map``
+            when present and included in the request body.
+
+        Returns:
+            List[Dict[str, Any]]: A list of result records as dictionaries.
+
+        Raises:
+            ValueError: If the SQL query fails validation (e.g., non-SELECT, missing
+                WHERE/LIMIT, forbidden keywords, subqueries).
+        """
+        return await self._data.query_entity_records_async(sql_query)
+
+    @traced(name="entity_upload_attachment", run_type="uipath")
+    def upload_attachment(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Upload a file attachment to a File-type field on a record.
+
+        Provide exactly one of ``file`` (raw bytes) or ``file_path`` (path on
+        disk).
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record whose
+                attachment field is being set.
+            field_name (str): Name of the File-type field on the entity.
+            file (Optional[FileContent]): Raw bytes (``bytes`` /
+                ``bytearray`` / ``memoryview``) of the file to upload.
+                Mutually exclusive with ``file_path``.
+            file_path (Optional[str]): Path to a local file to upload.
+                Mutually exclusive with ``file``.
+            expansion_level (Optional[int]): Optional FK expansion depth in
+                the response (``0`` means no expansion).
+
+        Returns:
+            Dict[str, Any]: The decoded JSON response (typically the updated
+                record), or an empty dict when the response has no body.
+
+        Examples:
+            Upload from raw bytes::
+
+                with open("contract.pdf", "rb") as f:
+                    data = f.read()
+                entities_service.upload_attachment(
+                    "Customers", "rec-1", "Contract", file=data
+                )
+
+            Upload from a path on disk::
+
+                entities_service.upload_attachment(
+                    "Customers", "rec-1", "Contract", file_path="./contract.pdf"
+                )
+        """
+        return self._data.upload_attachment(
+            entity_id,
+            record_id,
+            field_name,
+            file=file,
+            file_path=file_path,
+            expansion_level=expansion_level,
+        )
+
+    @traced(name="entity_upload_attachment", run_type="uipath")
+    async def upload_attachment_async(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Asynchronously upload a file attachment to a File-type field on a record.
+
+        Provide exactly one of ``file`` (raw bytes) or ``file_path`` (path on
+        disk).
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record whose
+                attachment field is being set.
+            field_name (str): Name of the File-type field on the entity.
+            file (Optional[FileContent]): Raw bytes of the file to upload.
+                Mutually exclusive with ``file_path``.
+            file_path (Optional[str]): Path to a local file to upload.
+                Mutually exclusive with ``file``.
+            expansion_level (Optional[int]): Optional FK expansion depth in
+                the response.
+
+        Returns:
+            Dict[str, Any]: The decoded JSON response.
+
+        Examples:
+            Upload from a path on disk::
+
+                await entities_service.upload_attachment_async(
+                    "Customers", "rec-1", "Contract", file_path="./contract.pdf"
+                )
+        """
+        return await self._data.upload_attachment_async(
+            entity_id,
+            record_id,
+            field_name,
+            file=file,
+            file_path=file_path,
+            expansion_level=expansion_level,
+        )
+
+    @traced(name="entity_download_attachment", run_type="uipath")
+    def download_attachment(
+        self, entity_id: str, record_id: str, field_name: str
+    ) -> bytes:
+        """Download a file attached to a record and return its raw bytes.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record containing
+                the attachment.
+            field_name (str): Name of the File-type field on the entity.
+
+        Returns:
+            bytes: The raw file content.
+
+        Examples:
+            Save the downloaded bytes to disk::
+
+                content = entities_service.download_attachment(
+                    "Customers", "rec-1", "Contract"
+                )
+                with open("downloaded.pdf", "wb") as f:
+                    f.write(content)
+        """
+        return self._data.download_attachment(entity_id, record_id, field_name)
+
+    @traced(name="entity_download_attachment", run_type="uipath")
+    async def download_attachment_async(
+        self, entity_id: str, record_id: str, field_name: str
+    ) -> bytes:
+        """Asynchronously download a file attached to a record.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record containing
+                the attachment.
+            field_name (str): Name of the File-type field on the entity.
+
+        Returns:
+            bytes: The raw file content.
+
+        Examples:
+            Save the downloaded bytes to disk::
+
+                content = await entities_service.download_attachment_async(
+                    "Customers", "rec-1", "Contract"
+                )
+                with open("downloaded.pdf", "wb") as f:
+                    f.write(content)
+        """
+        return await self._data.download_attachment_async(
+            entity_id, record_id, field_name
+        )
+
+    @traced(name="entity_delete_attachment", run_type="uipath")
+    def delete_attachment(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Remove the file attached to a File-type field on a record.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record whose
+                attachment is being removed.
+            field_name (str): Name of the File-type field on the entity.
+            expansion_level (Optional[int]): Optional FK expansion depth in
+                the response (``0`` means no expansion).
+
+        Returns:
+            Dict[str, Any]: The decoded JSON response (typically the updated
+                record), or an empty dict when the response has no body.
+
+        Examples:
+            Clear an attachment::
+
+                entities_service.delete_attachment(
+                    "Customers", "rec-1", "Contract"
+                )
+        """
+        return self._data.delete_attachment(
+            entity_id, record_id, field_name, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_delete_attachment", run_type="uipath")
+    async def delete_attachment_async(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Asynchronously remove the file attached to a File-type field.
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            record_id (str): The unique identifier of the record whose
+                attachment is being removed.
+            field_name (str): Name of the File-type field on the entity.
+            expansion_level (Optional[int]): Optional FK expansion depth.
+
+        Returns:
+            Dict[str, Any]: The decoded JSON response.
+
+        Examples:
+            Clear an attachment::
+
+                await entities_service.delete_attachment_async(
+                    "Customers", "rec-1", "Contract"
+                )
+        """
+        return await self._data.delete_attachment_async(
+            entity_id, record_id, field_name, expansion_level=expansion_level
+        )
+
+    @traced(name="entity_import_records", run_type="uipath")
+    def import_records(
+        self,
+        entity_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> EntityImportRecordsResponse:
+        """Bulk-import records into an entity from a CSV file.
+
+        Provide exactly one of ``file`` (raw bytes) or ``file_path`` (path on
+        disk).
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            file (Optional[FileContent]): Raw bytes of a CSV file. Mutually
+                exclusive with ``file_path``.
+            file_path (Optional[str]): Path to a local CSV file. Mutually
+                exclusive with ``file``.
+
+        Returns:
+            EntityImportRecordsResponse: Reports the total rows in the file,
+                the number successfully inserted, and an optional
+                ``error_file_link`` pointing to a CSV listing rows that
+                failed validation.
+
+        Examples:
+            Import from a path on disk::
+
+                result = entities_service.import_records(
+                    "Customers", file_path="./customers.csv"
+                )
+                print(
+                    f"Inserted {result.inserted_records} of "
+                    f"{result.total_records} rows"
+                )
+                if result.error_file_link:
+                    print(f"Errors: {result.error_file_link}")
+        """
+        return self._data.import_records(entity_id, file=file, file_path=file_path)
+
+    @traced(name="entity_import_records", run_type="uipath")
+    async def import_records_async(
+        self,
+        entity_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> EntityImportRecordsResponse:
+        """Asynchronously bulk-import records into an entity from a CSV file.
+
+        Provide exactly one of ``file`` (raw bytes) or ``file_path`` (path on
+        disk).
+
+        Args:
+            entity_id (str): The unique identifier of the entity.
+            file (Optional[FileContent]): Raw bytes of a CSV file.
+            file_path (Optional[str]): Path to a local CSV file.
+
+        Returns:
+            EntityImportRecordsResponse: Reports the total, inserted, and
+                ``error_file_link`` for failed rows.
+
+        Examples:
+            Import from a path on disk::
+
+                result = await entities_service.import_records_async(
+                    "Customers", file_path="./customers.csv"
+                )
+                print(
+                    f"Inserted {result.inserted_records} of "
+                    f"{result.total_records} rows"
+                )
+        """
+        return await self._data.import_records_async(
+            entity_id, file=file, file_path=file_path
+        )
+
+    # ------------------------------------------------------------------
+    # Public helper retained for backward compatibility — tests call this
+    # ------------------------------------------------------------------
+
+    def validate_entity_batch(
+        self,
+        batch_response: Response,
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Parse a batch response, optionally validating success records against ``schema``.
+
+        Failure records are returned as :class:`FailureRecord` instances and
+        are not validated against the user schema.
+        """
+        return self._data.validate_entity_batch(batch_response, schema=schema)
+
+    # ------------------------------------------------------------------
+    # Cross-cutting — entity-set resolution for agent overrides
+    # ------------------------------------------------------------------
+
+    @traced(name="resolve_entity_set", run_type="uipath")
+    def resolve_entity_set(
+        self,
+        items: List[DataFabricEntityItem],
+    ) -> EntitySetResolution:
+        """Resolve an agent entity set, applying resource overwrites."""
+        plan = create_resolution_plan(
+            items,
+            _resource_overwrites.get() or {},
+            lambda folder_path: (
+                self._folders_service.retrieve_key(folder_path=folder_path)
+                if self._folders_service is not None
+                else None
+            ),
+        )
+        entities = fetch_resolved_entities(
+            plan,
+            self.retrieve,
+            self.retrieve_by_name,
+            logger,
+        )
+        resolution_service: EntitiesService = build_resolution_service(  # type: ignore[assignment]
+            config=self._config,
+            execution_context=self._execution_context,
+            folders_service=self._folders_service,
+            plan=plan,
+            service_factory=EntitiesService,
+        )
+        return EntitySetResolution(
+            entities=entities,
+            entities_service=resolution_service,
+        )
+
+    @traced(name="resolve_entity_set", run_type="uipath")
+    async def resolve_entity_set_async(
+        self,
+        items: List[DataFabricEntityItem],
+    ) -> EntitySetResolution:
+        """Resolve an agent entity set, applying resource overwrites."""
+
+        async def _resolve_folder_path(folder_path: str) -> Optional[str]:
+            if self._folders_service is None:
+                return None
+            return await self._folders_service.retrieve_key_async(
+                folder_path=folder_path
+            )
+
+        plan = await create_resolution_plan_async(
+            items,
+            _resource_overwrites.get() or {},
+            _resolve_folder_path,
+        )
+        entities = await fetch_resolved_entities_async(
+            plan,
+            self.retrieve_async,
+            self.retrieve_by_name_async,
+            logger,
+        )
+        resolution_service: EntitiesService = build_resolution_service(  # type: ignore[assignment]
+            config=self._config,
+            execution_context=self._execution_context,
+            folders_service=self._folders_service,
+            plan=plan,
+            service_factory=EntitiesService,
+        )
+        return EntitySetResolution(
+            entities=entities,
+            entities_service=resolution_service,
+        )
+
+
+# Resolve the forward reference to EntitiesService in EntitySetResolution.
+# The model uses TYPE_CHECKING to avoid circular imports in entities.py,
+# so we must rebuild it here where EntitiesService is fully defined.
+EntitySetResolution.model_rebuild()
diff --git a/packages/uipath-platform/src/uipath/platform/entities/_entity_data_service.py b/packages/uipath-platform/src/uipath/platform/entities/_entity_data_service.py
new file mode 100644
index 000000000..60cfb99b4
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/_entity_data_service.py
@@ -0,0 +1,1403 @@
+"""Data-side operations for the Data Fabric entities surface.
+
+Handles record CRUD (single and batch), structured queries, attachments,
+choice-set value lookup, bulk import, and federated SQL queries. Schema
+definitions are managed by :class:`EntitySchemaService` and exposed alongside
+data operations through :class:`EntitiesService`.
+"""
+
+import json as json_module
+import logging
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type
+
+import sqlparse
+from httpx import HTTPStatusError, Response
+from pydantic import BaseModel
+from sqlparse.sql import Function, Identifier, IdentifierList, Parenthesis, Where
+from sqlparse.tokens import DML, Keyword, Whitespace, Wildcard
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from ..errors._enriched_exception import EnrichedException
+from ..orchestrator._folder_service import FolderService
+from ._entity_resolution import RoutingStrategy, create_routing_strategy
+from .entities import (
+    AggregateRow,
+    ChoiceSetValue,
+    EntityAggregate,
+    EntityBinning,
+    EntityImportRecordsResponse,
+    EntityJoin,
+    EntityQueryFilterGroup,
+    EntityQuerySortOption,
+    EntityRecord,
+    EntityRecordsBatchResponse,
+    EntityRecordsListResponse,
+    QueryRoutingOverrideContext,
+    RetrieveEntityRecordsResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+FileContent = bytes | bytearray | memoryview
+"""Acceptable raw bytes types for attachment and CSV uploads."""
+
+_FORBIDDEN_DML = {"INSERT", "UPDATE", "DELETE", "MERGE", "REPLACE"}
+_FORBIDDEN_DDL = {"DROP", "ALTER", "CREATE", "TRUNCATE"}
+_DISALLOWED_KEYWORDS = [
+    "WITH",
+    "UNION",
+    "INTERSECT",
+    "EXCEPT",
+    "OVER",
+    "ROLLUP",
+    "CUBE",
+    "GROUPING",
+    "PARTITION",
+]
+_AGGREGATE_FUNCTIONS = ("COUNT", "SUM", "AVG", "MIN", "MAX")
+
+
+class EntityDataService(BaseService):
+    """HTTP service for entity-record and attachment operations.
+
+    Backend target: ``datafabric_/api/EntityService/...`` plus
+    ``datafabric_/api/Attachment/...`` for file attachments, and
+    ``datafabric_/api/v1/query/execute`` for federated SQL queries.
+
+    !!! warning "Preview Feature"
+        This service is currently experimental. Behavior and parameters are
+        subject to change in future versions.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: Optional[FolderService] = None,
+        routing_strategy: Optional[RoutingStrategy] = None,
+        folders_map: Optional[Dict[str, str]] = None,
+        entity_name_overrides: Optional[Dict[str, str]] = None,
+        routing_context: Optional[QueryRoutingOverrideContext] = None,
+    ) -> None:
+        """Initialise the data service.
+
+        Either pass a pre-built ``routing_strategy`` (the facade does this so
+        both services share one) or supply the inputs and let this service
+        construct its own.
+        """
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+        self._routing_strategy: RoutingStrategy = (
+            routing_strategy
+            if routing_strategy is not None
+            else create_routing_strategy(
+                folders_map=folders_map,
+                effective_entity_names=entity_name_overrides,
+                routing_context=routing_context,
+                folders_service=folders_service,
+            )
+        )
+
+    # ------------------------------------------------------------------
+    # Choice-set value lookup
+    # ------------------------------------------------------------------
+
+    def get_choiceset_values(
+        self,
+        choiceset_id: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[ChoiceSetValue]:
+        """Internal implementation; see :meth:`EntitiesService.get_choiceset_values`."""
+        spec = self._get_choiceset_values_spec(choiceset_id, start=start, limit=limit)
+        response = self.request(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return self._parse_choiceset_values(response)
+
+    async def get_choiceset_values_async(
+        self,
+        choiceset_id: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[ChoiceSetValue]:
+        """Async variant of :meth:`get_choiceset_values`."""
+        spec = self._get_choiceset_values_spec(choiceset_id, start=start, limit=limit)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return self._parse_choiceset_values(response)
+
+    # ------------------------------------------------------------------
+    # List records (multi-record read with OData filters)
+    # ------------------------------------------------------------------
+
+    def list_records(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+        expansion_level: Optional[int] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        select: Optional[List[str]] = None,
+        expand: Optional[List[str]] = None,
+    ) -> EntityRecordsListResponse:
+        """Internal implementation; see :meth:`EntitiesService.list_records`."""
+        spec = self._list_records_spec(
+            entity_key,
+            start=start,
+            limit=limit,
+            expansion_level=expansion_level,
+            filter=filter,
+            orderby=orderby,
+            select=select,
+            expand=expand,
+        )
+        response = self.request(spec.method, spec.endpoint, params=spec.params)
+        return self._build_records_list_response(response, schema, start, limit)
+
+    async def list_records_async(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+        expansion_level: Optional[int] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        select: Optional[List[str]] = None,
+        expand: Optional[List[str]] = None,
+    ) -> EntityRecordsListResponse:
+        """Async variant of :meth:`list_records`."""
+        spec = self._list_records_spec(
+            entity_key,
+            start=start,
+            limit=limit,
+            expansion_level=expansion_level,
+            filter=filter,
+            orderby=orderby,
+            select=select,
+            expand=expand,
+        )
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params
+        )
+        return self._build_records_list_response(response, schema, start, limit)
+
+    # ------------------------------------------------------------------
+    # Single-record operations (fire trigger events; batch versions don't)
+    # ------------------------------------------------------------------
+
+    def insert_record(
+        self,
+        entity_key: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Internal implementation; see :meth:`EntitiesService.insert_record`."""
+        spec = self._insert_record_spec(entity_key, data, expansion_level)
+        response = self.request(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return EntityRecord.model_validate(response.json())
+
+    async def insert_record_async(
+        self,
+        entity_key: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Async variant of :meth:`insert_record`."""
+        spec = self._insert_record_spec(entity_key, data, expansion_level)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return EntityRecord.model_validate(response.json())
+
+    def get_record(
+        self,
+        entity_key: str,
+        record_id: str,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Fetch a single record by its id."""
+        spec = self._get_record_spec(entity_key, record_id, expansion_level)
+        response = self.request(spec.method, spec.endpoint, params=spec.params)
+        return EntityRecord.model_validate(response.json())
+
+    async def get_record_async(
+        self,
+        entity_key: str,
+        record_id: str,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Async variant of :meth:`get_record`."""
+        spec = self._get_record_spec(entity_key, record_id, expansion_level)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params
+        )
+        return EntityRecord.model_validate(response.json())
+
+    def update_record(
+        self,
+        entity_key: str,
+        record_id: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Internal implementation; see :meth:`EntitiesService.update_record`."""
+        spec = self._update_record_spec(entity_key, record_id, data, expansion_level)
+        response = self.request(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return EntityRecord.model_validate(response.json())
+
+    async def update_record_async(
+        self,
+        entity_key: str,
+        record_id: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> EntityRecord:
+        """Async variant of :meth:`update_record`."""
+        spec = self._update_record_spec(entity_key, record_id, data, expansion_level)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return EntityRecord.model_validate(response.json())
+
+    def delete_record(self, entity_key: str, record_id: str) -> None:
+        """Delete a single record by id."""
+        spec = self._delete_record_spec(entity_key, record_id)
+        self.request(spec.method, spec.endpoint)
+
+    async def delete_record_async(self, entity_key: str, record_id: str) -> None:
+        """Async variant of :meth:`delete_record`."""
+        spec = self._delete_record_spec(entity_key, record_id)
+        await self.request_async(spec.method, spec.endpoint)
+
+    # ------------------------------------------------------------------
+    # Batch record operations
+    # ------------------------------------------------------------------
+
+    def insert_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Internal implementation; see :meth:`EntitiesService.insert_records`."""
+        spec = self._insert_batch_spec(
+            entity_key,
+            records,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+        response = self._request_or_extract_batch(
+            sync_call=lambda: self.request(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+        )
+        if isinstance(response, EntityRecordsBatchResponse):
+            return response
+        return self.validate_entity_batch(response, schema)
+
+    async def insert_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Async variant of :meth:`insert_records`."""
+        spec = self._insert_batch_spec(
+            entity_key,
+            records,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+        async def _send_batch() -> Response:
+            return await self.request_async(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+
+        result = await self._request_or_extract_batch_async(_send_batch)
+        if isinstance(result, EntityRecordsBatchResponse):
+            return result
+        return self.validate_entity_batch(result, schema)
+
+    def update_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Internal implementation; see :meth:`EntitiesService.update_records`."""
+        normalized = [self._record_to_dict(record) for record in records]
+        if schema is not None:
+            for record in normalized:
+                EntityRecord.from_data(data=record, model=schema)
+
+        spec = self._update_batch_spec(
+            entity_key,
+            normalized,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+        response = self._request_or_extract_batch(
+            sync_call=lambda: self.request(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+        )
+        if isinstance(response, EntityRecordsBatchResponse):
+            return response
+        return self.validate_entity_batch(response, schema)
+
+    async def update_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Async variant of :meth:`update_records`."""
+        normalized = [self._record_to_dict(record) for record in records]
+        if schema is not None:
+            for record in normalized:
+                EntityRecord.from_data(data=record, model=schema)
+
+        spec = self._update_batch_spec(
+            entity_key,
+            normalized,
+            expansion_level=expansion_level,
+            fail_on_first=fail_on_first,
+        )
+
+        async def _send_batch() -> Response:
+            return await self.request_async(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+
+        result = await self._request_or_extract_batch_async(_send_batch)
+        if isinstance(result, EntityRecordsBatchResponse):
+            return result
+        return self.validate_entity_batch(result, schema)
+
+    def delete_records(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Delete multiple records by id in a single batch."""
+        spec = self._delete_batch_spec(
+            entity_key, record_ids, fail_on_first=fail_on_first
+        )
+        result = self._request_or_extract_batch(
+            sync_call=lambda: self.request(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+        )
+        if isinstance(result, EntityRecordsBatchResponse):
+            return result
+        return EntityRecordsBatchResponse.model_validate(result.json())
+
+    async def delete_records_async(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+        fail_on_first: Optional[bool] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Async variant of :meth:`delete_records`."""
+        spec = self._delete_batch_spec(
+            entity_key, record_ids, fail_on_first=fail_on_first
+        )
+
+        async def _send_batch() -> Response:
+            return await self.request_async(
+                spec.method, spec.endpoint, params=spec.params, json=spec.json
+            )
+
+        result = await self._request_or_extract_batch_async(_send_batch)
+        if isinstance(result, EntityRecordsBatchResponse):
+            return result
+        return EntityRecordsBatchResponse.model_validate(result.json())
+
+    # ------------------------------------------------------------------
+    # Structured query (POST /entity/{id}/query)
+    # ------------------------------------------------------------------
+
+    def retrieve_records(
+        self,
+        entity_key: str,
+        filter_group: Optional[EntityQueryFilterGroup] = None,
+        sort_options: Optional[List[EntityQuerySortOption]] = None,
+        selected_fields: Optional[List[str]] = None,
+        expansions: Optional[List[Any]] = None,
+        expansion_level: Optional[int] = None,
+        aggregates: Optional[List[EntityAggregate]] = None,
+        group_by: Optional[List[str]] = None,
+        joins: Optional[List[EntityJoin]] = None,
+        binnings: Optional[List[EntityBinning]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RetrieveEntityRecordsResponse:
+        """Internal implementation; see :meth:`EntitiesService.retrieve_records`."""
+        spec = self._retrieve_records_spec(
+            entity_key,
+            filter_group=filter_group,
+            sort_options=sort_options,
+            selected_fields=selected_fields,
+            expansions=expansions,
+            expansion_level=expansion_level,
+            aggregates=aggregates,
+            group_by=group_by,
+            joins=joins,
+            binnings=binnings,
+            start=start,
+            limit=limit,
+        )
+        response = self.request(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return self._parse_query_response(response, start=start, limit=limit)
+
+    async def retrieve_records_async(
+        self,
+        entity_key: str,
+        filter_group: Optional[EntityQueryFilterGroup] = None,
+        sort_options: Optional[List[EntityQuerySortOption]] = None,
+        selected_fields: Optional[List[str]] = None,
+        expansions: Optional[List[Any]] = None,
+        expansion_level: Optional[int] = None,
+        aggregates: Optional[List[EntityAggregate]] = None,
+        group_by: Optional[List[str]] = None,
+        joins: Optional[List[EntityJoin]] = None,
+        binnings: Optional[List[EntityBinning]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RetrieveEntityRecordsResponse:
+        """Async variant of :meth:`retrieve_records`."""
+        spec = self._retrieve_records_spec(
+            entity_key,
+            filter_group=filter_group,
+            sort_options=sort_options,
+            selected_fields=selected_fields,
+            expansions=expansions,
+            expansion_level=expansion_level,
+            aggregates=aggregates,
+            group_by=group_by,
+            joins=joins,
+            binnings=binnings,
+            start=start,
+            limit=limit,
+        )
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params, json=spec.json
+        )
+        return self._parse_query_response(response, start=start, limit=limit)
+
+    # ------------------------------------------------------------------
+    # Federated SQL query
+    # ------------------------------------------------------------------
+
+    def query_entity_records(
+        self,
+        sql_query: str,
+    ) -> List[Dict[str, Any]]:
+        """Internal implementation; see :meth:`EntitiesService.query_entity_records`."""
+        return self._query_entities_for_records(sql_query)
+
+    async def query_entity_records_async(
+        self,
+        sql_query: str,
+    ) -> List[Dict[str, Any]]:
+        """Async variant of :meth:`query_entity_records`."""
+        return await self._query_entities_for_records_async(sql_query)
+
+    # ------------------------------------------------------------------
+    # Attachments
+    # ------------------------------------------------------------------
+
+    def upload_attachment(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Internal implementation; see :meth:`EntitiesService.upload_attachment`."""
+        spec = self._attachment_endpoint(
+            entity_id, record_id, field_name, expansion_level
+        )
+        with self._open_file(file, file_path) as handle:
+            response = self.request(
+                "POST",
+                spec.endpoint,
+                params=spec.params,
+                files={"file": handle},
+            )
+        return response.json() if response.content else {}
+
+    async def upload_attachment_async(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Async variant of :meth:`upload_attachment`."""
+        spec = self._attachment_endpoint(
+            entity_id, record_id, field_name, expansion_level
+        )
+        with self._open_file(file, file_path) as handle:
+            response = await self.request_async(
+                "POST",
+                spec.endpoint,
+                params=spec.params,
+                files={"file": handle},
+            )
+        return response.json() if response.content else {}
+
+    def download_attachment(
+        self, entity_id: str, record_id: str, field_name: str
+    ) -> bytes:
+        """Internal implementation; see :meth:`EntitiesService.download_attachment`."""
+        spec = self._attachment_endpoint(entity_id, record_id, field_name)
+        response = self.request("GET", spec.endpoint)
+        return response.content
+
+    async def download_attachment_async(
+        self, entity_id: str, record_id: str, field_name: str
+    ) -> bytes:
+        """Async variant of :meth:`download_attachment`."""
+        spec = self._attachment_endpoint(entity_id, record_id, field_name)
+        response = await self.request_async("GET", spec.endpoint)
+        return response.content
+
+    def delete_attachment(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Internal implementation; see :meth:`EntitiesService.delete_attachment`."""
+        spec = self._attachment_endpoint(
+            entity_id, record_id, field_name, expansion_level
+        )
+        response = self.request("DELETE", spec.endpoint, params=spec.params)
+        return response.json() if response.content else {}
+
+    async def delete_attachment_async(
+        self,
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        expansion_level: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Async variant of :meth:`delete_attachment`."""
+        spec = self._attachment_endpoint(
+            entity_id, record_id, field_name, expansion_level
+        )
+        response = await self.request_async("DELETE", spec.endpoint, params=spec.params)
+        return response.json() if response.content else {}
+
+    # ------------------------------------------------------------------
+    # Bulk import
+    # ------------------------------------------------------------------
+
+    def import_records(
+        self,
+        entity_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> EntityImportRecordsResponse:
+        """Internal implementation; see :meth:`EntitiesService.import_records`."""
+        spec = self._import_records_spec(entity_id)
+        with self._open_file(file, file_path) as handle:
+            response = self.request(spec.method, spec.endpoint, files={"file": handle})
+        return EntityImportRecordsResponse.model_validate(response.json() or {})
+
+    async def import_records_async(
+        self,
+        entity_id: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> EntityImportRecordsResponse:
+        """Async variant of :meth:`import_records`."""
+        spec = self._import_records_spec(entity_id)
+        with self._open_file(file, file_path) as handle:
+            response = await self.request_async(
+                spec.method, spec.endpoint, files={"file": handle}
+            )
+        return EntityImportRecordsResponse.model_validate(response.json() or {})
+
+    # ------------------------------------------------------------------
+    # Public helper for batch response validation
+    # ------------------------------------------------------------------
+
+    def validate_entity_batch(
+        self,
+        batch_response: Response,
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Internal implementation; see :meth:`EntitiesService.validate_entity_batch`."""
+        parsed = EntityRecordsBatchResponse.model_validate(batch_response.json())
+
+        validated_successful_records = []
+        for successful_record in parsed.success_records:
+            data = successful_record.model_dump(by_alias=True)
+            if data.get("Id") is not None:
+                validated_successful_records.append(
+                    EntityRecord.from_data(data=data, model=schema)
+                )
+
+        return EntityRecordsBatchResponse(
+            success_records=validated_successful_records,
+            failure_records=parsed.failure_records,
+        )
+
+    # ------------------------------------------------------------------
+    # Internal helpers — request specs
+    # ------------------------------------------------------------------
+
+    def _query_entities_for_records(self, sql_query: str) -> List[Dict[str, Any]]:
+        """Synchronously run a validated SQL query through the federated query engine."""
+        self._validate_sql_query(sql_query)
+        routing_context = self._routing_strategy.resolve()
+        spec = self._query_entity_records_spec(sql_query, routing_context)
+        response = self.request(spec.method, spec.endpoint, json=spec.json)
+        return response.json().get("results", [])
+
+    async def _query_entities_for_records_async(
+        self, sql_query: str
+    ) -> List[Dict[str, Any]]:
+        """Asynchronously run a validated SQL query through the federated query engine."""
+        self._validate_sql_query(sql_query)
+        routing_context = await self._routing_strategy.resolve_async()
+        spec = self._query_entity_records_spec(sql_query, routing_context)
+        response = await self.request_async(spec.method, spec.endpoint, json=spec.json)
+        return response.json().get("results", [])
+
+    @staticmethod
+    def _list_records_spec(
+        entity_key: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+        expansion_level: Optional[int] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        select: Optional[List[str]] = None,
+        expand: Optional[List[str]] = None,
+    ) -> RequestSpec:
+        """Build the GET spec for the multi-record read endpoint."""
+        params: Dict[str, Any] = {}
+        if start is not None:
+            params["start"] = start
+        if limit is not None:
+            params["limit"] = limit
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        if filter is not None:
+            params["$filter"] = filter
+        if orderby is not None:
+            params["$orderby"] = orderby
+        if select:
+            params["$select"] = ",".join(select)
+        if expand:
+            params["$expand"] = ",".join(expand)
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/read"
+            ),
+            params=params,
+        )
+
+    @staticmethod
+    def _insert_record_spec(
+        entity_key: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for inserting a single record."""
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/insert"
+            ),
+            params=params,
+            json=EntityDataService._record_to_dict(data),
+        )
+
+    @staticmethod
+    def _get_record_spec(
+        entity_key: str,
+        record_id: str,
+        expansion_level: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the GET spec for fetching a single record by id."""
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/read/{record_id}"
+            ),
+            params=params,
+        )
+
+    @staticmethod
+    def _update_record_spec(
+        entity_key: str,
+        record_id: str,
+        data: Any,
+        expansion_level: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for updating a single record by id."""
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/update/{record_id}"
+            ),
+            params=params,
+            json=EntityDataService._record_to_dict(data),
+        )
+
+    @staticmethod
+    def _delete_record_spec(entity_key: str, record_id: str) -> RequestSpec:
+        """Build the DELETE spec for removing a single record by id."""
+        return RequestSpec(
+            method="DELETE",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/delete/{record_id}"
+            ),
+        )
+
+    @staticmethod
+    def _insert_batch_spec(
+        entity_key: str,
+        records: List[Any],
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for the batch-insert endpoint."""
+        params = EntityDataService._batch_params(
+            expansion_level=expansion_level, fail_on_first=fail_on_first
+        )
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/insert-batch"
+            ),
+            params=params,
+            json=[EntityDataService._record_to_dict(record) for record in records],
+        )
+
+    @staticmethod
+    def _update_batch_spec(
+        entity_key: str,
+        records: List[Dict[str, Any]],
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for the batch-update endpoint."""
+        params = EntityDataService._batch_params(
+            expansion_level=expansion_level, fail_on_first=fail_on_first
+        )
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/update-batch"
+            ),
+            params=params,
+            json=records,
+        )
+
+    @staticmethod
+    def _delete_batch_spec(
+        entity_key: str,
+        record_ids: List[str],
+        fail_on_first: Optional[bool] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for the batch-delete endpoint."""
+        params = EntityDataService._batch_params(fail_on_first=fail_on_first)
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/delete-batch"
+            ),
+            params=params,
+            json=record_ids,
+        )
+
+    @staticmethod
+    def _batch_params(
+        expansion_level: Optional[int] = None,
+        fail_on_first: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Build the optional URL params common to all batch endpoints."""
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        if fail_on_first is not None:
+            params["failOnFirst"] = "true" if fail_on_first else "false"
+        return params
+
+    @staticmethod
+    def _retrieve_records_spec(
+        entity_key: str,
+        filter_group: Optional[EntityQueryFilterGroup] = None,
+        sort_options: Optional[List[EntityQuerySortOption]] = None,
+        selected_fields: Optional[List[str]] = None,
+        expansions: Optional[List[Any]] = None,
+        expansion_level: Optional[int] = None,
+        aggregates: Optional[List[Any]] = None,
+        group_by: Optional[List[str]] = None,
+        joins: Optional[List[EntityJoin]] = None,
+        binnings: Optional[List[EntityBinning]] = None,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the request spec for the structured-query endpoint.
+
+        Filters, sorting, projection, expansions, aggregates, group-by, joins,
+        binnings, ``start``, and ``limit`` are placed in the JSON body;
+        ``expansionLevel`` is a URL query parameter. The V2 endpoint is used
+        only when ``binnings`` are supplied.
+        """
+        body: Dict[str, Any] = {}
+        if filter_group is not None:
+            body["filterGroup"] = filter_group.model_dump(
+                by_alias=True, exclude_none=True
+            )
+        if sort_options:
+            body["sortOptions"] = [
+                opt.model_dump(by_alias=True, exclude_none=True) for opt in sort_options
+            ]
+        if selected_fields:
+            body["selectedFields"] = list(selected_fields)
+        if expansions:
+            body["expansions"] = [
+                e.model_dump(by_alias=True, exclude_none=True)
+                if isinstance(e, BaseModel)
+                else e
+                for e in expansions
+            ]
+        if aggregates:
+            body["aggregates"] = [
+                a.model_dump(by_alias=True, exclude_none=True)
+                if isinstance(a, BaseModel)
+                else a
+                for a in aggregates
+            ]
+        if group_by:
+            body["groupBy"] = list(group_by)
+        if joins:
+            body["joins"] = [
+                j.model_dump(by_alias=True, exclude_none=True) for j in joins
+            ]
+        if binnings:
+            body["binnings"] = [
+                b.model_dump(by_alias=True, exclude_none=True) for b in binnings
+            ]
+        if start is not None:
+            body["start"] = start
+        if limit is not None:
+            body["limit"] = limit
+
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+
+        if binnings:
+            endpoint = Endpoint(
+                f"datafabric_/api/v2/EntityService/entity/{entity_key}/query"
+            )
+        else:
+            endpoint = Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/query"
+            )
+
+        return RequestSpec(
+            method="POST",
+            endpoint=endpoint,
+            params=params,
+            json=body,
+        )
+
+    @staticmethod
+    def _query_entity_records_spec(
+        sql_query: str,
+        routing_context: Optional[QueryRoutingOverrideContext] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for the federated SQL query endpoint."""
+        body: Dict[str, Any] = {"query": sql_query}
+        if routing_context:
+            body["routingContext"] = routing_context.model_dump(
+                by_alias=True, exclude_none=True
+            )
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("datafabric_/api/v1/query/execute"),
+            json=body,
+        )
+
+    @staticmethod
+    def _get_choiceset_values_spec(
+        choiceset_id: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for the choice-set values endpoint."""
+        params: Dict[str, Any] = {}
+        if start is not None:
+            params["start"] = start
+        if limit is not None:
+            params["limit"] = limit
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{choiceset_id}/query_expansion"
+            ),
+            params=params,
+            json={},
+        )
+
+    @staticmethod
+    def _attachment_endpoint(
+        entity_id: str,
+        record_id: str,
+        field_name: str,
+        expansion_level: Optional[int] = None,
+    ) -> RequestSpec:
+        """Return the attachment endpoint plus any ``expansionLevel`` query param.
+
+        The HTTP verb is supplied by the caller; only the URL and query
+        parameters depend on these arguments.
+        """
+        params: Dict[str, Any] = {}
+        if expansion_level is not None:
+            params["expansionLevel"] = expansion_level
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/Attachment/entity/{entity_id}/{record_id}/{field_name}"
+            ),
+            params=params,
+        )
+
+    @staticmethod
+    def _import_records_spec(entity_id: str) -> RequestSpec:
+        """Build the POST spec for the bulk-upload (CSV import) endpoint."""
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_id}/bulk-upload"
+            ),
+        )
+
+    @staticmethod
+    def _open_file(file: Optional[FileContent], file_path: Optional[str]) -> Any:
+        """Yield a file-like object from raw bytes or a path on disk.
+
+        Exactly one of ``file`` and ``file_path`` must be supplied.
+        """
+        if (file is None) == (file_path is None):
+            raise ValueError(
+                "Provide exactly one of `file` (bytes) or `file_path` (str path on disk)."
+            )
+        if file_path is not None:
+            return open(Path(file_path), "rb")
+        return nullcontext(file)
+
+    # ------------------------------------------------------------------
+    # Internal helpers — response parsing and record normalisation
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _record_to_dict(record: Any) -> Dict[str, Any]:
+        """Normalize an input record to a plain dict.
+
+        Accepts dicts, Pydantic ``BaseModel`` (including :class:`EntityRecord`),
+        or any object exposing ``__dict__``. Explicit ``None`` values are
+        preserved so callers can clear fields by setting them to ``None`` on a
+        model instance — only unset fields (whose Pydantic default applies) are
+        dropped via ``exclude_unset=True``.
+        """
+        if isinstance(record, dict):
+            return dict(record)
+        if isinstance(record, BaseModel):
+            return record.model_dump(by_alias=True, exclude_unset=True)
+        if hasattr(record, "__dict__"):
+            return {k: v for k, v in record.__dict__.items() if not k.startswith("_")}
+        raise TypeError(
+            f"Cannot convert record of type {type(record).__name__} to dict — "
+            "pass a dict, an EntityRecord, a Pydantic BaseModel, or an object with __dict__."
+        )
+
+    @staticmethod
+    def _build_records_list_response(
+        response: Response,
+        schema: Optional[Type[Any]],
+        start: Optional[int],
+        limit: Optional[int],
+    ) -> EntityRecordsListResponse:
+        """Build an :class:`EntityRecordsListResponse` from a list-records body."""
+        body = response.json() or {}
+        records_data = body.get("value", [])
+        total_count = int(
+            body.get("totalRecordCount", body.get("totalCount", len(records_data))) or 0
+        )
+        records = [
+            EntityRecord.from_data(data=record, model=schema) for record in records_data
+        ]
+
+        next_cursor = body.get("nextCursor")
+        if limit is not None and limit > 0:
+            consumed = (start or 0) + len(records)
+            has_next_page = consumed < total_count
+        else:
+            has_next_page = bool(body.get("hasNextPage", False))
+
+        return EntityRecordsListResponse(
+            items=records,
+            total_count=total_count,
+            has_next_page=has_next_page,
+            next_cursor=next_cursor,
+        )
+
+    @staticmethod
+    def _parse_query_response(
+        response: Response,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RetrieveEntityRecordsResponse:
+        """Parse a query response into :class:`RetrieveEntityRecordsResponse`.
+
+        Rows that include an ``Id`` field are parsed as :class:`EntityRecord`;
+        rows that don't (aggregate / group-by / binning results) are parsed as
+        :class:`AggregateRow`. ``has_next_page`` is derived from
+        ``start + len(items) < total_count`` whenever ``limit`` is supplied;
+        ``next_cursor`` is populated only when the backend returns one,
+        otherwise the caller paginates by passing the next ``start``.
+        """
+        body = response.json() or {}
+        items_raw = body.get("value", []) or []
+        items: List[EntityRecord | AggregateRow] = []
+        for raw in items_raw:
+            if isinstance(raw, dict) and isinstance(raw.get("Id"), str):
+                items.append(EntityRecord.from_data(data=raw))
+            else:
+                items.append(AggregateRow.model_validate(raw))
+
+        total_count = int(body.get("totalRecordCount", body.get("totalCount", 0)) or 0)
+
+        next_cursor: Optional[str] = body.get("nextCursor")
+        has_next_page = bool(body.get("hasNextPage", False))
+        if next_cursor is None and limit is not None and limit > 0:
+            consumed = (start or 0) + len(items)
+            has_next_page = consumed < total_count
+
+        return RetrieveEntityRecordsResponse(
+            items=items,
+            total_count=total_count,
+            has_next_page=has_next_page,
+            next_cursor=next_cursor,
+        )
+
+    @staticmethod
+    def _parse_choiceset_values(response: Response) -> List[ChoiceSetValue]:
+        """Decode and return the choice-set values from a query-expansion response."""
+        data = response.json()
+        raw_values = data.get("jsonValue", "[]")
+        items = (
+            json_module.loads(raw_values) if isinstance(raw_values, str) else raw_values
+        )
+        return [ChoiceSetValue.model_validate(item) for item in items]
+
+    # ------------------------------------------------------------------
+    # Internal helpers — batch error recovery
+    # ------------------------------------------------------------------
+
+    def _request_or_extract_batch(
+        self,
+        sync_call: Any,
+    ) -> Response | EntityRecordsBatchResponse:
+        """Run a batch request and recover per-record failures from a 400 body.
+
+        On HTTP 400 with a body that lists both ``successRecords`` and
+        ``failureRecords``, returns the parsed batch response instead of
+        raising. All other errors propagate.
+        """
+        try:
+            return sync_call()
+        except EnrichedException as exc:
+            extracted = self._extract_batch_response_from_error(exc)
+            if extracted is not None:
+                return extracted
+            raise
+
+    async def _request_or_extract_batch_async(
+        self,
+        async_call: Any,
+    ) -> Response | EntityRecordsBatchResponse:
+        """Async variant of :meth:`_request_or_extract_batch`."""
+        try:
+            return await async_call()
+        except EnrichedException as exc:
+            extracted = self._extract_batch_response_from_error(exc)
+            if extracted is not None:
+                return extracted
+            raise
+
+    @staticmethod
+    def _extract_batch_response_from_error(
+        exc: EnrichedException,
+    ) -> Optional[EntityRecordsBatchResponse]:
+        """Return a parsed batch response when the error body matches the per-record-failure shape.
+
+        Recovery is intentionally narrow: only HTTP 400 with a JSON object
+        containing list-typed ``successRecords`` and ``failureRecords`` keys.
+        Returns ``None`` for any other status, body shape, or parse failure
+        so that the original error propagates.
+        """
+        cause = exc.__cause__
+        if not isinstance(cause, HTTPStatusError):
+            return None
+        if cause.response.status_code != 400:
+            return None
+        try:
+            data = cause.response.json()
+        except Exception:
+            return None
+        if not isinstance(data, dict):
+            return None
+        if not (
+            isinstance(data.get("successRecords"), list)
+            and isinstance(data.get("failureRecords"), list)
+        ):
+            return None
+        try:
+            return EntityRecordsBatchResponse.model_validate(data)
+        except Exception:
+            return None
+
+    # ------------------------------------------------------------------
+    # Internal helpers — SQL validation (federated query path)
+    # ------------------------------------------------------------------
+
+    def _validate_sql_query(self, sql_query: str) -> None:
+        """Validate a SQL string for the federated query endpoint client-side."""
+        query = sql_query.strip().rstrip(";").strip()
+        if not query:
+            raise ValueError("SQL query cannot be empty.")
+
+        statements = sqlparse.parse(query)
+        if len(statements) != 1 or not statements[0].tokens:
+            raise ValueError("Only a single SELECT statement is allowed.")
+
+        stmt = statements[0]
+        stmt_type = stmt.get_type()
+
+        if stmt_type != "SELECT":
+            raise ValueError("Only SELECT statements are allowed.")
+
+        keywords = set()
+        for token in stmt.flatten():
+            if token.ttype in Keyword:
+                keywords.add(token.normalized)
+
+        for kw in _FORBIDDEN_DML:
+            if kw in keywords:
+                raise ValueError(f"SQL keyword '{kw}' is not allowed.")
+
+        for kw in _FORBIDDEN_DDL:
+            if kw in keywords:
+                raise ValueError(f"SQL keyword '{kw}' is not allowed.")
+
+        for kw in _DISALLOWED_KEYWORDS:
+            if kw in keywords:
+                raise ValueError(
+                    f"SQL construct '{kw}' is not allowed in entity queries."
+                )
+
+        if self._has_subquery(stmt):
+            raise ValueError("Subqueries are not allowed.")
+
+        has_where = any(isinstance(t, Where) for t in stmt.tokens)
+        has_limit = "LIMIT" in keywords
+        has_from = "FROM" in keywords
+
+        if not has_from:
+            raise ValueError("Queries must include a FROM clause.")
+
+        projection = self._projection_tokens(stmt)
+
+        if self._projection_has_count_star(projection):
+            raise ValueError(
+                "COUNT(*) is not supported. Use COUNT(column_name) instead."
+            )
+
+        has_aggregate = self._projection_has_aggregate(projection)
+
+        if not has_where and not has_limit and not has_aggregate:
+            raise ValueError("Queries without WHERE must include a LIMIT clause.")
+
+        has_bare_wildcard = self._projection_has_bare_wildcard(projection)
+        if has_bare_wildcard:
+            raise ValueError("SELECT * is not allowed. Specify column names instead.")
+        if not has_where and self._projection_column_count(projection) > 4:
+            raise ValueError(
+                "Selecting more than 4 columns without filtering is not allowed."
+            )
+
+    @staticmethod
+    def _projection_has_aggregate(
+        projection: List[sqlparse.sql.Token],
+    ) -> bool:
+        """Return ``True`` when the projection contains an aggregate function call."""
+
+        def _has_agg(token: sqlparse.sql.Token) -> bool:
+            if isinstance(token, Function):
+                return token.get_name().upper() in _AGGREGATE_FUNCTIONS
+            if isinstance(token, Identifier):
+                return any(_has_agg(child) for child in token.tokens)
+            return False
+
+        for node in projection:
+            if _has_agg(node):
+                return True
+            if isinstance(node, IdentifierList):
+                if any(_has_agg(child) for child in node.tokens):
+                    return True
+        return False
+
+    @staticmethod
+    def _projection_has_count_star(
+        projection: List[sqlparse.sql.Token],
+    ) -> bool:
+        """Return ``True`` when the projection contains ``COUNT(*)``."""
+
+        def _is_count_star(func: Function) -> bool:
+            if func.get_name().upper() != "COUNT":
+                return False
+            return any(t.ttype is Wildcard for t in func.flatten())
+
+        def _has_count_star(token: sqlparse.sql.Token) -> bool:
+            if isinstance(token, Function):
+                return _is_count_star(token)
+            if isinstance(token, Identifier):
+                return any(_has_count_star(child) for child in token.tokens)
+            return False
+
+        for node in projection:
+            if _has_count_star(node):
+                return True
+            if isinstance(node, IdentifierList):
+                if any(_has_count_star(child) for child in node.tokens):
+                    return True
+        return False
+
+    @staticmethod
+    def _projection_has_bare_wildcard(
+        projection: List[sqlparse.sql.Token],
+    ) -> bool:
+        """Return ``True`` for a bare ``*`` or qualified ``table.*`` outside a function."""
+
+        def _identifier_has_wildcard(ident: Identifier) -> bool:
+            return any(t.ttype is Wildcard for t in ident.tokens)
+
+        for node in projection:
+            if node.ttype is Wildcard:
+                return True
+            if isinstance(node, Identifier) and _identifier_has_wildcard(node):
+                return True
+            if isinstance(node, IdentifierList):
+                for child in node.tokens:
+                    if child.ttype is Wildcard:
+                        return True
+                    if isinstance(child, Identifier) and _identifier_has_wildcard(
+                        child
+                    ):
+                        return True
+        return False
+
+    @staticmethod
+    def _has_subquery(stmt: sqlparse.sql.Statement) -> bool:
+        """Recursively walk the AST looking for a SELECT inside parentheses."""
+
+        def _walk(token: sqlparse.sql.Token) -> bool:
+            if isinstance(token, Parenthesis):
+                for child in token.flatten():
+                    if child.ttype is DML and child.normalized == "SELECT":
+                        return True
+            if hasattr(token, "tokens"):
+                for child in token.tokens:
+                    if _walk(child):
+                        return True
+            return False
+
+        for token in stmt.tokens:
+            if _walk(token):
+                return True
+        return False
+
+    @staticmethod
+    def _projection_tokens(
+        stmt: sqlparse.sql.Statement,
+    ) -> List[sqlparse.sql.Token]:
+        """Return the non-flattened AST nodes between the first SELECT and FROM."""
+        tokens: List[sqlparse.sql.Token] = []
+        collecting = False
+        for token in stmt.tokens:
+            if token.ttype is DML and token.normalized == "SELECT":
+                collecting = True
+                continue
+            if token.ttype is Keyword and token.normalized in ("FROM", "INTO"):
+                break
+            if token.ttype is Keyword and token.normalized == "DISTINCT":
+                continue
+            if collecting and token.ttype is not Whitespace:
+                tokens.append(token)
+        return tokens
+
+    @staticmethod
+    def _projection_column_count(
+        projection: List[sqlparse.sql.Token],
+    ) -> int:
+        """Return the number of columns referenced by the projection."""
+        for node in projection:
+            if isinstance(node, IdentifierList):
+                return len(list(node.get_identifiers()))
+            if isinstance(node, (Identifier, Function)):
+                return 1
+            if node.ttype is Wildcard:
+                return 1
+        return 0
diff --git a/packages/uipath-platform/src/uipath/platform/entities/_entity_resolution.py b/packages/uipath-platform/src/uipath/platform/entities/_entity_resolution.py
new file mode 100644
index 000000000..2477b26b9
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/_entity_resolution.py
@@ -0,0 +1,526 @@
+from __future__ import annotations
+
+import abc
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Dict, Optional
+
+from ..common._bindings import (
+    EntityResourceOverwrite,
+    ResourceOverwrite,
+    _resource_overwrites,
+)
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..orchestrator._folder_service import FolderService
+from .entities import (
+    DataFabricEntityItem,
+    Entity,
+    EntityRouting,
+    QueryRoutingOverrideContext,
+)
+
+FolderPathResolver = Callable[[str], Optional[str]]
+AsyncFolderPathResolver = Callable[[str], Awaitable[Optional[str]]]
+EntityByKeyFetcher = Callable[[str], Entity]
+AsyncEntityByKeyFetcher = Callable[[str], Awaitable[Entity]]
+EntityByNameFetcher = Callable[[str, Optional[str]], Entity]
+AsyncEntityByNameFetcher = Callable[[str, Optional[str]], Awaitable[Entity]]
+
+
+# ---------------------------------------------------------------------------
+# Routing strategy
+# ---------------------------------------------------------------------------
+
+
+class RoutingStrategy(abc.ABC):
+    """Strategy for resolving a ``QueryRoutingOverrideContext`` at query time."""
+
+    @abc.abstractmethod
+    def resolve(self) -> Optional[QueryRoutingOverrideContext]: ...
+
+    @abc.abstractmethod
+    async def resolve_async(self) -> Optional[QueryRoutingOverrideContext]: ...
+
+
+class PreResolvedRoutingStrategy(RoutingStrategy):
+    """Returns a routing context that was fully resolved at init time.
+
+    Used after ``resolve_entity_set`` where all folder paths have already
+    been converted to folder keys and the routing context is immutable.
+    """
+
+    def __init__(
+        self,
+        routing_context: QueryRoutingOverrideContext,
+    ) -> None:
+        self._routing_context = routing_context
+
+    def resolve(self) -> Optional[QueryRoutingOverrideContext]:
+        return self._routing_context
+
+    async def resolve_async(self) -> Optional[QueryRoutingOverrideContext]:
+        return self._routing_context
+
+    @property
+    def routing_context(self) -> QueryRoutingOverrideContext:
+        return self._routing_context
+
+
+class FoldersMapRoutingStrategy(RoutingStrategy):
+    """Builds a routing context from a pre-populated folders map.
+
+    Used when an ``EntitiesService`` is constructed with an explicit
+    ``folders_map`` (and optional entity-name overrides) but *without* a
+    pre-built routing context.  Folder paths in the map are resolved to
+    folder keys lazily at query time via ``FolderService``.
+    """
+
+    def __init__(
+        self,
+        folders_map: Dict[str, str],
+        effective_entity_names: Dict[str, str],
+        folders_service: Optional[FolderService],
+    ) -> None:
+        self._folders_map = folders_map
+        self._effective_entity_names = effective_entity_names
+        self._folders_service = folders_service
+
+    def resolve(self) -> Optional[QueryRoutingOverrideContext]:
+        resolved = self._resolve_folder_paths()
+        return build_resolution_routing_context(
+            {
+                name: (resolved or {}).get(path, path)
+                for name, path in self._folders_map.items()
+            },
+            self._effective_entity_names,
+        )
+
+    async def resolve_async(self) -> Optional[QueryRoutingOverrideContext]:
+        resolved = await self._resolve_folder_paths_async()
+        return build_resolution_routing_context(
+            {
+                name: (resolved or {}).get(path, path)
+                for name, path in self._folders_map.items()
+            },
+            self._effective_entity_names,
+        )
+
+    def _resolve_folder_paths(self) -> Optional[dict[str, str]]:
+        folder_paths = set(self._folders_map.values())
+        if not folder_paths:
+            return None
+
+        resolved: dict[str, str] = {}
+        for folder_path in folder_paths:
+            if self._folders_service is not None:
+                folder_key = self._folders_service.retrieve_key(folder_path=folder_path)
+                if folder_key is not None:
+                    resolved[folder_path] = folder_key
+                    continue
+            resolved[folder_path] = folder_path
+        return resolved
+
+    async def _resolve_folder_paths_async(self) -> Optional[dict[str, str]]:
+        folder_paths = set(self._folders_map.values())
+        if not folder_paths:
+            return None
+
+        resolved: dict[str, str] = {}
+        for folder_path in folder_paths:
+            if self._folders_service is not None:
+                folder_key = await self._folders_service.retrieve_key_async(
+                    folder_path=folder_path
+                )
+                if folder_key is not None:
+                    resolved[folder_path] = folder_key
+                    continue
+            resolved[folder_path] = folder_path
+        return resolved
+
+
+class ContextOverwriteRoutingStrategy(RoutingStrategy):
+    """Builds a routing context lazily from ``_resource_overwrites``.
+
+    This is the fallback for direct SDK usage where no ``folders_map`` or
+    pre-resolved routing context exists.  Entity overwrites are read from
+    the active ``ResourceOverwritesContext`` at query time.
+    """
+
+    def __init__(self, folders_service: Optional[FolderService]) -> None:
+        self._folders_service = folders_service
+
+    def resolve(self) -> Optional[QueryRoutingOverrideContext]:
+        entity_overwrites = _get_entity_overwrites_from_context()
+        if not entity_overwrites:
+            return None
+
+        folder_paths = {
+            ow.folder_path for ow in entity_overwrites.values() if ow.folder_path
+        }
+        resolved = self._resolve_paths(folder_paths)
+        return self._build(entity_overwrites, resolved)
+
+    async def resolve_async(self) -> Optional[QueryRoutingOverrideContext]:
+        entity_overwrites = _get_entity_overwrites_from_context()
+        if not entity_overwrites:
+            return None
+
+        folder_paths = {
+            ow.folder_path for ow in entity_overwrites.values() if ow.folder_path
+        }
+        resolved = await self._resolve_paths_async(folder_paths)
+        return self._build(entity_overwrites, resolved)
+
+    def _resolve_paths(self, folder_paths: set[str]) -> dict[str, str]:
+        resolved: dict[str, str] = {}
+        for path in folder_paths:
+            if self._folders_service is not None:
+                key = self._folders_service.retrieve_key(folder_path=path)
+                if key is not None:
+                    resolved[path] = key
+                    continue
+            resolved[path] = path
+        return resolved
+
+    async def _resolve_paths_async(self, folder_paths: set[str]) -> dict[str, str]:
+        resolved: dict[str, str] = {}
+        for path in folder_paths:
+            if self._folders_service is not None:
+                key = await self._folders_service.retrieve_key_async(folder_path=path)
+                if key is not None:
+                    resolved[path] = key
+                    continue
+            resolved[path] = path
+        return resolved
+
+    @staticmethod
+    def _build(
+        entity_overwrites: Dict[str, EntityResourceOverwrite],
+        resolved: dict[str, str],
+    ) -> Optional[QueryRoutingOverrideContext]:
+        routings: list[EntityRouting] = []
+        for original_name, overwrite in entity_overwrites.items():
+            override_name = (
+                overwrite.resource_identifier
+                if overwrite.resource_identifier != original_name
+                else None
+            )
+            folder_id = _resolve_overwrite_folder(overwrite, resolved)
+            routings.append(
+                EntityRouting(
+                    entity_name=original_name,
+                    folder_id=folder_id,
+                    override_entity_name=override_name,
+                )
+            )
+
+        if not routings:
+            return None
+        return QueryRoutingOverrideContext(entity_routings=routings)
+
+
+def create_routing_strategy(
+    *,
+    folders_map: Optional[Dict[str, str]],
+    effective_entity_names: Optional[Dict[str, str]],
+    routing_context: Optional[QueryRoutingOverrideContext],
+    folders_service: Optional[FolderService],
+) -> RoutingStrategy:
+    """Select the appropriate routing strategy based on init-time state."""
+    if routing_context is not None:
+        return PreResolvedRoutingStrategy(routing_context)
+    if folders_map:
+        return FoldersMapRoutingStrategy(
+            folders_map,
+            effective_entity_names or {},
+            folders_service,
+        )
+    return ContextOverwriteRoutingStrategy(folders_service)
+
+
+# ---------------------------------------------------------------------------
+# Helpers shared across strategies
+# ---------------------------------------------------------------------------
+
+
+def _get_entity_overwrites_from_context() -> Dict[str, EntityResourceOverwrite]:
+    """Extract entity overwrites from the active ResourceOverwritesContext."""
+    context_overwrites = _resource_overwrites.get()
+    if not context_overwrites:
+        return {}
+
+    result: Dict[str, EntityResourceOverwrite] = {}
+    for key, overwrite in context_overwrites.items():
+        if isinstance(overwrite, EntityResourceOverwrite):
+            original_name = key.split(".", 1)[1] if "." in key else key
+            result[original_name] = overwrite
+    return result
+
+
+def _resolve_overwrite_folder(
+    overwrite: EntityResourceOverwrite,
+    resolved: dict[str, str],
+) -> str:
+    """Return the folder key for an entity overwrite.
+
+    Uses folder_id directly when present (already a key).
+    Falls back to resolving folder_path through the resolved map.
+    """
+    if overwrite.folder_id:
+        return overwrite.folder_id
+    if overwrite.folder_path and resolved:
+        return resolved.get(overwrite.folder_path, overwrite.folder_path)
+    return overwrite.folder_identifier
+
+
+# ---------------------------------------------------------------------------
+# Resolution plan (used by resolve_entity_set)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class EntityFetchByKey:
+    entity_key: str
+
+
+@dataclass(frozen=True)
+class EntityFetchByName:
+    entity_name: str
+    folder_key: str
+
+
+@dataclass(frozen=True)
+class EntityResolutionDraft:
+    fetch_by_key: list[EntityFetchByKey]
+    fetch_by_name: list[EntityFetchByName]
+    folders_map: dict[str, str]
+    effective_entity_names: dict[str, str]
+    folder_paths_to_resolve: set[str]
+
+
+@dataclass(frozen=True)
+class EntityResolutionPlan:
+    fetch_by_key: list[EntityFetchByKey]
+    fetch_by_name: list[EntityFetchByName]
+    folders_map: dict[str, str]
+    effective_entity_names: dict[str, str]
+    routing_context: QueryRoutingOverrideContext | None
+
+
+def create_resolution_draft(
+    items: list[DataFabricEntityItem],
+    context_overwrites: dict[str, ResourceOverwrite],
+) -> EntityResolutionDraft:
+    folders_map: dict[str, str] = {}
+    effective_entity_names: dict[str, str] = {}
+    folder_paths_to_resolve: set[str] = set()
+    fetch_by_key: list[EntityFetchByKey] = []
+    fetch_by_name: list[EntityFetchByName] = []
+
+    for item in items:
+        overwrite = context_overwrites.get(
+            f"entity.{item.id}"
+        ) or context_overwrites.get(f"entity.{item.name}")
+        resolved_folder = item.folder_key
+
+        if isinstance(overwrite, EntityResourceOverwrite):
+            folder_changed = False
+            if overwrite.folder_id:
+                resolved_folder = overwrite.folder_id
+                folder_changed = resolved_folder != item.folder_key
+            elif overwrite.folder_path:
+                resolved_folder = overwrite.folder_path
+                folder_changed = True
+                folder_paths_to_resolve.add(overwrite.folder_path)
+
+            if overwrite.name != item.name or folder_changed:
+                if overwrite.name != item.name:
+                    effective_entity_names[item.name] = overwrite.name
+                fetch_by_name.append(
+                    EntityFetchByName(
+                        entity_name=overwrite.name,
+                        folder_key=resolved_folder,
+                    )
+                )
+                folders_map[item.name] = resolved_folder
+                continue
+
+        fetch_by_key.append(EntityFetchByKey(entity_key=item.entity_key or item.id))
+        folders_map[item.name] = resolved_folder
+
+    return EntityResolutionDraft(
+        fetch_by_key=fetch_by_key,
+        fetch_by_name=fetch_by_name,
+        folders_map=folders_map,
+        effective_entity_names=effective_entity_names,
+        folder_paths_to_resolve=folder_paths_to_resolve,
+    )
+
+
+def finalize_resolution_plan(
+    draft: EntityResolutionDraft,
+    resolve_folder_path: Callable[[str], Optional[str]],
+) -> EntityResolutionPlan:
+    resolved_paths: dict[str, str] = {}
+    for folder_path in draft.folder_paths_to_resolve:
+        resolved_paths[folder_path] = resolve_folder_path(folder_path) or folder_path
+
+    resolved_folders_map = {
+        entity_name: resolved_paths.get(folder_key, folder_key)
+        for entity_name, folder_key in draft.folders_map.items()
+    }
+    resolved_fetch_by_name = [
+        EntityFetchByName(
+            entity_name=entry.entity_name,
+            folder_key=resolved_paths.get(entry.folder_key, entry.folder_key),
+        )
+        for entry in draft.fetch_by_name
+    ]
+
+    return EntityResolutionPlan(
+        fetch_by_key=draft.fetch_by_key,
+        fetch_by_name=resolved_fetch_by_name,
+        folders_map=resolved_folders_map,
+        effective_entity_names=draft.effective_entity_names,
+        routing_context=build_resolution_routing_context(
+            resolved_folders_map,
+            draft.effective_entity_names,
+        ),
+    )
+
+
+def build_resolution_routing_context(
+    folders_map: dict[str, str],
+    effective_entity_names: dict[str, str],
+) -> QueryRoutingOverrideContext | None:
+    routings = [
+        EntityRouting(
+            entity_name=original_name,
+            folder_id=folder_id,
+            override_entity_name=effective_entity_names.get(original_name),
+        )
+        for original_name, folder_id in folders_map.items()
+    ]
+    if not routings:
+        return None
+
+    return QueryRoutingOverrideContext(entity_routings=routings)
+
+
+def create_resolution_plan(
+    items: list[DataFabricEntityItem],
+    context_overwrites: dict[str, ResourceOverwrite],
+    resolve_folder_path: FolderPathResolver,
+) -> EntityResolutionPlan:
+    draft = create_resolution_draft(items, context_overwrites)
+    return finalize_resolution_plan(draft, resolve_folder_path)
+
+
+async def create_resolution_plan_async(
+    items: list[DataFabricEntityItem],
+    context_overwrites: dict[str, ResourceOverwrite],
+    resolve_folder_path: AsyncFolderPathResolver,
+) -> EntityResolutionPlan:
+    draft = create_resolution_draft(items, context_overwrites)
+    folder_paths = list(draft.folder_paths_to_resolve)
+    results = await asyncio.gather(*(resolve_folder_path(fp) for fp in folder_paths))
+    resolved_paths = {
+        fp: result or fp for fp, result in zip(folder_paths, results, strict=True)
+    }
+
+    return finalize_resolution_plan(
+        draft,
+        lambda folder_path: resolved_paths.get(folder_path, folder_path),
+    )
+
+
+def fetch_resolved_entities(
+    plan: EntityResolutionPlan,
+    retrieve_by_key: EntityByKeyFetcher,
+    retrieve_by_name: EntityByNameFetcher,
+    logger: logging.Logger,
+) -> list[Entity]:
+    entities: list[Entity] = []
+    for key_entry in plan.fetch_by_key:
+        try:
+            entities.append(retrieve_by_key(key_entry.entity_key))
+        except Exception:
+            logger.warning(
+                "Failed to fetch entity by key '%s', skipping.",
+                key_entry.entity_key,
+                exc_info=True,
+            )
+
+    for name_entry in plan.fetch_by_name:
+        try:
+            entities.append(
+                retrieve_by_name(name_entry.entity_name, name_entry.folder_key)
+            )
+        except Exception:
+            logger.warning(
+                "Failed to fetch entity by name '%s' (folder_key=%s), skipping.",
+                name_entry.entity_name,
+                name_entry.folder_key,
+                exc_info=True,
+            )
+
+    return entities
+
+
+async def fetch_resolved_entities_async(
+    plan: EntityResolutionPlan,
+    retrieve_by_key: AsyncEntityByKeyFetcher,
+    retrieve_by_name: AsyncEntityByNameFetcher,
+    logger: logging.Logger,
+) -> list[Entity]:
+    async def _safe_fetch_by_key(entry: EntityFetchByKey) -> Optional[Entity]:
+        try:
+            return await retrieve_by_key(entry.entity_key)
+        except Exception:
+            logger.warning(
+                "Failed to fetch entity by key '%s', skipping.",
+                entry.entity_key,
+                exc_info=True,
+            )
+            return None
+
+    async def _safe_fetch_by_name(entry: EntityFetchByName) -> Optional[Entity]:
+        try:
+            return await retrieve_by_name(
+                entry.entity_name,
+                entry.folder_key,
+            )
+        except Exception:
+            logger.warning(
+                "Failed to fetch entity by name '%s' (folder_key=%s), skipping.",
+                entry.entity_name,
+                entry.folder_key,
+                exc_info=True,
+            )
+            return None
+
+    tasks = [_safe_fetch_by_key(entry) for entry in plan.fetch_by_key] + [
+        _safe_fetch_by_name(entry) for entry in plan.fetch_by_name
+    ]
+    results = await asyncio.gather(*tasks)
+    return [entity for entity in results if entity is not None]
+
+
+def build_resolution_service(
+    *,
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    folders_service: FolderService | None,
+    plan: EntityResolutionPlan,
+    service_factory: Callable[..., object],
+) -> object:
+    return service_factory(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folders_service,
+        folders_map=plan.folders_map,
+        entity_name_overrides=plan.effective_entity_names,
+        routing_context=plan.routing_context,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/entities/_entity_schema_service.py b/packages/uipath-platform/src/uipath/platform/entities/_entity_schema_service.py
new file mode 100644
index 000000000..9872969d6
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/_entity_schema_service.py
@@ -0,0 +1,522 @@
+"""Schema-side operations for the Data Fabric entities surface.
+
+Handles entity definitions, choice set listings, and the create / delete /
+update-metadata lifecycle that targets the backend ``EntityController``.
+Record CRUD, queries, attachments, and bulk import live on
+:class:`EntityDataService` and are mediated by :class:`EntitiesService`.
+"""
+
+import re
+from typing import Any, Dict, List, Optional
+
+from httpx import Response
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from ..common.constants import HEADER_FOLDER_KEY
+from ..orchestrator._folder_service import FolderService
+from .entities import (
+    ENTITY_FIELD_CONSTRAINT_DEFAULTS,
+    ENTITY_FIELD_CONSTRAINT_SPEC,
+    ENTITY_SCHEMA_FIELD_TYPE_MAP,
+    RESERVED_FIELD_NAMES,
+    Entity,
+    EntityCreateFieldOptions,
+    EntityCreateOptions,
+    EntityFieldDataType,
+    EntityMetadataUpdateOptions,
+)
+
+DATA_FABRIC_TENANT_FOLDER_ID = "00000000-0000-0000-0000-000000000000"
+
+_NAME_RE = re.compile(r"^[a-zA-Z][a-zA-Z0-9]*$")
+"""Entity and field name pattern: must start with a letter, then letters and digits only.
+
+Matches the UI's create-entity / create-field form validators so any name accepted
+here can later be displayed or edited through the Data Service UI.
+"""
+
+_ENTITY_NAME_MIN_LENGTH = 1
+_ENTITY_NAME_MAX_LENGTH = 30
+_FIELD_NAME_MIN_LENGTH = 3
+_FIELD_NAME_MAX_LENGTH = 100
+
+
+class EntitySchemaService(BaseService):
+    """HTTP service for entity-schema operations.
+
+    Provides retrieval and lifecycle management for entities and choice sets.
+    Backend target: ``datafabric_/api/Entity``.
+
+    See Also:
+        https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/introduction
+
+    !!! warning "Preview Feature"
+        This service is currently experimental. Behavior and parameters are
+        subject to change in future versions.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: Optional[FolderService] = None,
+    ) -> None:
+        """Initialise the schema service."""
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    def retrieve(self, entity_key: str) -> Entity:
+        """Internal implementation; see :meth:`EntitiesService.retrieve`."""
+        spec = self._retrieve_spec(entity_key)
+        response = self.request(spec.method, spec.endpoint)
+        return Entity.model_validate(response.json())
+
+    async def retrieve_async(self, entity_key: str) -> Entity:
+        """Async variant of :meth:`retrieve`."""
+        spec = self._retrieve_spec(entity_key)
+        response = await self.request_async(spec.method, spec.endpoint)
+        return Entity.model_validate(response.json())
+
+    def retrieve_by_name(
+        self, entity_name: str, folder_key: Optional[str] = None
+    ) -> Entity:
+        """Internal implementation; see :meth:`EntitiesService.retrieve_by_name`."""
+        spec = self._retrieve_by_name_spec(entity_name)
+        headers = self._folder_key_headers(folder_key)
+        response = self.request(spec.method, spec.endpoint, headers=headers)
+        return Entity.model_validate(response.json())
+
+    async def retrieve_by_name_async(
+        self, entity_name: str, folder_key: Optional[str] = None
+    ) -> Entity:
+        """Async variant of :meth:`retrieve_by_name`."""
+        spec = self._retrieve_by_name_spec(entity_name)
+        headers = self._folder_key_headers(folder_key)
+        response = await self.request_async(spec.method, spec.endpoint, headers=headers)
+        return Entity.model_validate(response.json())
+
+    def list_entities(self) -> List[Entity]:
+        """Internal implementation; see :meth:`EntitiesService.list_entities`."""
+        spec = self._list_entities_spec()
+        response = self.request(spec.method, spec.endpoint)
+        entities_data = response.json()
+        return [Entity.model_validate(entity) for entity in entities_data]
+
+    async def list_entities_async(self) -> List[Entity]:
+        """Async variant of :meth:`list_entities`."""
+        spec = self._list_entities_spec()
+        response = await self.request_async(spec.method, spec.endpoint)
+        entities_data = response.json()
+        return [Entity.model_validate(entity) for entity in entities_data]
+
+    def list_choicesets(self) -> List[Entity]:
+        """Internal implementation; see :meth:`EntitiesService.list_choicesets`."""
+        spec = self._list_choicesets_spec()
+        response = self.request(spec.method, spec.endpoint)
+        return [Entity.model_validate(item) for item in response.json()]
+
+    async def list_choicesets_async(self) -> List[Entity]:
+        """Async variant of :meth:`list_choicesets`."""
+        spec = self._list_choicesets_spec()
+        response = await self.request_async(spec.method, spec.endpoint)
+        return [Entity.model_validate(item) for item in response.json()]
+
+    def create_entity(
+        self,
+        name: str,
+        fields: List[EntityCreateFieldOptions],
+        options: Optional[EntityCreateOptions] = None,
+    ) -> str:
+        """Internal implementation; see :meth:`EntitiesService.create_entity`."""
+        spec = self._create_entity_spec(name, fields, options)
+        response = self.request(spec.method, spec.endpoint, json=spec.json)
+        return self._extract_entity_id(response)
+
+    async def create_entity_async(
+        self,
+        name: str,
+        fields: List[EntityCreateFieldOptions],
+        options: Optional[EntityCreateOptions] = None,
+    ) -> str:
+        """Async variant of :meth:`create_entity`."""
+        spec = self._create_entity_spec(name, fields, options)
+        response = await self.request_async(spec.method, spec.endpoint, json=spec.json)
+        return self._extract_entity_id(response)
+
+    def delete_entity(self, entity_id: str) -> None:
+        """Delete an entity and all of its records."""
+        spec = self._delete_entity_spec(entity_id)
+        self.request(spec.method, spec.endpoint)
+
+    async def delete_entity_async(self, entity_id: str) -> None:
+        """Async variant of :meth:`delete_entity`."""
+        spec = self._delete_entity_spec(entity_id)
+        await self.request_async(spec.method, spec.endpoint)
+
+    def update_entity_metadata(
+        self,
+        entity_id: str,
+        metadata: EntityMetadataUpdateOptions | Dict[str, Any],
+    ) -> None:
+        """Internal implementation; see :meth:`EntitiesService.update_entity_metadata`."""
+        spec = self._update_entity_metadata_spec(entity_id, metadata)
+        self.request(spec.method, spec.endpoint, json=spec.json)
+
+    async def update_entity_metadata_async(
+        self,
+        entity_id: str,
+        metadata: EntityMetadataUpdateOptions | Dict[str, Any],
+    ) -> None:
+        """Async variant of :meth:`update_entity_metadata`."""
+        spec = self._update_entity_metadata_spec(entity_id, metadata)
+        await self.request_async(spec.method, spec.endpoint, json=spec.json)
+
+    # ------------------------------------------------------------------
+    # Request-spec builders
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _retrieve_spec(entity_key: str) -> RequestSpec:
+        """Build the GET spec for fetching an entity by key."""
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"datafabric_/api/Entity/{entity_key}"),
+        )
+
+    @staticmethod
+    def _retrieve_by_name_spec(entity_name: str) -> RequestSpec:
+        """Build the GET spec for fetching an entity by name."""
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"datafabric_/api/Entity/{entity_name}/metadata"),
+        )
+
+    @staticmethod
+    def _folder_key_headers(folder_key: Optional[str]) -> Dict[str, str]:
+        """Return the folder-key header dict, empty when no key is supplied."""
+        if folder_key:
+            return {HEADER_FOLDER_KEY: folder_key}
+        return {}
+
+    @staticmethod
+    def _list_entities_spec() -> RequestSpec:
+        """Build the GET spec for listing all entities (non-choice-sets)."""
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("datafabric_/api/Entity"),
+        )
+
+    @staticmethod
+    def _list_choicesets_spec() -> RequestSpec:
+        """Build the GET spec for listing all choice sets."""
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("datafabric_/api/Entity/choiceset"),
+        )
+
+    @classmethod
+    def _create_entity_spec(
+        cls,
+        name: str,
+        fields: List[EntityCreateFieldOptions],
+        options: Optional[EntityCreateOptions] = None,
+    ) -> RequestSpec:
+        """Build the POST spec for creating an entity with its field schema."""
+        cls._validate_name(name, "entity")
+        for field in fields:
+            cls._validate_name(field.field_name, "field")
+        opts = options or EntityCreateOptions()
+        # The user-facing option ``is_analytics_enabled`` maps to the legacy
+        # backend field name ``isInsightsEnabled`` — the wire name predates
+        # the "Analytics" UI rename.
+        payload: Dict[str, Any] = {
+            "displayName": opts.display_name or name,
+            "entityDefinition": {
+                "name": name,
+                "fields": [cls._build_schema_field_payload(f) for f in fields],
+                "folderId": opts.folder_key or DATA_FABRIC_TENANT_FOLDER_ID,
+                "isRbacEnabled": bool(opts.is_rbac_enabled or False),
+                "isInsightsEnabled": bool(opts.is_analytics_enabled or False),
+                "externalFields": opts.external_fields or [],
+            },
+        }
+        if opts.description is not None:
+            payload["description"] = opts.description
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("datafabric_/api/Entity"),
+            json=payload,
+        )
+
+    @staticmethod
+    def _delete_entity_spec(entity_id: str) -> RequestSpec:
+        """Build the DELETE spec for removing an entity."""
+        return RequestSpec(
+            method="DELETE",
+            endpoint=Endpoint(f"datafabric_/api/Entity/{entity_id}"),
+        )
+
+    @staticmethod
+    def _update_entity_metadata_spec(
+        entity_id: str,
+        metadata: EntityMetadataUpdateOptions | Dict[str, Any],
+    ) -> RequestSpec:
+        """Build the PATCH spec for updating entity metadata.
+
+        Dict inputs are validated through :class:`EntityMetadataUpdateOptions`
+        so snake_case keys (``display_name``) and camelCase keys
+        (``displayName``) both serialise to the API field names the backend
+        expects.
+        """
+        if not isinstance(metadata, EntityMetadataUpdateOptions):
+            metadata = EntityMetadataUpdateOptions.model_validate(metadata)
+        body = metadata.model_dump(by_alias=True, exclude_none=True)
+        return RequestSpec(
+            method="PATCH",
+            endpoint=Endpoint(f"datafabric_/api/Entity/{entity_id}/metadata"),
+            json=body,
+        )
+
+    @classmethod
+    def _build_schema_field_payload(
+        cls, field: EntityCreateFieldOptions
+    ) -> Dict[str, Any]:
+        """Build the API field payload for a single field on create-entity.
+
+        Maps :class:`EntityFieldDataType` to the backend's ``sqlType.name`` and
+        ``fieldDisplayType`` (e.g. ``STRING`` becomes ``NVARCHAR`` / ``Basic``).
+        Caller-supplied constraints are validated against
+        :data:`ENTITY_FIELD_CONSTRAINT_SPEC`; unsupplied per-type constraints
+        fall back to :data:`ENTITY_FIELD_CONSTRAINT_DEFAULTS` so the field is
+        persisted fully and remains editable later.
+        """
+        ftype = field.type or EntityFieldDataType.STRING
+        cls._validate_name(field.field_name, "field")
+        cls._validate_field_constraints(ftype, field)
+
+        sql_type_name, field_display_type = ENTITY_SCHEMA_FIELD_TYPE_MAP[ftype]
+        sql_type: Dict[str, Any] = {"name": sql_type_name}
+        sql_type.update(cls._build_sql_type_constraints(ftype, field))
+
+        payload: Dict[str, Any] = {
+            "name": field.field_name,
+            "displayName": field.display_name or field.field_name,
+            "sqlType": sql_type,
+            "fieldDisplayType": field_display_type,
+            "description": field.description or "",
+            "isRequired": bool(field.is_required or False),
+            "isUnique": bool(field.is_unique or False),
+            "isRbacEnabled": bool(field.is_rbac_enabled or False),
+            "isEncrypted": bool(field.is_encrypted or False),
+        }
+        if field.default_value is not None:
+            payload["defaultValue"] = field.default_value
+        if field.choice_set_id is not None:
+            payload["choiceSetId"] = field.choice_set_id
+        if field.reference_entity_name is not None:
+            payload["referenceEntityName"] = field.reference_entity_name
+        if field.reference_field_name is not None:
+            payload["referenceFieldName"] = field.reference_field_name
+        return payload
+
+    @staticmethod
+    def _build_sql_type_constraints(
+        ftype: EntityFieldDataType, field: EntityCreateFieldOptions
+    ) -> Dict[str, Any]:
+        """Return the ``sqlType`` constraint fields required for ``ftype``.
+
+        Caller-supplied values override defaults where the type accepts them;
+        types that take no constraints (UUID, DATETIME, CHOICE_SET_SINGLE,
+        AUTO_NUMBER) return an empty dict.
+        """
+        d = ENTITY_FIELD_CONSTRAINT_DEFAULTS
+        if ftype is EntityFieldDataType.STRING:
+            return {"lengthLimit": field.length_limit or d["STRING_LENGTH_LIMIT"]}
+        if ftype is EntityFieldDataType.MULTILINE_TEXT:
+            return {
+                "lengthLimit": field.length_limit or d["MULTILINE_TEXT_LENGTH_LIMIT"]
+            }
+        if ftype is EntityFieldDataType.DECIMAL:
+            return {
+                "lengthLimit": d["DECIMAL_LENGTH_LIMIT"],
+                "decimalPrecision": (
+                    field.decimal_precision
+                    if field.decimal_precision is not None
+                    else d["DECIMAL_PRECISION"]
+                ),
+                "maxValue": (
+                    field.max_value
+                    if field.max_value is not None
+                    else d["NUMERIC_MAX_VALUE"]
+                ),
+                "minValue": (
+                    field.min_value
+                    if field.min_value is not None
+                    else d["NUMERIC_MIN_VALUE"]
+                ),
+            }
+        if ftype is EntityFieldDataType.BOOLEAN:
+            return {"lengthLimit": d["BOOLEAN_LENGTH_LIMIT"]}
+        if ftype in (
+            EntityFieldDataType.DATE,
+            EntityFieldDataType.DATETIME_WITH_TZ,
+        ):
+            return {"lengthLimit": d["DATE_LENGTH_LIMIT"]}
+        if ftype in (EntityFieldDataType.INTEGER, EntityFieldDataType.BIG_INTEGER):
+            return {
+                "maxValue": (
+                    field.max_value
+                    if field.max_value is not None
+                    else d["NUMERIC_MAX_VALUE"]
+                ),
+                "minValue": (
+                    field.min_value
+                    if field.min_value is not None
+                    else d["NUMERIC_MIN_VALUE"]
+                ),
+            }
+        if ftype in (EntityFieldDataType.FLOAT, EntityFieldDataType.DOUBLE):
+            return {
+                "decimalPrecision": (
+                    field.decimal_precision
+                    if field.decimal_precision is not None
+                    else d["DECIMAL_PRECISION"]
+                ),
+                "maxValue": (
+                    field.max_value
+                    if field.max_value is not None
+                    else d["NUMERIC_MAX_VALUE"]
+                ),
+                "minValue": (
+                    field.min_value
+                    if field.min_value is not None
+                    else d["NUMERIC_MIN_VALUE"]
+                ),
+            }
+        if ftype in (EntityFieldDataType.FILE, EntityFieldDataType.RELATIONSHIP):
+            return {"lengthLimit": d["UNIQUEIDENTIFIER_LENGTH_LIMIT"]}
+        if ftype is EntityFieldDataType.CHOICE_SET_MULTIPLE:
+            return {"lengthLimit": d["CHOICE_SET_MULTIPLE_LENGTH_LIMIT"]}
+        # UUID, DATETIME, CHOICE_SET_SINGLE, AUTO_NUMBER — no constraints
+        return {}
+
+    @staticmethod
+    def _validate_name(name: str, context: str) -> None:
+        r"""Validate an entity or field name against the UI's create-form rules.
+
+        Entity names must be 1-30 characters; field names must be 3-100
+        characters. Both must match ``^[a-zA-Z][a-zA-Z0-9]*$`` — start with a
+        letter, then letters or digits only (underscores are not permitted, to
+        stay consistent with the UI's entity / field creation forms).
+
+        Field names additionally cannot collide with the system-reserved field
+        names in :data:`RESERVED_FIELD_NAMES`; the reserved-name check runs
+        first so that short reserved names produce a more informative error.
+        """
+        if context == "field":
+            if name in RESERVED_FIELD_NAMES:
+                reserved = ", ".join(sorted(RESERVED_FIELD_NAMES))
+                raise ValueError(
+                    f"Field name {name!r} is reserved. Reserved names: {reserved}."
+                )
+            min_len, max_len = _FIELD_NAME_MIN_LENGTH, _FIELD_NAME_MAX_LENGTH
+        else:
+            min_len, max_len = _ENTITY_NAME_MIN_LENGTH, _ENTITY_NAME_MAX_LENGTH
+
+        if not (min_len <= len(name) <= max_len) or not _NAME_RE.match(name):
+            raise ValueError(
+                f"Invalid {context} name {name!r}. Must start with a letter, "
+                f"contain only letters and digits, and be {min_len}-{max_len} "
+                "characters."
+            )
+
+    @staticmethod
+    def _validate_field_constraints(
+        ftype: EntityFieldDataType, field: EntityCreateFieldOptions
+    ) -> None:
+        """Validate caller-supplied per-field constraints.
+
+        Rejects constraints that ``ftype`` does not accept (e.g.
+        ``decimal_precision`` on ``STRING``), values outside the inclusive
+        range declared in :data:`ENTITY_FIELD_CONSTRAINT_SPEC`, and
+        ``min_value`` greater than or equal to ``max_value`` when both are
+        supplied. Also enforces type-dependent required references:
+        ``CHOICE_SET_SINGLE`` and ``CHOICE_SET_MULTIPLE`` need
+        ``choice_set_id``; ``RELATIONSHIP`` needs ``reference_entity_name``.
+        """
+        if (
+            ftype
+            in (
+                EntityFieldDataType.CHOICE_SET_SINGLE,
+                EntityFieldDataType.CHOICE_SET_MULTIPLE,
+            )
+            and not field.choice_set_id
+        ):
+            raise ValueError(
+                f"Field {field.field_name!r} of type {ftype.value} requires "
+                "choice_set_id."
+            )
+        if (
+            ftype is EntityFieldDataType.RELATIONSHIP
+            and not field.reference_entity_name
+        ):
+            raise ValueError(
+                f"Field {field.field_name!r} of type {ftype.value} requires "
+                "reference_entity_name."
+            )
+
+        spec = ENTITY_FIELD_CONSTRAINT_SPEC.get(ftype, {})
+        provided: Dict[str, Any] = {}
+        for attr in ("length_limit", "max_value", "min_value", "decimal_precision"):
+            value = getattr(field, attr)
+            if value is not None:
+                provided[attr] = value
+
+        unsupported = [name for name in provided if name not in spec]
+        if unsupported:
+            allowed = ", ".join(sorted(spec.keys())) or "none"
+            raise ValueError(
+                f"Field {field.field_name!r} of type {ftype.value} does not accept "
+                f"{', '.join(sorted(unsupported))}. Allowed constraints: {allowed}."
+            )
+
+        for name, value in provided.items():
+            low, high = spec[name]
+            if not (low <= value <= high):
+                raise ValueError(
+                    f"Field {field.field_name!r} of type {ftype.value}: "
+                    f"{name}={value} is out of range [{low}, {high}]."
+                )
+
+        if (
+            field.min_value is not None
+            and field.max_value is not None
+            and field.min_value >= field.max_value
+        ):
+            raise ValueError(
+                f"Field {field.field_name!r}: min_value ({field.min_value}) must be "
+                f"strictly less than max_value ({field.max_value})."
+            )
+
+    @staticmethod
+    def _extract_entity_id(response: Response) -> str:
+        """Return the new entity id from a create-entity response.
+
+        Accepts both a bare JSON string id and a JSON object containing
+        ``id`` or ``entityId``.
+        """
+        try:
+            body = response.json()
+        except Exception:
+            return response.text.strip().strip('"')
+        if isinstance(body, str):
+            return body
+        if isinstance(body, dict):
+            for key in ("id", "Id", "entityId", "EntityId"):
+                value = body.get(key)
+                if isinstance(value, str):
+                    return value
+        return response.text.strip().strip('"')
diff --git a/packages/uipath-platform/src/uipath/platform/entities/entities.py b/packages/uipath-platform/src/uipath/platform/entities/entities.py
new file mode 100644
index 000000000..51eea2d1b
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/entities/entities.py
@@ -0,0 +1,856 @@
+"""Entities models for UiPath Platform API interactions."""
+
+from __future__ import annotations
+
+from enum import Enum, IntEnum
+from types import EllipsisType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    overload,
+)
+
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    create_model,
+    model_validator,
+)
+
+if TYPE_CHECKING:
+    from ._entities_service import EntitiesService
+
+
+class ReferenceType(Enum):
+    """Enum representing types of references between entities."""
+
+    ManyToOne = "ManyToOne"
+
+
+class FieldDisplayType(Enum):
+    """Enum representing display types of fields in entities."""
+
+    Basic = "Basic"
+    Relationship = "Relationship"
+    File = "File"
+    ChoiceSetSingle = "ChoiceSetSingle"
+    ChoiceSetMultiple = "ChoiceSetMultiple"
+    AutoNumber = "AutoNumber"
+
+
+class DataDirectionType(Enum):
+    """Enum representing data direction types for fields in entities."""
+
+    ReadOnly = "ReadOnly"
+    ReadAndWrite = "ReadAndWrite"
+
+
+class JoinType(Enum):
+    """Enum representing types of joins between entities."""
+
+    LeftJoin = "LeftJoin"
+
+
+class EntityType(Enum):
+    """Enum representing types of entities."""
+
+    Entity = "Entity"
+    ChoiceSet = "ChoiceSet"
+    InternalEntity = "InternalEntity"
+    SystemEntity = "SystemEntity"
+
+
+class EntityFieldMetadata(BaseModel):
+    """Model representing metadata for an entity field."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+    )
+    type: str
+    required: bool
+    name: str
+
+
+class ExternalConnection(BaseModel):
+    """Model representing an external connection."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    connection_id: str = Field(alias="connectionId")
+    element_instance_id: str = Field(alias="elementInstanceId")
+    folder_id: str = Field(alias="folderKey")
+    connector_id: str = Field(alias="connectorKey")
+    connector_name: str = Field(alias="connectorName")
+    connection_name: str = Field(alias="connectionName")
+
+
+class ExternalFieldMapping(BaseModel):
+    """Model representing an external field mapping."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    external_field_name: str = Field(alias="externalFieldName")
+    external_field_display_name: str = Field(alias="externalFieldDisplayName")
+    external_object_id: str = Field(alias="externalObjectId")
+    external_field_type: str = Field(alias="externalFieldType")
+    internal_field_id: str = Field(alias="internalFieldId")
+    direction_type: DataDirectionType = Field(alias="directionType")
+
+
+class FieldDataType(BaseModel):
+    """Model representing data type information for a field."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    name: str
+    length_limit: Optional[int] = Field(default=None, alias="LengthLimit")
+    max_value: Optional[int] = Field(default=None, alias="MaxValue")
+    min_value: Optional[int] = Field(default=None, alias="MinValue")
+    decimal_precision: Optional[int] = Field(default=None, alias="DecimalPrecision")
+
+
+class FieldMetadata(BaseModel):
+    """Model representing metadata for an entity field."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: Optional[str] = Field(default=None, alias="id")
+    name: str
+    is_primary_key: bool = Field(alias="isPrimaryKey")
+    is_foreign_key: bool = Field(alias="isForeignKey")
+    is_external_field: bool = Field(alias="isExternalField")
+    is_hidden_field: bool = Field(alias="isHiddenField")
+    is_unique: bool = Field(alias="isUnique")
+    reference_name: Optional[str] = Field(default=None, alias="referenceName")
+    reference_entity: Optional["Entity"] = Field(default=None, alias="referenceEntity")
+    reference_choiceset: Optional["Entity"] = Field(
+        default=None, alias="referenceChoiceset"
+    )
+    reference_field: Optional["EntityField"] = Field(
+        default=None, alias="referenceField"
+    )
+    reference_type: Optional[ReferenceType] = Field(default=None, alias="referenceType")
+    sql_type: "FieldDataType" = Field(alias="sqlType")
+    is_required: bool = Field(alias="isRequired")
+    display_name: str = Field(alias="displayName")
+    description: Optional[str] = Field(default=None, alias="description")
+    is_system_field: bool = Field(alias="isSystemField")
+    field_display_type: Optional[str] = Field(
+        default=None, alias="fieldDisplayType"
+    )  # Should be FieldDisplayType enum
+    choiceset_id: Optional[str] = Field(default=None, alias="choicesetId")
+    default_value: Optional[str] = Field(default=None, alias="defaultValue")
+    is_attachment: bool = Field(alias="isAttachment")
+    is_rbac_enabled: bool = Field(alias="isRbacEnabled")
+
+
+class ExternalField(BaseModel):
+    """Model representing an external field."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    field_metadata: FieldMetadata = Field(alias="fieldMetadata")
+    external_field_mapping_detail: ExternalFieldMapping = Field(
+        alias="externalFieldMappingDetail"
+    )
+
+
+class EntityField(BaseModel):
+    """Model representing a field within an entity."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+    )
+    id: Optional[str] = Field(default=None, alias="id")
+    definition: Optional[FieldMetadata] = Field(default=None, alias="definition")
+
+
+class ExternalObject(BaseModel):
+    """Model representing an external object."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    external_object_name: str = Field(alias="externalObjectName")
+    external_object_display_name: str = Field(alias="externalObjectDisplayName")
+    primary_key: str = Field(alias="primaryKey")
+    external_connection_id: str = Field(alias="externalConnectionId")
+    entity_id: str = Field(alias="entityId")
+    is_primary_source: bool = Field(alias="isPrimarySource")
+
+
+class ExternalSourceFields(BaseModel):
+    """Model representing external source fields."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    fields: List[ExternalField]
+    external_object_detail: ExternalObject = Field(alias="externalObject")
+    external_connection_detail: ExternalConnection = Field(alias="externalConnection")
+
+
+class SourceJoinCriteria(BaseModel):
+    """Model representing source join criteria."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        extra="allow",
+    )
+    id: Optional[str] = None
+    entity_id: Optional[str] = Field(default=None, alias="entityId")
+    join_field_name: Optional[str] = Field(default=None, alias="joinFieldName")
+    join_type: Optional[str] = Field(default=None, alias="joinType")
+    related_source_object_id: Optional[str] = Field(
+        default=None, alias="relatedSourceObjectId"
+    )
+    related_source_object_field_name: Optional[str] = Field(
+        default=None, alias="relatedSourceObjectFieldName"
+    )
+    related_source_field_name: Optional[str] = Field(
+        default=None, alias="relatedSourceFieldName"
+    )
+
+
+class ChoiceSetValue(BaseModel):
+    """Model representing a single value within a choice set."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    id: str = Field(alias="Id")
+    name: str = Field(alias="Name")
+    display_name: str = Field(alias="DisplayName")
+    number_id: int = Field(alias="NumberId")
+    created_time: str | None = Field(default=None, alias="CreateTime")
+    updated_time: str | None = Field(default=None, alias="UpdateTime")
+    created_by: str | None = Field(default=None, alias="CreatedBy")
+    updated_by: str | None = Field(default=None, alias="UpdatedBy")
+    record_owner: str | None = Field(default=None, alias="RecordOwner")
+
+
+class EntityRecord(BaseModel):
+    """Model representing a record within an entity."""
+
+    model_config = {
+        "validate_by_name": True,
+        "validate_by_alias": True,
+        "extra": "allow",
+    }
+
+    id: str = Field(alias="Id")
+
+    @classmethod
+    def from_data(
+        cls, data: Dict[str, Any], model: Optional[Any] = None
+    ) -> "EntityRecord":
+        """Create an EntityRecord instance by validating raw data and optionally instantiating a custom model.
+
+        :param data: Raw data dictionary for the entity.
+        :param model: Optional user-defined class for validation.
+        :return: EntityRecord instance
+        """
+        # Validate the "Id" field is mandatory and must be a string
+        id_value = data.get("Id", None)
+        if id_value is None or not isinstance(id_value, str):
+            raise ValueError("Field 'Id' is mandatory and must be a string.")
+
+        if model:
+            # Check if the model is a plain Python class or Pydantic model
+            cls._validate_against_user_model(data, model)
+
+        return cls(**data)
+
+    @staticmethod
+    def _validate_against_user_model(
+        data: Dict[str, Any], user_class: Type[Any]
+    ) -> None:
+        user_class_annotations = getattr(user_class, "__annotations__", None)
+        if user_class_annotations is None:
+            raise ValueError(
+                f"User-provided class '{user_class.__name__}' is missing type annotations."
+            )
+
+        # Dynamically define a Pydantic model based on the user's class annotations
+        # Fields must be valid type annotations directly
+        pydantic_fields: dict[str, tuple[Any, EllipsisType | None]] = {}
+
+        for name, annotation in user_class_annotations.items():
+            is_optional = False
+
+            origin = get_origin(annotation)
+            args = get_args(annotation)
+
+            # Handle Optional[...] or X | None
+            if origin is Union and type(None) in args:
+                is_optional = True
+
+            # Check for optional fields
+            if is_optional:
+                pydantic_fields[name] = (annotation, None)  # Not required
+            else:
+                pydantic_fields[name] = (annotation, ...)
+
+        # Dynamically create the Pydantic model class
+        dynamic_model = create_model(
+            f"Dynamic_{user_class.__name__}",
+            **pydantic_fields,  # type: ignore[call-overload] # __base__ causes an issue. type checker cannot know that the key does not contain "__base__"
+        )
+
+        # Validate input data
+        dynamic_model.model_validate(data)
+
+
+class Entity(BaseModel):
+    """Model representing an entity in the UiPath platform."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    name: str
+    display_name: str = Field(alias="displayName")
+    entity_type: str = Field(alias="entityType")
+    description: Optional[str] = Field(default=None, alias="description")
+    fields: Optional[List[FieldMetadata]] = Field(default=None, alias="fields")
+    external_fields: Optional[
+        List[ExternalField | ExternalSourceFields | Dict[str, Any]]
+    ] = Field(
+        default=None,
+        alias="externalFields",
+    )
+    source_join_criteria: Optional[List[SourceJoinCriteria | Dict[str, Any]]] = Field(
+        default=None,
+        validation_alias=AliasChoices("sourceJoinCriteria", "sourceJoinCriterias"),
+        alias="sourceJoinCriteria",
+    )
+    record_count: Optional[int] = Field(default=None, alias="recordCount")
+    storage_size_in_mb: Optional[float] = Field(default=None, alias="storageSizeInMB")
+    used_storage_size_in_mb: Optional[float] = Field(
+        default=None, alias="usedStorageSizeInMB"
+    )
+    attachment_size_in_byte: Optional[int] = Field(
+        default=None, alias="attachmentSizeInBytes"
+    )
+    is_rbac_enabled: bool = Field(alias="isRbacEnabled")
+    id: str
+
+
+class FailureRecord(BaseModel):
+    """A record that failed to insert/update/delete in a batch operation.
+
+    Backend error responses for failed records do not always include a valid
+    ``Id`` field — this model accepts arbitrary shapes so the caller can
+    inspect ``error`` text and the original ``record`` payload.
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        extra="allow",
+    )
+
+    id: Optional[str] = Field(default=None, alias="Id")
+    error: Optional[str] = Field(default=None)
+    record: Optional[Dict[str, Any]] = Field(default=None)
+
+
+class EntityRecordsBatchResponse(BaseModel):
+    """Model representing a batch response of entity records."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    success_records: List[EntityRecord] = Field(
+        default_factory=list, alias="successRecords"
+    )
+    failure_records: List[FailureRecord] = Field(
+        default_factory=list, alias="failureRecords"
+    )
+
+
+class EntityRecordsListResponse(List[EntityRecord]):
+    """List of EntityRecord with pagination metadata.
+
+    Subclasses ``list`` so existing call sites that iterate, index, or call
+    ``len()`` continue to work; new fields ``total_count``, ``has_next_page``,
+    and ``next_cursor`` expose pagination information returned by the backend.
+    """
+
+    def __init__(
+        self,
+        items: Optional[List[EntityRecord]] = None,
+        total_count: int = 0,
+        has_next_page: bool = False,
+        next_cursor: Optional[str] = None,
+    ) -> None:
+        """Construct from a list of records plus pagination metadata."""
+        super().__init__(items or [])
+        self.total_count = total_count
+        self.has_next_page = has_next_page
+        self.next_cursor = next_cursor
+
+
+class LogicalOperator(IntEnum):
+    """Logical operator for combining query filter groups."""
+
+    And = 0
+    Or = 1
+
+
+class QueryFilterOperator(str, Enum):
+    """Comparison operators supported by the structured query API."""
+
+    Equals = "="
+    NotEquals = "!="
+    GreaterThan = ">"
+    LessThan = "<"
+    GreaterThanOrEqual = ">="
+    LessThanOrEqual = "<="
+    Contains = "contains"
+    NotContains = "not contains"
+    StartsWith = "startswith"
+    EndsWith = "endswith"
+    In = "in"
+    NotIn = "not in"
+
+
+class EntityQueryFilter(BaseModel):
+    """A single filter condition for querying entity records.
+
+    Backend operator/operand rules:
+
+    * ``in`` / ``not in`` — require a non-empty ``value_list`` and reject
+      ``value``.
+    * ``=`` / ``!=`` — allow a null ``value`` (becomes ``IS NULL`` / ``IS
+      NOT NULL``) and reject ``value_list``.
+    * All other operators (``>``, ``<``, ``>=``, ``<=``, ``contains``,
+      ``not contains``, ``startswith``, ``endswith``) — require a non-null
+      ``value`` and reject ``value_list``.
+    """
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+    field_name: str = Field(alias="fieldName")
+    operator: QueryFilterOperator
+    value: Optional[str] = None
+    value_list: Optional[List[str]] = Field(default=None, alias="valueList")
+
+    @model_validator(mode="after")
+    def _check_operator_operands(self) -> "EntityQueryFilter":
+        """Reject operator/operand combinations the backend rejects.
+
+        Implements the same rules the Data Service ``SelectQueryBuilder``
+        enforces server-side, so callers see a clear local error instead of
+        an opaque HTTP 400.
+        """
+        op = self.operator
+        if op in (QueryFilterOperator.In, QueryFilterOperator.NotIn):
+            if not self.value_list:
+                raise ValueError(
+                    f"Operator {op.value!r} requires a non-empty value_list."
+                )
+            if self.value is not None:
+                raise ValueError(
+                    f"Operator {op.value!r} uses value_list; value must be omitted."
+                )
+            return self
+
+        if self.value_list is not None:
+            raise ValueError(
+                f"Operator {op.value!r} uses value; value_list must be omitted."
+            )
+        if (
+            op not in (QueryFilterOperator.Equals, QueryFilterOperator.NotEquals)
+            and self.value is None
+        ):
+            raise ValueError(f"Operator {op.value!r} requires a non-null value.")
+        return self
+
+
+class EntityQueryFilterGroup(BaseModel):
+    """A group of query filters combined with a logical operator."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+    logical_operator: Optional[LogicalOperator] = Field(
+        default=None, alias="logicalOperator"
+    )
+    continue_logical_operator: Optional[LogicalOperator] = Field(
+        default=None, alias="continueLogicalOperator"
+    )
+    query_filters: Optional[List[EntityQueryFilter]] = Field(
+        default=None, alias="queryFilters"
+    )
+    filter_groups: Optional[List["EntityQueryFilterGroup"]] = Field(
+        default=None, alias="filterGroups"
+    )
+
+
+class EntityQuerySortOption(BaseModel):
+    """Sort option for query results."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+    field_name: str = Field(alias="fieldName")
+    is_descending: Optional[bool] = Field(default=None, alias="isDescending")
+
+
+class EntityAggregateFunction(str, Enum):
+    """Aggregate functions supported by the Data Fabric query API."""
+
+    Count = "COUNT"
+    Sum = "SUM"
+    Avg = "AVG"
+    Min = "MIN"
+    Max = "MAX"
+
+
+class EntityAggregate(BaseModel):
+    """A single aggregate expression to apply during a query."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+    function: EntityAggregateFunction
+    field: str
+    alias: Optional[str] = None
+
+
+class EntityJoin(BaseModel):
+    """Multi-entity JOIN definition for cross-entity queries."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    entity_name: Optional[str] = Field(default=None, alias="entityName")
+    join_type: Optional[str] = Field(default=None, alias="joinType")
+    join_field_name: Optional[str] = Field(default=None, alias="joinFieldName")
+    related_entity_name: Optional[str] = Field(default=None, alias="relatedEntityName")
+    related_field_name: Optional[str] = Field(default=None, alias="relatedFieldName")
+
+
+class EntityBinning(BaseModel):
+    """A binning (GROUP BY/aggregation) clause for V2 query endpoint."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    field_name: Optional[str] = Field(default=None, alias="fieldName")
+    aggregate_function: Optional[EntityAggregateFunction] = Field(
+        default=None, alias="aggregateFunction"
+    )
+    alias: Optional[str] = None
+
+
+class AggregateRow(BaseModel):
+    """A row returned by aggregate / group-by / binning queries.
+
+    Aggregate rows do not have an ``Id`` field; columns vary by query
+    (``selected_fields``, ``aggregates`` aliases, binning aliases) and are
+    accessible as attributes via ``extra="allow"``.
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class RetrieveEntityRecordsResponse(BaseModel):
+    """Response from :meth:`EntitiesService.retrieve_records`.
+
+    For plain queries, ``items`` is a list of :class:`EntityRecord`. When the
+    query uses ``aggregates``, ``group_by``, or ``binnings``, the backend
+    returns rows without an ``Id`` field; those rows are parsed as
+    :class:`AggregateRow` instances.
+    """
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+    items: List[EntityRecord | AggregateRow] = Field(default_factory=list)
+    total_count: int = Field(default=0, alias="totalCount")
+    has_next_page: bool = Field(default=False, alias="hasNextPage")
+    next_cursor: Optional[str] = Field(default=None, alias="nextCursor")
+
+    def __iter__(self) -> Iterator[EntityRecord | AggregateRow]:  # type: ignore[override]
+        """Iterate over records (delegates to ``self.items``)."""
+        return iter(self.items)
+
+    def __len__(self) -> int:
+        """Return the number of records (delegates to ``self.items``)."""
+        return len(self.items)
+
+    @overload
+    def __getitem__(self, index: int) -> EntityRecord | AggregateRow: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> List[EntityRecord | AggregateRow]: ...
+
+    def __getitem__(
+        self, index: int | slice
+    ) -> EntityRecord | AggregateRow | List[EntityRecord | AggregateRow]:
+        """Index or slice records (delegates to ``self.items``)."""
+        return self.items[index]
+
+
+class EntityFieldDataType(str, Enum):
+    """User-facing entity field data type names accepted by ``create_entity``."""
+
+    UUID = "UUID"
+    STRING = "STRING"
+    INTEGER = "INTEGER"
+    DATETIME = "DATETIME"
+    DATETIME_WITH_TZ = "DATETIME_WITH_TZ"
+    DECIMAL = "DECIMAL"
+    FLOAT = "FLOAT"
+    DOUBLE = "DOUBLE"
+    DATE = "DATE"
+    BOOLEAN = "BOOLEAN"
+    BIG_INTEGER = "BIG_INTEGER"
+    MULTILINE_TEXT = "MULTILINE_TEXT"
+    FILE = "FILE"
+    CHOICE_SET_SINGLE = "CHOICE_SET_SINGLE"
+    CHOICE_SET_MULTIPLE = "CHOICE_SET_MULTIPLE"
+    AUTO_NUMBER = "AUTO_NUMBER"
+    RELATIONSHIP = "RELATIONSHIP"
+
+
+# Maps the user-facing EntityFieldDataType to the ``(sqlType.name, fieldDisplayType)``
+# tuple expected by the backend when creating an entity. ``sqlType.name`` is
+# the raw SQL Server type the backend persists; ``fieldDisplayType`` controls
+# how the field renders in the UI.
+ENTITY_SCHEMA_FIELD_TYPE_MAP: Dict[EntityFieldDataType, "tuple[str, str]"] = {
+    EntityFieldDataType.UUID: ("UNIQUEIDENTIFIER", "Basic"),
+    EntityFieldDataType.STRING: ("NVARCHAR", "Basic"),
+    EntityFieldDataType.INTEGER: ("INT", "Basic"),
+    EntityFieldDataType.DATETIME: ("DATETIME2", "Basic"),
+    EntityFieldDataType.DATETIME_WITH_TZ: ("DATETIMEOFFSET", "Basic"),
+    EntityFieldDataType.DECIMAL: ("DECIMAL", "Basic"),
+    EntityFieldDataType.FLOAT: ("FLOAT", "Basic"),
+    EntityFieldDataType.DOUBLE: ("REAL", "Basic"),
+    EntityFieldDataType.DATE: ("DATE", "Basic"),
+    EntityFieldDataType.BOOLEAN: ("BIT", "Basic"),
+    EntityFieldDataType.BIG_INTEGER: ("BIGINT", "Basic"),
+    EntityFieldDataType.MULTILINE_TEXT: ("MULTILINE", "Basic"),
+    EntityFieldDataType.FILE: ("UNIQUEIDENTIFIER", "File"),
+    EntityFieldDataType.CHOICE_SET_SINGLE: ("INT", "ChoiceSetSingle"),
+    EntityFieldDataType.CHOICE_SET_MULTIPLE: ("NVARCHAR", "ChoiceSetMultiple"),
+    EntityFieldDataType.AUTO_NUMBER: ("DECIMAL", "AutoNumber"),
+    EntityFieldDataType.RELATIONSHIP: ("UNIQUEIDENTIFIER", "Relationship"),
+}
+
+# Default and fixed sqlType constraint values applied when the caller does
+# not supply them. The backend requires these on field creation — without
+# them the field is stored in an incomplete state and the UI later fails
+# with "Field type cannot be changed" when editing advanced options.
+ENTITY_FIELD_CONSTRAINT_DEFAULTS: Dict[str, int] = {
+    "STRING_LENGTH_LIMIT": 200,
+    "MULTILINE_TEXT_LENGTH_LIMIT": 200,
+    "DECIMAL_LENGTH_LIMIT": 1000,
+    "DECIMAL_PRECISION": 2,
+    "BOOLEAN_LENGTH_LIMIT": 100,
+    "DATE_LENGTH_LIMIT": 1000,
+    "UNIQUEIDENTIFIER_LENGTH_LIMIT": 300,
+    "CHOICE_SET_MULTIPLE_LENGTH_LIMIT": 4000,
+    "NUMERIC_MAX_VALUE": 1_000_000_000_000,
+    "NUMERIC_MIN_VALUE": -1_000_000_000_000,
+}
+
+# Per-field-type spec describing which user-supplied constraints are valid
+# and their inclusive ranges. Field types absent from this map (BOOLEAN,
+# DATE, DATETIME, DATETIME_WITH_TZ, FILE, RELATIONSHIP, UUID, CHOICE_SET_*,
+# AUTO_NUMBER) accept no user-supplied constraints — passing one raises
+# ``ValueError`` so the caller gets a clear local error before any HTTP call.
+_MAX_SAFE_INTEGER = 9_007_199_254_740_991
+
+ENTITY_FIELD_CONSTRAINT_SPEC: Dict[
+    EntityFieldDataType, Dict[str, "tuple[int, int]"]
+] = {
+    EntityFieldDataType.STRING: {
+        "length_limit": (1, 4000),
+    },
+    EntityFieldDataType.MULTILINE_TEXT: {
+        "length_limit": (1, 10000),
+    },
+    EntityFieldDataType.INTEGER: {
+        "max_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "min_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+    },
+    EntityFieldDataType.BIG_INTEGER: {
+        "max_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "min_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+    },
+    EntityFieldDataType.DECIMAL: {
+        "max_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "min_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "decimal_precision": (0, 10),
+    },
+    EntityFieldDataType.FLOAT: {
+        "max_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "min_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "decimal_precision": (0, 10),
+    },
+    EntityFieldDataType.DOUBLE: {
+        "max_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "min_value": (-_MAX_SAFE_INTEGER, _MAX_SAFE_INTEGER),
+        "decimal_precision": (0, 10),
+    },
+}
+
+RESERVED_FIELD_NAMES = frozenset(
+    ["Id", "CreatedBy", "CreateTime", "UpdatedBy", "UpdateTime"]
+)
+"""Field names reserved by the backend — using one as a user field name is rejected."""
+
+
+class EntityCreateFieldOptions(BaseModel):
+    """User-facing field definition for creating or updating entity schemas."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    field_name: str = Field(alias="fieldName")
+    type: Optional[EntityFieldDataType] = Field(
+        default=EntityFieldDataType.STRING, alias="type"
+    )
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+    description: Optional[str] = None
+    is_required: Optional[bool] = Field(default=None, alias="isRequired")
+    is_unique: Optional[bool] = Field(default=None, alias="isUnique")
+    is_rbac_enabled: Optional[bool] = Field(default=None, alias="isRbacEnabled")
+    is_encrypted: Optional[bool] = Field(default=None, alias="isEncrypted")
+    default_value: Optional[str] = Field(default=None, alias="defaultValue")
+    length_limit: Optional[int] = Field(default=None, alias="lengthLimit")
+    max_value: Optional[int] = Field(default=None, alias="maxValue")
+    min_value: Optional[int] = Field(default=None, alias="minValue")
+    decimal_precision: Optional[int] = Field(default=None, alias="decimalPrecision")
+    choice_set_id: Optional[str] = Field(default=None, alias="choiceSetId")
+    reference_entity_name: Optional[str] = Field(
+        default=None, alias="referenceEntityName"
+    )
+    reference_field_name: Optional[str] = Field(
+        default=None, alias="referenceFieldName"
+    )
+
+
+class EntityCreateOptions(BaseModel):
+    """Options for creating a new Data Fabric entity."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+    description: Optional[str] = None
+    folder_key: Optional[str] = Field(default=None, alias="folderKey")
+    is_rbac_enabled: Optional[bool] = Field(default=None, alias="isRbacEnabled")
+    is_analytics_enabled: Optional[bool] = Field(
+        default=None, alias="isAnalyticsEnabled"
+    )
+    external_fields: Optional[List[Dict[str, Any]]] = Field(
+        default=None, alias="externalFields"
+    )
+
+
+class EntityMetadataUpdateOptions(BaseModel):
+    """Options for updating an entity's metadata via PATCH /metadata."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+    description: Optional[str] = None
+    is_rbac_enabled: Optional[bool] = Field(default=None, alias="isRbacEnabled")
+
+
+class EntityImportRecordsResponse(BaseModel):
+    """Response from a bulk import operation."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    total_records: int = Field(default=0, alias="totalRecords")
+    inserted_records: int = Field(default=0, alias="insertedRecords")
+    error_file_link: Optional[str] = Field(default=None, alias="errorFileLink")
+
+
+class EntityRouting(BaseModel):
+    """A single entity-to-folder routing entry for query execution."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    entity_name: str = Field(alias="entityName")
+    folder_id: str = Field(alias="folderId")
+    override_entity_name: Optional[str] = Field(
+        default=None, alias="overrideEntityName"
+    )
+
+
+class QueryRoutingOverrideContext(BaseModel):
+    """Routing context that maps entities to their folders for multi-entity queries."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    entity_routings: List[EntityRouting] = Field(alias="entityRoutings")
+
+
+class DataFabricEntityItem(BaseModel):
+    """A single Data Fabric entity reference from agent configuration."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    id: str
+    entity_key: Optional[str] = Field(None, alias="referenceKey")
+    name: str
+    folder_key: str = Field(alias="folderId")
+    description: Optional[str] = None
+
+
+class EntitySetResolution(BaseModel):
+    """Result of resolving an agent entity set with overwrites applied."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    entities: list[Entity]
+    entities_service: EntitiesService
+
+
+Entity.model_rebuild()
+EntityQueryFilterGroup.model_rebuild()
diff --git a/packages/uipath-platform/src/uipath/platform/errors/__init__.py b/packages/uipath-platform/src/uipath/platform/errors/__init__.py
new file mode 100644
index 000000000..97f7e6d98
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/__init__.py
@@ -0,0 +1,46 @@
+"""UiPath Platform Errors.
+
+This module contains all exception classes used by the UiPath Platform SDK.
+
+Available exceptions:
+- BaseUrlMissingError: Raised when base URL is not configured
+- SecretMissingError: Raised when access token is not configured
+- FolderNotFoundException: Raised when a folder cannot be found
+- UnsupportedDataSourceException: Raised when an operation is attempted on an unsupported data source type
+- IngestionInProgressException: Raised when a search is attempted on an index during ingestion
+- ContextGroundingIndexNotFoundError: Raised when a context grounding index cannot be resolved by name
+- BatchTransformFailedException: Raised when a batch transform has failed
+- BatchTransformNotCompleteException: Raised when attempting to get results from an incomplete batch transform
+- OperationNotCompleteException: Raised when attempting to get results from an incomplete operation
+- OperationFailedException: Raised when an operation has failed
+- EnrichedException: Enriched HTTP error with detailed request/response information
+"""
+
+from ._base_url_missing_error import BaseUrlMissingError
+from ._batch_transform_failed_exception import BatchTransformFailedException
+from ._batch_transform_not_complete_exception import BatchTransformNotCompleteException
+from ._context_grounding_index_not_found_exception import (
+    ContextGroundingIndexNotFoundError,
+)
+from ._enriched_exception import EnrichedException, ExtractedErrorInfo
+from ._folder_not_found_exception import FolderNotFoundException
+from ._ingestion_in_progress_exception import IngestionInProgressException
+from ._operation_failed_exception import OperationFailedException
+from ._operation_not_complete_exception import OperationNotCompleteException
+from ._secret_missing_error import SecretMissingError
+from ._unsupported_data_source_exception import UnsupportedDataSourceException
+
+__all__ = [
+    "BaseUrlMissingError",
+    "BatchTransformFailedException",
+    "BatchTransformNotCompleteException",
+    "ContextGroundingIndexNotFoundError",
+    "EnrichedException",
+    "ExtractedErrorInfo",
+    "FolderNotFoundException",
+    "IngestionInProgressException",
+    "OperationFailedException",
+    "OperationNotCompleteException",
+    "SecretMissingError",
+    "UnsupportedDataSourceException",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_base_url_missing_error.py b/packages/uipath-platform/src/uipath/platform/errors/_base_url_missing_error.py
new file mode 100644
index 000000000..db4c8efbd
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_base_url_missing_error.py
@@ -0,0 +1,13 @@
+class BaseUrlMissingError(Exception):
+    """Raised when base URL is not configured.
+
+    This exception is raised when attempting to use the SDK without setting
+    the base URL via the UIPATH_URL environment variable or through authentication.
+    """
+
+    def __init__(
+        self,
+        message="Authentication required. Please run \033[1muipath auth\033[22m or set the base URL via the UIPATH_URL environment variable.",
+    ):
+        self.message = message
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_failed_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_failed_exception.py
new file mode 100644
index 000000000..67088b0f1
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_failed_exception.py
@@ -0,0 +1,10 @@
+class BatchTransformFailedException(Exception):
+    """Raised when a batch transform has failed.
+
+    This exception is raised when a batch transform task has completed
+    with a failed status, as opposed to still being in progress.
+    """
+
+    def __init__(self, batch_transform_id: str):
+        self.message = f"Batch transform '{batch_transform_id}' failed."
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_not_complete_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_not_complete_exception.py
new file mode 100644
index 000000000..8b8956923
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_batch_transform_not_complete_exception.py
@@ -0,0 +1,13 @@
+class BatchTransformNotCompleteException(Exception):
+    """Raised when attempting to get results from an incomplete batch transform.
+
+    This exception is raised when attempting to download results from a batch
+    transform task that has not yet completed successfully.
+    """
+
+    def __init__(self, batch_transform_id: str, status: str):
+        self.message = (
+            f"Batch transform '{batch_transform_id}' is not complete. "
+            f"Current status: {status}"
+        )
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_context_grounding_index_not_found_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_context_grounding_index_not_found_exception.py
new file mode 100644
index 000000000..653be92e8
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_context_grounding_index_not_found_exception.py
@@ -0,0 +1,13 @@
+from typing import Optional
+
+
+class ContextGroundingIndexNotFoundError(Exception):
+    """Raised when a context grounding index cannot be resolved by name."""
+
+    def __init__(self, index_name: Optional[str] = None):
+        self.index_name = index_name
+        if index_name:
+            self.message = f"ContextGroundingIndex '{index_name}' not found"
+        else:
+            self.message = "ContextGroundingIndex not found"
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_enriched_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_enriched_exception.py
new file mode 100644
index 000000000..613518ddc
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_enriched_exception.py
@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from functools import cached_property
+
+from httpx import HTTPStatusError
+
+
+@dataclass(frozen=True)
+class ExtractedErrorInfo:
+    message: str | None = None
+    error_code: str | None = None
+    trace_id: str | None = None
+
+
+class EnrichedException(Exception):
+    """Enriched HTTP error with detailed request/response information.
+
+    Wraps HTTPStatusError with URL, method, status code, and truncated response
+    content in __str__. For structured error fields, use ``error_info`` which
+    delegates to per-service extractors.
+
+    Does not retain a reference to the original HTTPStatusError — all needed
+    data is eagerly extracted. Callers needing the raw response can still
+    access ``__cause__`` (set by ``raise EnrichedException(e) from e``).
+    """
+
+    def __init__(self, error: HTTPStatusError) -> None:
+        # while status code 0 is the correct one according to http standard;
+        # it has a totally oposite meaning as return codes in CLIs;
+        # opted for -1 to avoid confusion
+        self.status_code: int = error.response.status_code if error.response else -1
+        self.url: str = str(error.request.url) if error.request else "Unknown"
+        self.http_method: str = (
+            error.request.method
+            if error.request and error.request.method
+            else "Unknown"
+        )
+
+        self._response_body: str | None = None
+        self._content_type: str | None = None
+        if error.response is not None:
+            self._content_type = error.response.headers.get("content-type")
+            if error.response.content:
+                try:
+                    self._response_body = error.response.content.decode("utf-8")
+                except Exception:
+                    pass
+
+        max_content_length = 200
+        if self._response_body:
+            if len(self._response_body) > max_content_length:
+                self.response_content = (
+                    self._response_body[:max_content_length] + "... (truncated)"
+                )
+            else:
+                self.response_content = self._response_body
+        else:
+            self.response_content = "No content"
+
+        enriched_message = (
+            f"\nRequest URL: {self.url}"
+            f"\nHTTP Method: {self.http_method}"
+            f"\nStatus Code: {self.status_code}"
+            f"\nResponse Content: {self.response_content}"
+        )
+
+        super().__init__(enriched_message)
+
+    @cached_property
+    def error_info(self) -> ExtractedErrorInfo | None:
+        """Service-aware extraction of message, error_code, trace_id."""
+        from ._extractors._router import extract_error_info
+
+        if not self._response_body:
+            return None
+        return extract_error_info(self.url, self._response_body, self._content_type)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_agenthub.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_agenthub.py
new file mode 100644
index 000000000..fb8b45d8a
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_agenthub.py
@@ -0,0 +1,24 @@
+"""AgentHub / AgentsRuntime error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_typed_field
+
+
+def extract_agenthub(body: dict[str, Any]) -> ExtractedErrorInfo:
+    message = get_typed_field(body, str, "message", "title")
+    error_code = get_typed_field(body, str, "errorCode", "code")
+    trace_id = get_typed_field(body, str, "traceId")
+
+    problem = get_typed_field(body, dict, "problem")
+    if problem is not None:
+        message = message or get_typed_field(problem, str, "detail", "title")
+        error_code = error_code or get_typed_field(problem, str, "errorCode", "type")
+        trace_id = trace_id or get_typed_field(problem, str, "traceId")
+
+    return ExtractedErrorInfo(
+        message=message,
+        error_code=error_code,
+        trace_id=trace_id,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_apps.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_apps.py
new file mode 100644
index 000000000..59b2476a1
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_apps.py
@@ -0,0 +1,14 @@
+"""Apps service error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_typed_field
+
+
+def extract_apps(body: dict[str, Any]) -> ExtractedErrorInfo:
+    return ExtractedErrorInfo(
+        message=get_typed_field(body, str, "errorMessageV2", "message"),
+        error_code=get_typed_field(body, str, "errorCode", "code"),
+        trace_id=get_typed_field(body, str, "traceId"),
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_elements.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_elements.py
new file mode 100644
index 000000000..8c75399d8
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_elements.py
@@ -0,0 +1,20 @@
+"""Elements service error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_str_field, get_typed_field
+
+
+def extract_elements(body: dict[str, Any]) -> ExtractedErrorInfo:
+    message = get_typed_field(body, str, "providerMessage") or get_typed_field(
+        body, str, "message"
+    )
+    error_code = get_str_field(body, "providerErrorCode", "status")
+    trace_id = get_typed_field(body, str, "requestId")
+
+    return ExtractedErrorInfo(
+        message=message,
+        error_code=error_code,
+        trace_id=trace_id,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_generic.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_generic.py
new file mode 100644
index 000000000..d089186fc
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_generic.py
@@ -0,0 +1,35 @@
+"""Generic fallback error payload extractor.
+
+Tries structural RFC 7807 detection first, then common field patterns
+covering Orchestrator, Connections, ECS, and most other services.
+"""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_field, get_str_field, get_typed_field
+from ._rfc7807 import extract_rfc7807, looks_like_rfc7807
+
+
+def extract_generic(body: dict[str, Any]) -> ExtractedErrorInfo:
+    if looks_like_rfc7807(body):
+        return extract_rfc7807(body)
+
+    message: str | None
+    error = get_field(body, "error")
+    if isinstance(error, str):
+        message = error
+    elif isinstance(error, dict):
+        message = get_typed_field(error, str, "message")
+    else:
+        message = get_typed_field(body, str, "message")
+
+    # str() conversion handles services that return numeric error codes
+    error_code = get_str_field(body, "errorCode", "code")
+    trace_id = get_typed_field(body, str, "traceId", "requestId")
+
+    return ExtractedErrorInfo(
+        message=message,
+        error_code=error_code,
+        trace_id=trace_id,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_helpers.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_helpers.py
new file mode 100644
index 000000000..290f3d5e0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_helpers.py
@@ -0,0 +1,63 @@
+"""Shared helpers for error payload extractors."""
+
+from typing import Any, TypeVar
+from urllib.parse import urlparse
+
+T = TypeVar("T")
+
+
+def get_field(body: dict[str, Any], *keys: str) -> Any:
+    """Return the first non-None value found for the given keys.
+
+    Automatically tries both camelCase and PascalCase for each key.
+    """
+    for key in keys:
+        val = body.get(key)
+        if val is not None:
+            return val
+        val = body.get(key[0].swapcase() + key[1:])
+        if val is not None:
+            return val
+    return None
+
+
+def get_typed_field(body: dict[str, Any], type_: type[T], *keys: str) -> T | None:
+    """Return the first non-None value matching *type_* for the given keys.
+
+    Skips values that don't match the expected type, trying the next key.
+    """
+    for key in keys:
+        val = body.get(key)
+        if val is None:
+            val = body.get(key[0].swapcase() + key[1:])
+        if isinstance(val, type_):
+            return val
+    return None
+
+
+def get_str_field(body: dict[str, Any], *keys: str) -> str | None:
+    """Return the first scalar value for the given keys, converted to str.
+
+    Skips dicts, lists, and None.
+    """
+    for key in keys:
+        val = body.get(key)
+        if val is None:
+            val = body.get(key[0].swapcase() + key[1:])
+        if val is not None and not isinstance(val, (dict, list)):
+            return str(val)
+    return None
+
+
+def extract_service_prefix(url: str) -> str | None:
+    """Extract the service prefix (e.g. 'orchestrator_') from a UiPath URL path."""
+    path = urlparse(url).path if "://" in url else url
+    for segment in path.strip("/").split("/"):
+        if segment.endswith("_") and len(segment) > 1:
+            return segment
+    return None
+
+
+def is_llm_path(url: str) -> bool:
+    """Check if the URL targets the LLM Gateway."""
+    return "/llm/" in url
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llm_gateway.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llm_gateway.py
new file mode 100644
index 000000000..fd62d0e46
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llm_gateway.py
@@ -0,0 +1,23 @@
+"""LLM Gateway error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_typed_field
+
+
+def extract_llm_gateway(body: dict[str, Any]) -> ExtractedErrorInfo:
+    message = get_typed_field(body, str, "message")
+    error_code = get_typed_field(body, str, "errorCode", "code")
+    trace_id = get_typed_field(body, str, "traceId")
+
+    error = get_typed_field(body, dict, "error")
+    if error is not None:
+        message = message or get_typed_field(error, str, "message")
+        error_code = error_code or get_typed_field(error, str, "code", "type")
+
+    return ExtractedErrorInfo(
+        message=message,
+        error_code=error_code,
+        trace_id=trace_id,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llmops.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llmops.py
new file mode 100644
index 000000000..20af23c56
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_llmops.py
@@ -0,0 +1,14 @@
+"""LLMOps service error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_typed_field
+
+
+def extract_llmops(body: dict[str, Any]) -> ExtractedErrorInfo:
+    return ExtractedErrorInfo(
+        message=get_typed_field(body, str, "errorMessage"),
+        error_code=get_typed_field(body, str, "code"),
+        trace_id=get_typed_field(body, str, "requestId"),
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_rfc7807.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_rfc7807.py
new file mode 100644
index 000000000..d8bc768db
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_rfc7807.py
@@ -0,0 +1,46 @@
+"""RFC 7807 Problem Details error payload extractor."""
+
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._helpers import get_typed_field
+
+_RFC7807_CONTENT_TYPES = frozenset(
+    {
+        "application/problem+json",
+        "application/problem+xml",
+    }
+)
+
+
+_RFC7807_REQUIRED = {"detail", "title"}
+_RFC7807_SUPPORTING = {"type", "status", "instance"}
+
+
+def is_rfc7807_content_type(content_type: str | None) -> bool:
+    """Check if the content type indicates an RFC 7807 response."""
+    if not content_type:
+        return False
+    return content_type.split(";")[0].strip().lower() in _RFC7807_CONTENT_TYPES
+
+
+def looks_like_rfc7807(body: dict[str, Any]) -> bool:
+    """Structural heuristic: has detail/title + at least 2 RFC 7807 keys."""
+    keys = body.keys()
+    has_required = bool(_RFC7807_REQUIRED & keys)
+    supporting_count = len((_RFC7807_REQUIRED | _RFC7807_SUPPORTING) & keys)
+    return has_required and supporting_count >= 2
+
+
+def extract_rfc7807(body: dict[str, Any]) -> ExtractedErrorInfo:
+    message = get_typed_field(body, str, "detail") or get_typed_field(
+        body, str, "title"
+    )
+    error_code = get_typed_field(body, str, "type")
+    trace_id = get_typed_field(body, str, "traceId", "instance")
+
+    return ExtractedErrorInfo(
+        message=message,
+        error_code=error_code,
+        trace_id=trace_id,
+    )
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_extractors/_router.py b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_router.py
new file mode 100644
index 000000000..37369113b
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_extractors/_router.py
@@ -0,0 +1,66 @@
+"""Routes HTTP error payloads to the appropriate service extractor.
+
+Priority:
+1. RFC 7807 via content-type (authoritative)
+2. LLM Gateway via URL path (/llm/)
+3. Dedicated service extractor via URL prefix
+4. Generic fallback (structural RFC 7807 + common fields)
+"""
+
+import json
+from collections.abc import Callable
+from typing import Any
+
+from .._enriched_exception import ExtractedErrorInfo
+from ._agenthub import extract_agenthub
+from ._apps import extract_apps
+from ._elements import extract_elements
+from ._generic import extract_generic
+from ._helpers import extract_service_prefix, is_llm_path
+from ._llm_gateway import extract_llm_gateway
+from ._llmops import extract_llmops
+from ._rfc7807 import extract_rfc7807, is_rfc7807_content_type
+
+_Extractor = Callable[[dict[str, Any]], ExtractedErrorInfo]
+
+# Only services with extraction logic that differs from generic.
+# All other services (orchestrator, connections, ecs, etc.) fall through to generic.
+_SERVICE_EXTRACTORS: dict[str, _Extractor] = {
+    "agenthub_": extract_agenthub,
+    "agentsruntime_": extract_agenthub,
+    "apps_": extract_apps,
+    "elements_": extract_elements,
+    "llmopstenant_": extract_llmops,
+}
+
+
+def extract_error_info(
+    url: str,
+    body: str,
+    content_type: str | None = None,
+) -> ExtractedErrorInfo | None:
+    """Parse an HTTP error response body into structured error info.
+
+    Returns None if the body cannot be parsed as JSON.
+    """
+    try:
+        parsed: dict[str, Any] = json.loads(body)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+    if not isinstance(parsed, dict):
+        return None
+
+    if is_rfc7807_content_type(content_type):
+        return extract_rfc7807(parsed)
+
+    if is_llm_path(url):
+        return extract_llm_gateway(parsed)
+
+    prefix = extract_service_prefix(url)
+    if prefix is not None:
+        extractor = _SERVICE_EXTRACTORS.get(prefix)
+        if extractor is not None:
+            return extractor(parsed)
+
+    return extract_generic(parsed)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_folder_not_found_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_folder_not_found_exception.py
new file mode 100644
index 000000000..b5daa8005
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_folder_not_found_exception.py
@@ -0,0 +1,13 @@
+class FolderNotFoundException(Exception):
+    """Raised when a folder cannot be found.
+
+    This exception is raised when attempting to access a folder that does not exist
+    in the UiPath Orchestrator.
+    """
+
+    def __init__(
+        self,
+        folder_name,
+    ):
+        self.message = f"Folder {folder_name} not found."
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_ingestion_in_progress_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_ingestion_in_progress_exception.py
new file mode 100644
index 000000000..d0a093719
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_ingestion_in_progress_exception.py
@@ -0,0 +1,17 @@
+from typing import Optional
+
+
+class IngestionInProgressException(Exception):
+    """Raised when a search is attempted on an index during ingestion.
+
+    This exception is raised when attempting to search an index that is currently
+    undergoing ingestion and is not yet available for queries.
+    """
+
+    def __init__(self, index_name: Optional[str], search_operation: bool = True):
+        index_name = index_name or "Unknown index name"
+        if search_operation:
+            self.message = f"index '{index_name}' cannot be searched during ingestion"
+        else:
+            self.message = f"index '{index_name}' is currently queued for ingestion"
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_operation_failed_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_operation_failed_exception.py
new file mode 100644
index 000000000..216ef7d24
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_operation_failed_exception.py
@@ -0,0 +1,19 @@
+class OperationFailedException(Exception):
+    """Raised when attempting to get results from a failed operation.
+
+    This exception is raised when attempting to retrieve results from operation
+    that failed to complete successfully.
+    """
+
+    def __init__(
+        self,
+        operation_id: str,
+        status: str,
+        error: str,
+        operation_name: str = "Operation",
+    ):
+        self.operation_id = operation_id
+        self.status = status
+        self.error = error
+        self.message = f"{operation_name} '{operation_id}' failed with status: {status} error: {error}"
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_operation_not_complete_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_operation_not_complete_exception.py
new file mode 100644
index 000000000..50941353c
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_operation_not_complete_exception.py
@@ -0,0 +1,14 @@
+class OperationNotCompleteException(Exception):
+    """Raised when attempting to get results from an incomplete operation.
+
+    This exception is raised when attempting to retrieve results from operation
+    that has not yet completed successfully.
+    """
+
+    def __init__(
+        self, operation_id: str, status: str, operation_name: str = "Operation"
+    ):
+        self.operation_id = operation_id
+        self.status = status
+        self.message = f"{operation_name} '{operation_id}' is not complete. Current status: {status}"
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_secret_missing_error.py b/packages/uipath-platform/src/uipath/platform/errors/_secret_missing_error.py
new file mode 100644
index 000000000..e03ed3c51
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_secret_missing_error.py
@@ -0,0 +1,13 @@
+class SecretMissingError(Exception):
+    """Raised when access token is not configured.
+
+    This exception is raised when attempting to use the SDK without setting
+    the access token via the UIPATH_ACCESS_TOKEN environment variable or through authentication.
+    """
+
+    def __init__(
+        self,
+        message="Authentication required. Please run \033[1muipath auth\033[22m or set the UIPATH_ACCESS_TOKEN environment variable to a valid access token.",
+    ):
+        self.message = message
+        super().__init__(self.message)
diff --git a/packages/uipath-platform/src/uipath/platform/errors/_unsupported_data_source_exception.py b/packages/uipath-platform/src/uipath/platform/errors/_unsupported_data_source_exception.py
new file mode 100644
index 000000000..0f9c30fe9
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/errors/_unsupported_data_source_exception.py
@@ -0,0 +1,17 @@
+from typing import Optional
+
+
+class UnsupportedDataSourceException(Exception):
+    """Raised when an operation is attempted on an unsupported data source type.
+
+    This exception is raised when attempting to use an operation that only supports
+    specific data source types (e.g., Orchestrator Storage Bucket) with an incompatible
+    data source.
+    """
+
+    def __init__(self, operation: str, data_source_type: Optional[str] = None):
+        if data_source_type:
+            message = f"Operation '{operation}' is not supported for data source type: {data_source_type}. Only Orchestrator Storage Bucket data sources are supported."
+        else:
+            message = f"Operation '{operation}' requires an Orchestrator Storage Bucket data source."
+        super().__init__(message)
diff --git a/packages/uipath-platform/src/uipath/platform/governance/__init__.py b/packages/uipath-platform/src/uipath/platform/governance/__init__.py
new file mode 100644
index 000000000..e1f587606
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/governance/__init__.py
@@ -0,0 +1,20 @@
+"""Governance services for the UiPath Platform.
+
+Exposes the agenticgovernance_ ingress: tenant-controlled policy packs
+served centrally so policy decisions can change without redeploying
+agents.
+"""
+
+from ._governance_provider import UiPathPlatformGovernanceProvider
+from ._governance_service import GovernanceService
+from .compensate import FiredRule, GovernRequest
+from .policy import PolicyContext, PolicyResponse
+
+__all__ = [
+    "FiredRule",
+    "GovernRequest",
+    "GovernanceService",
+    "PolicyContext",
+    "PolicyResponse",
+    "UiPathPlatformGovernanceProvider",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/governance/_governance_provider.py b/packages/uipath-platform/src/uipath/platform/governance/_governance_provider.py
new file mode 100644
index 000000000..23f1464bb
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/governance/_governance_provider.py
@@ -0,0 +1,81 @@
+"""Platform-backed implementation of the core governance provider protocols.
+
+Thin adapter around :class:`GovernanceService` that exposes only the
+methods required by
+:class:`uipath.core.governance.GovernancePolicyProvider` and
+:class:`uipath.core.governance.GovernanceCompensationProvider`.
+
+Wrap an existing :class:`GovernanceService` (e.g.
+``UiPathPlatformGovernanceProvider(service=UiPath().governance)``) or
+pass ``config``/``execution_context`` to construct one inline.
+"""
+
+from __future__ import annotations
+
+from uipath.core.governance import GovernRequest, PolicyContext, PolicyResponse
+
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ._governance_service import GovernanceService
+
+
+class UiPathPlatformGovernanceProvider:
+    """Platform-backed governance provider.
+
+    Implements both
+    :class:`uipath.core.governance.GovernancePolicyProvider` and
+    :class:`uipath.core.governance.GovernanceCompensationProvider` by
+    delegating to :class:`GovernanceService`.
+
+    Args:
+        service: Existing :class:`GovernanceService` to delegate to.
+            Useful for tests and for sharing an SDK service across
+            consumers. When omitted, a fresh service is built from the
+            ``config`` and ``execution_context`` kwargs.
+        config: Required when ``service`` is not supplied.
+        execution_context: Required when ``service`` is not supplied.
+    """
+
+    def __init__(
+        self,
+        service: GovernanceService | None = None,
+        *,
+        config: UiPathApiConfig | None = None,
+        execution_context: UiPathExecutionContext | None = None,
+    ) -> None:
+        if service is None:
+            if config is None or execution_context is None:
+                raise ValueError(
+                    "UiPathPlatformGovernanceProvider requires either a "
+                    "GovernanceService instance or both config and "
+                    "execution_context."
+                )
+            service = GovernanceService(
+                config=config, execution_context=execution_context
+            )
+        self._service = service
+
+    @property
+    def service(self) -> GovernanceService:
+        """The underlying :class:`GovernanceService` instance."""
+        return self._service
+
+    # ── GovernancePolicyProvider ─────────────────────────────────────
+
+    def get_policy(self, context: PolicyContext) -> PolicyResponse:
+        """Fetch the policy pack — delegates to ``GovernanceService``."""
+        return self._service.get_policy(context)
+
+    async def get_policy_async(self, context: PolicyContext) -> PolicyResponse:
+        """Async variant of :meth:`get_policy`."""
+        return await self._service.get_policy_async(context)
+
+    # ── GovernanceCompensationProvider ───────────────────────────────
+
+    def compensate(self, request: GovernRequest) -> None:
+        """Fire the compensating ``/runtime/govern`` POST."""
+        self._service._compensate(request)
+
+    async def compensate_async(self, request: GovernRequest) -> None:
+        """Async variant of :meth:`compensate`."""
+        await self._service._compensate_async(request)
diff --git a/packages/uipath-platform/src/uipath/platform/governance/_governance_service.py b/packages/uipath-platform/src/uipath/platform/governance/_governance_service.py
new file mode 100644
index 000000000..5ceabf479
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/governance/_governance_service.py
@@ -0,0 +1,356 @@
+"""Service for the ``agenticgovernance_`` ingress.
+
+Wraps the two governance backend endpoints UiPath exposes:
+
+- ``GET  /{org}/agenticgovernance_/api/v1/runtime/policy``  — fetch the
+  tenant-managed policy pack (see :meth:`GovernanceService.retrieve_policy`).
+- ``POST /{org}/agenticgovernance_/api/v1/runtime/govern``  — compensating
+  governance call fired when a ``guardrail_fallback`` rule matches
+  (see :meth:`GovernanceService.compensate`).
+
+Org/tenant scoping is read from :class:`UiPathConfig`; auth, retries,
+trace context, and error enrichment come from :class:`BaseService`.
+"""
+
+from typing import Any, Optional
+
+from uipath.core import traced
+from uipath.core.governance import (
+    FiredRule,
+    GovernRequest,
+    PolicyContext,
+    PolicyResponse,
+)
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathConfig
+from ..common._service_url_overrides import (
+    inject_routing_headers,
+    resolve_service_url,
+)
+from ..common.constants import HEADER_INTERNAL_TENANT_ID
+
+# The agenticgovernance_ ingress lives at a separate org-scoped path that
+# uses the organization UUID (not the slug exposed by ``UIPATH_URL``).
+GOVERNANCE_SERVICE_PREFIX = "agenticgovernance_"
+POLICY_API_PATH = "api/v1/runtime/policy"
+GOVERN_API_PATH = "api/v1/runtime/govern"
+AGENT_TYPE_PARAM = "agentType"
+
+
+class GovernanceService(BaseService):
+    """Service for the agenticgovernance_ ingress.
+
+    Exposes two endpoints:
+
+    - :meth:`retrieve_policy` — GET the tenant-managed policy pack.
+    - :meth:`compensate` — POST a compensating ``/runtime/govern`` call
+      so the server can run a disabled centralized guardrail and write
+      the per-rule LLMOps audit records itself.
+
+    Org and tenant scoping come from :attr:`UiPathConfig.organization_id`
+    and :attr:`UiPathConfig.tenant_id`; the tenant travels in the
+    ``x-uipath-internal-tenantid`` header (the URL is org-scoped only).
+
+    !!! info "Version Availability"
+        This service is available starting from **uipath** version **2.2.13**.
+    """
+
+    # ── Policy fetch ─────────────────────────────────────────────────
+
+    @traced(name="governance_retrieve_policy", run_type="uipath")
+    def retrieve_policy(
+        self,
+        *,
+        is_conversational: Optional[bool] = None,
+    ) -> PolicyResponse:
+        """Fetch the governance policy pack for the active org/tenant.
+
+        Args:
+            is_conversational: When the hosted agent's type is known,
+                selects the conversational (``True``) or autonomous
+                (``False``) policy view. ``None`` (default) omits the
+                ``agentType`` query param so the server applies its
+                default.
+
+        Returns:
+            PolicyResponse: ``mode`` and the YAML ``policies`` string.
+
+        Raises:
+            ValueError: If ``UiPathConfig.organization_id`` or
+                ``UiPathConfig.tenant_id`` is not set.
+            EnrichedException: If the backend returns a non-2xx response.
+
+        Examples:
+            ```python
+            from uipath.platform import UiPath
+
+            client = UiPath()
+            response = client.governance.retrieve_policy()
+            print(response.mode, len(response.policies))
+            ```
+        """
+        url, headers = self._build_org_scoped_request(POLICY_API_PATH)
+        params = self._policy_params(is_conversational)
+        response = self.request("GET", url=url, params=params, headers=headers)
+        return PolicyResponse.model_validate(response.json())
+
+    @traced(name="governance_retrieve_policy", run_type="uipath")
+    async def retrieve_policy_async(
+        self,
+        *,
+        is_conversational: Optional[bool] = None,
+    ) -> PolicyResponse:
+        """Asynchronously fetch the governance policy pack.
+
+        See :meth:`retrieve_policy` for parameter and return semantics.
+        """
+        url, headers = self._build_org_scoped_request(POLICY_API_PATH)
+        params = self._policy_params(is_conversational)
+        response = await self.request_async(
+            "GET", url=url, params=params, headers=headers
+        )
+        return PolicyResponse.model_validate(response.json())
+
+    # ── Policy provider adapter (GovernancePolicyProvider protocol) ─
+
+    def get_policy(self, context: PolicyContext) -> PolicyResponse:
+        """Fetch the policy pack — :class:`GovernancePolicyProvider` adapter.
+
+        Thin wrapper over :meth:`retrieve_policy` that accepts the
+        context model the core protocol uses. Lets the runtime consume
+        governance through :class:`uipath.core.governance.GovernancePolicyProvider`
+        without importing this module.
+        """
+        return self.retrieve_policy(is_conversational=context.is_conversational)
+
+    async def get_policy_async(self, context: PolicyContext) -> PolicyResponse:
+        """Async variant of :meth:`get_policy`."""
+        return await self.retrieve_policy_async(
+            is_conversational=context.is_conversational
+        )
+
+    # ── Compensating governance call ─────────────────────────────────
+
+    def compensate(
+        self,
+        *,
+        hook: str,
+        validators: list[str],
+        rules: list[FiredRule],
+        data: dict[str, Any],
+        trace_id: str,
+        src_timestamp: str,
+        agent_name: str,
+        runtime_id: str,
+        folder_key: str | None = None,
+        job_key: str | None = None,
+        process_key: str | None = None,
+        reference_id: str | None = None,
+        agent_version: str | None = None,
+    ) -> None:
+        """POST a compensating ``/runtime/govern`` call.
+
+        Fired when a ``guardrail_fallback`` rule matches: the centralized
+        guardrail is disabled, so the server is asked to run the
+        guardrail check server-side and write the per-rule LLMOps audit
+        records bound to ``trace_id``. The agent does not inspect the
+        response body.
+
+        Job-context fields (``folder_key`` / ``job_key`` /
+        ``process_key`` / ``reference_id`` / ``agent_version``) are
+        auto-populated from :class:`UiPathConfig` when omitted.
+        Caller-supplied values — including the empty string — take
+        precedence.
+
+        Args:
+            hook: Identifier of the agent hook that fired the rule
+                (e.g. ``"before_model"``).
+            validators: Validator names attached to the fired rules.
+            rules: Each rule that fired — one LLMOps audit record is
+                written per entry.
+            data: Hook payload the server replays through the
+                centralized guardrail.
+            trace_id: Canonical 32-char hex trace id. Capture via
+                :func:`resolve_trace_id` on the hook thread before
+                hopping to a background pool.
+            src_timestamp: ISO-8601 timestamp on the source side.
+            agent_name: Agent identifier as known to the platform.
+            runtime_id: Runtime instance identifier.
+            folder_key: Override the env-backed folder key.
+            job_key: Override the env-backed job key.
+            process_key: Override the env-backed process key.
+            reference_id: Override the env-backed agent id.
+            agent_version: Override the env-backed agent version.
+
+        Raises:
+            ValueError: If ``UiPathConfig.organization_id`` or
+                ``UiPathConfig.tenant_id`` is not set.
+            EnrichedException: If the backend returns a non-2xx response.
+
+        Threading:
+            ``trace_id`` must be the agent's canonical trace id, and
+            OpenTelemetry context is thread-local; capture it on the
+            hook thread (via :func:`resolve_trace_id`) before hopping
+            to a background pool.
+        """
+        self._compensate(
+            GovernRequest(
+                hook=hook,
+                validators=validators,
+                rules=rules,
+                data=data,
+                trace_id=trace_id,
+                src_timestamp=src_timestamp,
+                agent_name=agent_name,
+                runtime_id=runtime_id,
+                folder_key=folder_key,
+                job_key=job_key,
+                process_key=process_key,
+                reference_id=reference_id,
+                agent_version=agent_version,
+            )
+        )
+
+    async def compensate_async(
+        self,
+        *,
+        hook: str,
+        validators: list[str],
+        rules: list[FiredRule],
+        data: dict[str, Any],
+        trace_id: str,
+        src_timestamp: str,
+        agent_name: str,
+        runtime_id: str,
+        folder_key: str | None = None,
+        job_key: str | None = None,
+        process_key: str | None = None,
+        reference_id: str | None = None,
+        agent_version: str | None = None,
+    ) -> None:
+        """Asynchronously POST a compensating ``/runtime/govern`` call.
+
+        See :meth:`compensate` for parameter semantics.
+        """
+        await self._compensate_async(
+            GovernRequest(
+                hook=hook,
+                validators=validators,
+                rules=rules,
+                data=data,
+                trace_id=trace_id,
+                src_timestamp=src_timestamp,
+                agent_name=agent_name,
+                runtime_id=runtime_id,
+                folder_key=folder_key,
+                job_key=job_key,
+                process_key=process_key,
+                reference_id=reference_id,
+                agent_version=agent_version,
+            )
+        )
+
+    # ── Internal worker for GovernRequest-shaped callers ─────────────
+
+    @traced(name="governance_compensate", run_type="uipath")
+    def _compensate(self, request: GovernRequest) -> None:
+        """Fire a compensation call from a pre-built :class:`GovernRequest`.
+
+        Internal helper used by the provider adapter
+        (:class:`uipath.platform.governance.UiPathPlatformGovernanceProvider`)
+        to satisfy :class:`uipath.core.governance.GovernanceCompensationProvider`
+        without unpacking the request. The public ergonomic counterpart
+        is :meth:`compensate`.
+        """
+        url, headers = self._build_org_scoped_request(GOVERN_API_PATH)
+        payload = self._build_govern_payload(request)
+        self.request("POST", url=url, headers=headers, json=payload)
+
+    @traced(name="governance_compensate", run_type="uipath")
+    async def _compensate_async(self, request: GovernRequest) -> None:
+        """Async variant of :meth:`_compensate`."""
+        url, headers = self._build_org_scoped_request(GOVERN_API_PATH)
+        payload = self._build_govern_payload(request)
+        await self.request_async("POST", url=url, headers=headers, json=payload)
+
+    # ── Internals ────────────────────────────────────────────────────
+
+    def _build_org_scoped_request(self, path: str) -> tuple[str, dict[str, str]]:
+        """Compose the agenticgovernance_ URL and the tenant header.
+
+        Both governance endpoints share the same URL shape
+        (``{origin}/{org_id_uuid}/agenticgovernance_/{path}``) and the
+        same ``x-uipath-internal-tenantid`` header — neither matches
+        ``UiPathUrl.scope_url`` (slug-based), so the URL is composed
+        directly here.
+
+        Honors ``UIPATH_SERVICE_URL_AGENTICGOVERNANCE`` for local dev:
+        when set, redirects to the override and injects routing headers
+        so the local server sees what the platform router would have
+        carried. ``BaseService.request`` does this same dance for paths
+        that fit ``scope_url``; the org-UUID-in-path shape forces us to
+        run it ourselves before composing the absolute URL.
+        """
+        organization_id = UiPathConfig.organization_id
+        if not organization_id:
+            raise ValueError(
+                "Governance call requires UIPATH_ORGANIZATION_ID "
+                "to be set in the environment."
+            )
+        tenant_id = UiPathConfig.tenant_id
+        if not tenant_id:
+            raise ValueError(
+                "Governance call requires UIPATH_TENANT_ID "
+                "to be set in the environment."
+            )
+
+        override = resolve_service_url(f"{GOVERNANCE_SERVICE_PREFIX}/{path}")
+        if override:
+            headers: dict[str, str] = {}
+            inject_routing_headers(headers)
+            return override, headers
+
+        url = (
+            f"{self._url.base_url}/{organization_id}/{GOVERNANCE_SERVICE_PREFIX}/{path}"
+        )
+        return url, {HEADER_INTERNAL_TENANT_ID: tenant_id}
+
+    @staticmethod
+    def _policy_params(is_conversational: Optional[bool]) -> dict[str, str]:
+        if is_conversational is None:
+            return {}
+        return {
+            AGENT_TYPE_PARAM: "conversational" if is_conversational else "autonomous"
+        }
+
+    @staticmethod
+    def _build_govern_payload(request: GovernRequest) -> dict[str, Any]:
+        """Serialize the request and fill missing job-context from UiPathConfig.
+
+        Auto-fill resolution order for each job-context field: caller
+        value > ``UiPathConfig`` (env-var-backed) > omit.
+
+        ``model_dump(exclude_none=True)`` already drops fields the caller
+        left ``None``, so key presence — not truthiness — is the right
+        "was it supplied?" signal: a caller-supplied empty string is
+        still a caller value and must not be overridden by the env.
+        """
+        payload = request.model_dump(by_alias=True, exclude_none=True)
+        for wire_key, config_attr in _JOB_CONTEXT_FIELDS:
+            if wire_key in payload:
+                continue
+            value = getattr(UiPathConfig, config_attr, None)
+            if value:
+                payload[wire_key] = value
+        return payload
+
+
+# Wire-key → UiPathConfig attribute, for compensation payload auto-fill.
+_JOB_CONTEXT_FIELDS: tuple[tuple[str, str], ...] = (
+    ("folderKey", "folder_key"),
+    ("jobKey", "job_key"),
+    ("processKey", "process_uuid"),
+    ("referenceId", "agent_id"),
+    ("agentVersion", "process_version"),
+)
diff --git a/packages/uipath-platform/src/uipath/platform/governance/compensate.py b/packages/uipath-platform/src/uipath/platform/governance/compensate.py
new file mode 100644
index 000000000..bad4845f9
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/governance/compensate.py
@@ -0,0 +1,10 @@
+"""Re-exports of compensation models from :mod:`uipath.core.governance`.
+
+The wire-shape models live in ``uipath-core`` so the runtime can depend on
+the protocol contract without importing ``uipath-platform``. This module
+keeps the existing ``uipath.platform.governance`` import paths working.
+"""
+
+from uipath.core.governance import FiredRule, GovernRequest
+
+__all__ = ["FiredRule", "GovernRequest"]
diff --git a/packages/uipath-platform/src/uipath/platform/governance/policy.py b/packages/uipath-platform/src/uipath/platform/governance/policy.py
new file mode 100644
index 000000000..27de1c9e7
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/governance/policy.py
@@ -0,0 +1,10 @@
+"""Re-exports of governance policy models from :mod:`uipath.core.governance`.
+
+The wire-shape models live in ``uipath-core`` so the runtime can depend on
+the protocol contract without importing ``uipath-platform``. This module
+keeps the existing ``uipath.platform.governance`` import paths working.
+"""
+
+from uipath.core.governance import PolicyContext, PolicyResponse
+
+__all__ = ["PolicyContext", "PolicyResponse"]
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/__init__.py b/packages/uipath-platform/src/uipath/platform/guardrails/__init__.py
new file mode 100644
index 000000000..93c60b0a4
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/__init__.py
@@ -0,0 +1,91 @@
+"""UiPath Guardrails Models.
+
+This module contains models related to UiPath Guardrails service.
+"""
+
+# 2.3.0 remove
+from uipath.core.guardrails import (
+    BaseGuardrail,
+    DeterministicGuardrail,
+    DeterministicGuardrailsService,
+    GuardrailScope,
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+)
+
+from ._guardrails_service import GuardrailsService
+from .decorators import (
+    BlockAction,
+    BuiltInGuardrailValidator,
+    CustomGuardrailValidator,
+    CustomValidator,
+    GuardrailAction,
+    GuardrailBlockException,
+    GuardrailExclude,
+    GuardrailExecutionStage,
+    GuardrailTargetAdapter,
+    GuardrailValidatorBase,
+    HarmfulContentEntity,
+    HarmfulContentEntityType,
+    HarmfulContentValidator,
+    IntellectualPropertyEntityType,
+    IntellectualPropertyValidator,
+    LogAction,
+    LoggingSeverityLevel,
+    PIIDetectionEntity,
+    PIIDetectionEntityType,
+    PIIValidator,
+    PromptInjectionValidator,
+    RuleFunction,
+    UserPromptAttacksValidator,
+    guardrail,
+    register_guardrail_adapter,
+)
+from .guardrails import (
+    BuiltInValidatorGuardrail,
+    EnumListParameterValue,
+    GuardrailType,
+    MapEnumParameterValue,
+)
+
+__all__ = [
+    # Service
+    "GuardrailsService",
+    # Guardrail models
+    "BuiltInValidatorGuardrail",
+    "GuardrailType",
+    "GuardrailValidationResultType",
+    "BaseGuardrail",
+    "GuardrailScope",
+    "DeterministicGuardrail",
+    "DeterministicGuardrailsService",
+    "GuardrailValidationResult",
+    "EnumListParameterValue",
+    "MapEnumParameterValue",
+    # Decorator framework
+    "guardrail",
+    "GuardrailValidatorBase",
+    "BuiltInGuardrailValidator",
+    "CustomGuardrailValidator",
+    "HarmfulContentValidator",
+    "IntellectualPropertyValidator",
+    "PIIValidator",
+    "PromptInjectionValidator",
+    "UserPromptAttacksValidator",
+    "CustomValidator",
+    "RuleFunction",
+    "HarmfulContentEntity",
+    "HarmfulContentEntityType",
+    "IntellectualPropertyEntityType",
+    "PIIDetectionEntity",
+    "PIIDetectionEntityType",
+    "GuardrailExecutionStage",
+    "GuardrailAction",
+    "LogAction",
+    "BlockAction",
+    "LoggingSeverityLevel",
+    "GuardrailBlockException",
+    "GuardrailExclude",
+    "GuardrailTargetAdapter",
+    "register_guardrail_adapter",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/_guardrails_service.py b/packages/uipath-platform/src/uipath/platform/guardrails/_guardrails_service.py
new file mode 100644
index 000000000..86856a6b4
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/_guardrails_service.py
@@ -0,0 +1,184 @@
+import re
+from typing import Any, Optional
+
+from httpx import HTTPStatusError
+from uipath.core.guardrails import (
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+)
+from uipath.core.tracing import traced
+
+from ..chat.llm_trace_context import build_trace_context_headers
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from ..errors import EnrichedException
+from .guardrails import BuiltInValidatorGuardrail
+
+# x-uipath-traceparent-id header format: {version}-{trace_id}-{span_id}[-{trace_flags}]
+# Based on W3C traceparent but allows 16- or 32-hex span IDs.
+_TRACEPARENT_PATTERN = re.compile(
+    r"^[0-9a-f]{2}-[0-9a-f]{32}-(?P<span_id>[0-9a-f]{16}|[0-9a-f]{32})(?:-[0-9a-f]{2})?$",
+    re.IGNORECASE,
+)
+
+
+class GuardrailsService(BaseService):
+    """Service for validating text against UiPath Guardrails.
+
+    This service provides an interface for evaluating built-in guardrails such as:
+
+    - PII detection
+    - Prompt injection detection
+
+    Deterministic and custom guardrails are not yet supported.
+
+    !!! info "Version Availability"
+        This service is available starting from **uipath** version **2.2.12**.
+    """
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @staticmethod
+    def _extract_span_id_from_traceparent(
+        traceparent: Optional[str],
+    ) -> Optional[str]:
+        """Extract span ID from x-uipath-traceparent-id header and format as GUID.
+
+        Args:
+            traceparent: Value from the ``x-uipath-traceparent-id`` response header.
+                Accepts 3-part ``"00-{trace_id}-{span_id}"`` or 4-part
+                ``"00-{trace_id}-{span_id}-{trace_flags}"``. Span ID may be
+                16 or 32 hex chars.
+
+        Returns:
+            Span ID formatted as lowercase GUID (8-4-4-4-12), or None if not parseable.
+        """
+        if not traceparent:
+            return None
+        match = _TRACEPARENT_PATTERN.match(traceparent)
+        if not match:
+            return None
+        span_id_hex = match.group("span_id").lower()
+        # Pad to 32 chars for GUID conversion (span IDs may be 16 hex chars)
+        padded = span_id_hex.zfill(32)
+        return f"{padded[:8]}-{padded[8:12]}-{padded[12:16]}-{padded[16:20]}-{padded[20:32]}"
+
+    @staticmethod
+    def _parse_result(result_str: str) -> GuardrailValidationResultType:
+        """Parse result string from API response to GuardrailValidationResultType.
+
+        Args:
+            result_str: The result string from the API response (e.g., "VALIDATION_FAILED").
+
+        Returns:
+            GuardrailValidationResultType: The parsed validation result type.
+        """
+        if not result_str:
+            return GuardrailValidationResultType.VALIDATION_FAILED
+
+        # Convert uppercase enum name to enum value
+        # API: "VALIDATION_FAILED" -> enum: "validation_failed"
+        result_value = result_str.lower()
+        try:
+            return GuardrailValidationResultType(result_value)
+        except ValueError:
+            # If direct conversion fails, try by enum name
+            try:
+                return GuardrailValidationResultType[result_str]
+            except KeyError:
+                # Fallback to validation_failed if unknown
+                return GuardrailValidationResultType.VALIDATION_FAILED
+
+    @traced("evaluate_guardrail", run_type="uipath")
+    def evaluate_guardrail(
+        self,
+        input_data: str | dict[str, Any],
+        guardrail: BuiltInValidatorGuardrail,
+    ) -> GuardrailValidationResult:
+        """Validate input text using the provided guardrail.
+
+        Args:
+            input_data: The text or structured data to validate. Dictionaries will be converted to a string before validation.
+            guardrail: A guardrail instance used for validation.
+
+        Returns:
+            GuardrailValidationResult: The outcome of the guardrail evaluation.
+        """
+        parameters = [
+            param.model_dump(by_alias=True) for param in guardrail.validator_parameters
+        ]
+        payload = {
+            "validator": guardrail.validator_type,
+            "input": input_data if isinstance(input_data, str) else str(input_data),
+            "parameters": parameters,
+            "guardrailName": guardrail.name,
+        }
+        spec = RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/agentsruntime_/api/execution/guardrails/validate"),
+            json=payload,
+        )
+        # Include trace context headers for server-side span correlation
+        trace_headers = build_trace_context_headers()
+        request_headers = {**(spec.headers or {}), **trace_headers}
+        span_id = None
+        try:
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                json=spec.json,
+                headers=request_headers,
+            )
+            span_id = self._extract_span_id_from_traceparent(
+                response.headers.get("x-uipath-traceparent-id")
+            )
+            response_data = response.json()
+        except EnrichedException as e:
+            # Handle 403 responses: API returns 403 with valid JSON body for
+            # ENTITLEMENTS_MISSING or FEATURE_DISABLED cases
+            if e.status_code == 403:
+                # Access the original HTTPStatusError to get the full response
+                original_error = e.__cause__
+                if (
+                    isinstance(original_error, HTTPStatusError)
+                    and original_error.response
+                ):
+                    try:
+                        span_id = self._extract_span_id_from_traceparent(
+                            original_error.response.headers.get(
+                                "x-uipath-traceparent-id"
+                            )
+                        )
+                        response_data = original_error.response.json()
+                    except Exception:
+                        # If JSON parsing fails, re-raise the original exception
+                        raise
+                else:
+                    # Try to parse from response_content if available
+                    try:
+                        import json
+
+                        response_data = json.loads(e.response_content)
+                    except Exception:
+                        raise
+            else:
+                raise
+
+        result = self._parse_result(response_data.get("result", ""))
+
+        reason = response_data.get("details", "")
+
+        # Prepare model data
+        model_data: dict[str, Any] = {
+            "result": result.value,
+            "reason": reason,
+        }
+        if span_id:
+            model_data["spanId"] = span_id
+
+        return GuardrailValidationResult.model_validate(model_data)
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/__init__.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/__init__.py
new file mode 100644
index 000000000..e8d692164
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/__init__.py
@@ -0,0 +1,66 @@
+"""Guardrail decorator framework for UiPath Platform.
+
+Provides the ``@guardrail`` decorator, built-in validators, actions, and an
+adapter registry that framework integrations (e.g. *uipath-langchain*) use to
+teach the decorator how to wrap their specific object types.
+"""
+
+from ._actions import BlockAction, LogAction, LoggingSeverityLevel
+from ._core import GuardrailExclude
+from ._enums import (
+    GuardrailExecutionStage,
+    HarmfulContentEntityType,
+    IntellectualPropertyEntityType,
+    PIIDetectionEntityType,
+)
+from ._exceptions import GuardrailBlockException
+from ._guardrail import guardrail
+from ._models import GuardrailAction, HarmfulContentEntity, PIIDetectionEntity
+from ._registry import GuardrailTargetAdapter, register_guardrail_adapter
+from .validators import (
+    BuiltInGuardrailValidator,
+    CustomGuardrailValidator,
+    CustomValidator,
+    GuardrailValidatorBase,
+    HarmfulContentValidator,
+    IntellectualPropertyValidator,
+    PIIValidator,
+    PromptInjectionValidator,
+    RuleFunction,
+    UserPromptAttacksValidator,
+)
+
+__all__ = [
+    # Decorator
+    "guardrail",
+    # Validators
+    "GuardrailValidatorBase",
+    "BuiltInGuardrailValidator",
+    "CustomGuardrailValidator",
+    "HarmfulContentValidator",
+    "IntellectualPropertyValidator",
+    "PIIValidator",
+    "PromptInjectionValidator",
+    "UserPromptAttacksValidator",
+    "CustomValidator",
+    "RuleFunction",
+    # Models & enums
+    "HarmfulContentEntity",
+    "HarmfulContentEntityType",
+    "IntellectualPropertyEntityType",
+    "PIIDetectionEntity",
+    "PIIDetectionEntityType",
+    "GuardrailExecutionStage",
+    "GuardrailAction",
+    # Actions
+    "LogAction",
+    "BlockAction",
+    "LoggingSeverityLevel",
+    # Exception
+    "GuardrailBlockException",
+    # Exclude marker
+    "GuardrailExclude",
+    # Adapter registry
+    "GuardrailTargetAdapter",
+    "register_guardrail_adapter",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_actions.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_actions.py
new file mode 100644
index 000000000..8e6489797
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_actions.py
@@ -0,0 +1,82 @@
+"""Built-in GuardrailAction implementations."""
+
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional
+
+from uipath.core.guardrails import (
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+)
+
+from ._exceptions import GuardrailBlockException
+from ._models import GuardrailAction
+
+
+class LoggingSeverityLevel(int, Enum):
+    """Logging severity level for :class:`LogAction`."""
+
+    ERROR = logging.ERROR
+    INFO = logging.INFO
+    WARNING = logging.WARNING
+    DEBUG = logging.DEBUG
+
+
+@dataclass
+class LogAction(GuardrailAction):
+    """Log guardrail violations without stopping execution.
+
+    Args:
+        severity_level: Python logging level. Defaults to ``WARNING``.
+        message: Custom log message. If omitted, the validation reason is used.
+    """
+
+    severity_level: LoggingSeverityLevel = LoggingSeverityLevel.WARNING
+    message: Optional[str] = None
+
+    def handle_validation_result(
+        self,
+        result: GuardrailValidationResult,
+        data: str | dict[str, Any],
+        guardrail_name: str,
+    ) -> str | dict[str, Any] | None:
+        """Log the violation and return ``None`` (no data modification)."""
+        if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+            msg = self.message or f"Failed: {result.reason}"
+            logging.getLogger(__name__).log(
+                self.severity_level,
+                "[GUARDRAIL] [%s] %s",
+                guardrail_name,
+                msg,
+            )
+        return None
+
+
+@dataclass
+class BlockAction(GuardrailAction):
+    """Block execution by raising :class:`GuardrailBlockException`.
+
+    Framework adapters catch ``GuardrailBlockException`` at the wrapper boundary
+    and convert it to their own runtime error type.
+
+    Args:
+        title: Exception title. Defaults to a message derived from the guardrail name.
+        detail: Exception detail. Defaults to the validation reason.
+    """
+
+    title: Optional[str] = None
+    detail: Optional[str] = None
+
+    def handle_validation_result(
+        self,
+        result: GuardrailValidationResult,
+        data: str | dict[str, Any],
+        guardrail_name: str,
+    ) -> str | dict[str, Any] | None:
+        """Raise :class:`GuardrailBlockException` when validation fails."""
+        if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+            title = self.title or f"Guardrail [{guardrail_name}] blocked execution"
+            detail = self.detail or result.reason or "Guardrail validation failed"
+            raise GuardrailBlockException(title=title, detail=detail)
+        return None
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_core.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_core.py
new file mode 100644
index 000000000..ca168a1e0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_core.py
@@ -0,0 +1,302 @@
+"""Core framework-agnostic utilities for guardrail decorators."""
+
+import ast
+import dataclasses
+import inspect
+import json
+import logging
+from typing import Annotated, Any, Callable, get_args, get_origin, get_type_hints
+
+from uipath.core.guardrails import (
+    GuardrailValidationResult,
+)
+
+from ._enums import GuardrailExecutionStage
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# GuardrailExclude marker
+# ---------------------------------------------------------------------------
+
+
+class GuardrailExclude:
+    """Marker to exclude a parameter from guardrail input serialization.
+
+    Use with :data:`typing.Annotated` to prevent a specific function parameter
+    from being collected into the guardrail evaluation payload::
+
+        async def process(
+            text: str,
+            config: Annotated[dict, GuardrailExclude()],
+        ) -> str: ...
+    """
+
+
+# ---------------------------------------------------------------------------
+# Evaluator type alias
+# ---------------------------------------------------------------------------
+
+_EvaluatorFn = Callable[
+    [
+        "str | dict[str, Any]",  # data
+        GuardrailExecutionStage,  # stage
+        "dict[str, Any] | None",  # input_data
+        "dict[str, Any] | None",  # output_data
+    ],
+    GuardrailValidationResult,
+]
+"""Type alias for the unified evaluation callable used by all wrappers."""
+
+
+# ---------------------------------------------------------------------------
+# Evaluator factory
+# ---------------------------------------------------------------------------
+
+
+def _make_evaluator(
+    validator: Any,
+    name: str,
+    description: str | None,
+    enabled_for_evals: bool,
+) -> _EvaluatorFn:
+    """Return a unified evaluation callable.
+
+    Delegates to ``validator.run()`` which each validator subclass implements
+    (:class:`BuiltInGuardrailValidator` hits the UiPath API;
+    :class:`CustomGuardrailValidator` runs a local Python rule).
+
+    Args:
+        validator: :class:`GuardrailValidatorBase` instance.
+        name: Guardrail name — forwarded to ``validator.run()`` on each call.
+        description: Optional description — forwarded to ``validator.run()``.
+        enabled_for_evals: Whether active in evaluation scenarios.
+
+    Returns:
+        Callable with signature ``(data, stage, input_data, output_data)``.
+    """
+
+    def _eval(
+        data: str | dict[str, Any],
+        stage: GuardrailExecutionStage,
+        input_data: dict[str, Any] | None,
+        output_data: dict[str, Any] | None,
+    ) -> GuardrailValidationResult:
+        return validator.run(
+            name, description, enabled_for_evals, data, stage, input_data, output_data
+        )
+
+    return _eval
+
+
+# ---------------------------------------------------------------------------
+# Parameter introspection
+# ---------------------------------------------------------------------------
+
+
+def _get_excluded_params(func: Any) -> set[str]:
+    """Return parameter names annotated with :class:`GuardrailExclude`.
+
+    Args:
+        func: Callable to inspect.
+
+    Returns:
+        Set of parameter names that should be excluded from guardrail input.
+    """
+    try:
+        hints = get_type_hints(func, include_extras=True)
+    except Exception:
+        return set()
+    excluded: set[str] = set()
+    for name, hint in hints.items():
+        if get_origin(hint) is Annotated:
+            for meta in get_args(hint)[1:]:
+                if isinstance(meta, GuardrailExclude):
+                    excluded.add(name)
+    return excluded
+
+
+# ---------------------------------------------------------------------------
+# Serialization helpers
+# ---------------------------------------------------------------------------
+
+
+def _serialize_value(value: Any) -> Any:
+    """Serialize *value* to a JSON-compatible type for guardrail evaluation.
+
+    Pydantic models → ``model_dump()``, dataclasses → ``asdict()``,
+    primitives → as-is, everything else → ``str()``.
+    """
+    if value is None:
+        return None
+    if isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {k: _serialize_value(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_serialize_value(v) for v in value]
+    # Pydantic v2
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    # Pydantic v1
+    if hasattr(value, "dict") and callable(value.dict):
+        try:
+            return value.dict()
+        except Exception:
+            pass
+    # dataclasses
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        return dataclasses.asdict(value)
+    return str(value)
+
+
+def _collect_input(
+    bound: inspect.BoundArguments,
+    excluded: set[str],
+) -> dict[str, Any]:
+    """Collect non-excluded function parameters into a guardrail input dict.
+
+    Args:
+        bound: Bound arguments from ``inspect.Signature.bind()``.
+        excluded: Parameter names to skip.
+
+    Returns:
+        ``{param_name: serialized_value}`` for all non-excluded parameters.
+    """
+    result: dict[str, Any] = {}
+    for name, value in bound.arguments.items():
+        if name in excluded or name in ("self", "cls"):
+            continue
+        result[name] = _serialize_value(value)
+    return result
+
+
+def _collect_output(return_value: Any) -> dict[str, Any]:
+    """Serialize a function return value into a dict for guardrail evaluation.
+
+    Args:
+        return_value: The value returned by the wrapped function.
+
+    Returns:
+        A ``dict`` representation suitable for guardrail evaluation.
+    """
+    serialized = _serialize_value(return_value)
+    if isinstance(serialized, dict):
+        return serialized
+    return {"return": serialized}
+
+
+def _reconstruct_output(original: Any, modified: Any) -> Any:
+    """Reconstruct a return value from a guardrail-modified payload.
+
+    Args:
+        original: The original return value (used to determine target type).
+        modified: The modified value returned by the guardrail action.
+
+    Returns:
+        Reconstructed value of the same type as *original* where possible.
+    """
+    if modified is None:
+        return original
+    # Pydantic v2 model + dict modification → reconstruct via model_validate
+    if hasattr(original, "model_validate") and isinstance(modified, dict):
+        try:
+            return type(original).model_validate(modified)
+        except Exception:
+            pass
+    # Pydantic v1
+    if hasattr(original, "parse_obj") and isinstance(modified, dict):
+        try:
+            return type(original).parse_obj(modified)
+        except Exception:
+            pass
+    return modified
+
+
+def _apply_pre_modification(
+    bound: inspect.BoundArguments,
+    modified: Any,
+    excluded: set[str],
+) -> None:
+    """Apply guardrail PRE-stage modifications back to bound function arguments.
+
+    If the action returned a modified dict, keys matching non-excluded parameters
+    are updated in-place. If the action returned a plain string and there is exactly
+    one non-excluded parameter, that parameter is updated.
+
+    Args:
+        bound: Bound arguments to mutate in-place.
+        modified: Value returned by the guardrail action.
+        excluded: Parameter names that were excluded from evaluation.
+    """
+    if modified is None:
+        return
+    non_excluded = [
+        n for n in bound.arguments if n not in excluded and n not in ("self", "cls")
+    ]
+    if isinstance(modified, dict):
+        for name in non_excluded:
+            if name in modified:
+                bound.arguments[name] = modified[name]
+    elif isinstance(modified, str) and len(non_excluded) == 1:
+        bound.arguments[non_excluded[0]] = modified
+
+
+# ---------------------------------------------------------------------------
+# Tool I/O normalisation helpers (used by LangChain adapter)
+# ---------------------------------------------------------------------------
+
+
+def _is_tool_call_envelope(tool_input: Any) -> bool:
+    """Return ``True`` if *tool_input* is a LangGraph tool-call envelope dict."""
+    return (
+        isinstance(tool_input, dict)
+        and "args" in tool_input
+        and tool_input.get("type") == "tool_call"
+    )
+
+
+def _extract_input(tool_input: Any) -> dict[str, Any]:
+    """Normalise tool input to a plain dict for rule / guardrail evaluation.
+
+    LangGraph wraps tool inputs as ``{"name": ..., "args": {...}, "type": "tool_call"}``.
+    This function unwraps ``args`` so rules can access the actual tool arguments.
+    """
+    if _is_tool_call_envelope(tool_input):
+        args = tool_input["args"]
+        if isinstance(args, dict):
+            return args
+    if isinstance(tool_input, dict):
+        return tool_input
+    return {"input": tool_input}
+
+
+def _rewrap_input(original_tool_input: Any, modified_args: dict[str, Any]) -> Any:
+    """Re-wrap modified args back into the original tool-call envelope (if applicable)."""
+    if _is_tool_call_envelope(original_tool_input):
+        import copy
+
+        wrapped = copy.copy(original_tool_input)
+        wrapped["args"] = modified_args
+        return wrapped
+    return modified_args
+
+
+def _extract_output(result: Any) -> dict[str, Any]:
+    """Normalise tool output to a dict for guardrail / rule evaluation.
+
+    Falls back to ``{"output": content}`` for plain strings and anything else.
+    """
+    if isinstance(result, dict):
+        return result
+    if isinstance(result, str):
+        try:
+            parsed = json.loads(result)
+            return parsed if isinstance(parsed, dict) else {"output": parsed}
+        except ValueError:
+            try:
+                parsed = ast.literal_eval(result)
+                return parsed if isinstance(parsed, dict) else {"output": parsed}
+            except (ValueError, SyntaxError):
+                return {"output": result}
+    return {"output": result}
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_enums.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_enums.py
new file mode 100644
index 000000000..c88df5acd
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_enums.py
@@ -0,0 +1,93 @@
+"""Enums for guardrail decorators."""
+
+from enum import Enum
+
+
+class GuardrailExecutionStage(str, Enum):
+    """Execution stage for guardrails."""
+
+    PRE = "pre"
+    """Evaluate before the target executes."""
+
+    POST = "post"
+    """Evaluate after the target executes."""
+
+    PRE_AND_POST = "pre&post"
+    """Evaluate both before and after the target executes."""
+
+
+class PIIDetectionEntityType(str, Enum):
+    """PII detection entity types supported by UiPath guardrails.
+
+    | Value |
+    |---|
+    | `PERSON` |
+    | `ADDRESS` |
+    | `DATE` |
+    | `PHONE_NUMBER` |
+    | `EUGPS_COORDINATES` |
+    | `EMAIL` |
+    | `CREDIT_CARD_NUMBER` |
+    | `INTERNATIONAL_BANKING_ACCOUNT_NUMBER` |
+    | `SWIFT_CODE` |
+    | `ABA_ROUTING_NUMBER` |
+    | `US_DRIVERS_LICENSE_NUMBER` |
+    | `UK_DRIVERS_LICENSE_NUMBER` |
+    | `US_INDIVIDUAL_TAXPAYER_IDENTIFICATION` |
+    | `UK_UNIQUE_TAXPAYER_NUMBER` |
+    | `US_BANK_ACCOUNT_NUMBER` |
+    | `US_SOCIAL_SECURITY_NUMBER` |
+    | `USUK_PASSPORT_NUMBER` |
+    | `URL` |
+    | `IP_ADDRESS` |
+    """
+
+    PERSON = "Person"
+    ADDRESS = "Address"
+    DATE = "Date"
+    PHONE_NUMBER = "PhoneNumber"
+    EUGPS_COORDINATES = "EugpsCoordinates"
+    EMAIL = "Email"
+    CREDIT_CARD_NUMBER = "CreditCardNumber"
+    INTERNATIONAL_BANKING_ACCOUNT_NUMBER = "InternationalBankingAccountNumber"
+    SWIFT_CODE = "SwiftCode"
+    ABA_ROUTING_NUMBER = "ABARoutingNumber"
+    US_DRIVERS_LICENSE_NUMBER = "USDriversLicenseNumber"
+    UK_DRIVERS_LICENSE_NUMBER = "UKDriversLicenseNumber"
+    US_INDIVIDUAL_TAXPAYER_IDENTIFICATION = "USIndividualTaxpayerIdentification"
+    UK_UNIQUE_TAXPAYER_NUMBER = "UKUniqueTaxpayerNumber"
+    US_BANK_ACCOUNT_NUMBER = "USBankAccountNumber"
+    US_SOCIAL_SECURITY_NUMBER = "USSocialSecurityNumber"
+    USUK_PASSPORT_NUMBER = "UsukPassportNumber"
+    URL = "URL"
+    IP_ADDRESS = "IPAddress"
+
+
+class HarmfulContentEntityType(str, Enum):
+    """Harmful content entity types supported by UiPath guardrails.
+
+    | Value |
+    |---|
+    | `HATE` |
+    | `SELF_HARM` |
+    | `SEXUAL` |
+    | `VIOLENCE` |
+    """
+
+    HATE = "Hate"
+    SELF_HARM = "SelfHarm"
+    SEXUAL = "Sexual"
+    VIOLENCE = "Violence"
+
+
+class IntellectualPropertyEntityType(str, Enum):
+    """Intellectual property entity types supported by UiPath guardrails.
+
+    | Value |
+    |---|
+    | `TEXT` |
+    | `CODE` |
+    """
+
+    TEXT = "Text"
+    CODE = "Code"
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_exceptions.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_exceptions.py
new file mode 100644
index 000000000..f4b7672e5
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_exceptions.py
@@ -0,0 +1,18 @@
+"""Exceptions for guardrail decorators."""
+
+
+class GuardrailBlockException(Exception):
+    """Raised by BlockAction when a guardrail blocks execution.
+
+    Framework adapters (e.g. LangChain) should catch this and convert it to
+    their own runtime exception type at the outermost wrapper boundary.
+
+    Args:
+        title: Brief title for the block event.
+        detail: Detailed reason for the block.
+    """
+
+    def __init__(self, title: str, detail: str) -> None:
+        self.title = title
+        self.detail = detail
+        super().__init__(f"{title}: {detail}")
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_guardrail.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_guardrail.py
new file mode 100644
index 000000000..d61b41c0d
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_guardrail.py
@@ -0,0 +1,224 @@
+"""Single ``@guardrail`` decorator for all guardrail types."""
+
+import inspect
+import logging
+from functools import wraps
+from typing import Any
+
+from ._core import (
+    _apply_pre_modification,
+    _collect_input,
+    _collect_output,
+    _EvaluatorFn,
+    _get_excluded_params,
+    _make_evaluator,
+    _reconstruct_output,
+)
+from ._enums import GuardrailExecutionStage
+from ._models import GuardrailAction
+from ._registry import is_recognized_by_adapter, wrap_with_adapter
+from .validators._base import GuardrailValidatorBase
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _run_pre(
+    evaluator: _EvaluatorFn,
+    action: GuardrailAction,
+    name: str,
+    bound: inspect.BoundArguments,
+    excluded: set[str],
+) -> None:
+    """Evaluate PRE guardrail and apply any modifications to *bound* in-place."""
+    input_data = _collect_input(bound, excluded)
+    try:
+        result = evaluator(input_data, GuardrailExecutionStage.PRE, input_data, None)
+    except Exception as exc:
+        logger.error("Error evaluating PRE guardrail %r: %s", name, exc, exc_info=True)
+        return
+    from uipath.core.guardrails import GuardrailValidationResultType
+
+    if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+        modified = action.handle_validation_result(result, input_data, name)
+        _apply_pre_modification(bound, modified, excluded)
+
+
+def _run_post(
+    evaluator: _EvaluatorFn,
+    action: GuardrailAction,
+    name: str,
+    bound: inspect.BoundArguments,
+    excluded: set[str],
+    return_value: Any,
+) -> Any:
+    """Evaluate POST guardrail and return (possibly modified) return value."""
+    input_data = _collect_input(bound, excluded)
+    output_data = _collect_output(return_value)
+    try:
+        result = evaluator(
+            output_data, GuardrailExecutionStage.POST, input_data, output_data
+        )
+    except Exception as exc:
+        logger.error("Error evaluating POST guardrail %r: %s", name, exc, exc_info=True)
+        return return_value
+    from uipath.core.guardrails import GuardrailValidationResultType
+
+    if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+        modified = action.handle_validation_result(result, output_data, name)
+        return _reconstruct_output(return_value, modified)
+    return return_value
+
+
+def _wrap_function(
+    func: Any,
+    evaluator: _EvaluatorFn,
+    action: GuardrailAction,
+    name: str,
+    stage: GuardrailExecutionStage,
+    excluded: set[str],
+) -> Any:
+    """Wrap *func* as a pure Python function with PRE/POST guardrail evaluation."""
+    sig = inspect.signature(func)
+
+    def _dispatch_return(return_value: Any) -> Any:
+        """For factory functions: if the return value is recognized by an adapter, wrap it."""
+        if is_recognized_by_adapter(return_value):
+            return wrap_with_adapter(return_value, evaluator, action, name, stage)
+        return return_value
+
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _wrapped_async(*args: Any, **kwargs: Any) -> Any:
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            if stage in (
+                GuardrailExecutionStage.PRE,
+                GuardrailExecutionStage.PRE_AND_POST,
+            ):
+                _run_pre(evaluator, action, name, bound, excluded)
+            return_value = await func(*bound.args, **bound.kwargs)
+            return_value = _dispatch_return(return_value)
+            if stage in (
+                GuardrailExecutionStage.POST,
+                GuardrailExecutionStage.PRE_AND_POST,
+            ):
+                # Only run POST on plain (non-adapter-wrapped) values
+                if not is_recognized_by_adapter(return_value):
+                    return_value = _run_post(
+                        evaluator, action, name, bound, excluded, return_value
+                    )
+            return return_value
+
+        return _wrapped_async
+
+    @wraps(func)
+    def _wrapped(*args: Any, **kwargs: Any) -> Any:
+        bound = sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+        if stage in (
+            GuardrailExecutionStage.PRE,
+            GuardrailExecutionStage.PRE_AND_POST,
+        ):
+            _run_pre(evaluator, action, name, bound, excluded)
+        return_value = func(*bound.args, **bound.kwargs)
+        return_value = _dispatch_return(return_value)
+        if stage in (
+            GuardrailExecutionStage.POST,
+            GuardrailExecutionStage.PRE_AND_POST,
+        ):
+            if not is_recognized_by_adapter(return_value):
+                return_value = _run_post(
+                    evaluator, action, name, bound, excluded, return_value
+                )
+        return return_value
+
+    return _wrapped
+
+
+# ---------------------------------------------------------------------------
+# Public @guardrail decorator
+# ---------------------------------------------------------------------------
+
+
+def guardrail(
+    func: Any = None,
+    *,
+    validator: GuardrailValidatorBase,
+    action: GuardrailAction,
+    name: str = "Guardrail",
+    description: str | None = None,
+    stage: GuardrailExecutionStage = GuardrailExecutionStage.PRE_AND_POST,
+    enabled_for_evals: bool = True,
+) -> Any:
+    """Apply a guardrail to any callable — tool functions, LLM factories, agent nodes.
+
+    When applied to a plain function or async function, the decorator collects
+    function parameters (PRE) and return value (POST) and evaluates them against
+    the guardrail. Use :class:`~._core.GuardrailExclude` to opt individual
+    parameters out of serialization.
+
+    When applied to a factory function whose return value is recognised by a
+    registered framework adapter (e.g. a LangChain ``BaseChatModel``), the
+    returned object is wrapped so every subsequent ``invoke()`` call is guarded.
+
+    Multiple ``@guardrail`` decorators can be stacked on the same callable.
+
+    Args:
+        func: Callable to decorate. Supplied directly when used without parentheses.
+        validator: :class:`~.validators.GuardrailValidatorBase` defining what to check.
+        action: :class:`~._models.GuardrailAction` defining how to respond on violation.
+        name: Human-readable name for this guardrail instance.
+        description: Optional description passed to API-based guardrails.
+        stage: When to evaluate — ``PRE``, ``POST``, or ``PRE_AND_POST``.
+            Defaults to ``PRE_AND_POST``.
+        enabled_for_evals: Whether this guardrail is active in evaluation scenarios.
+            Defaults to ``True``.
+
+    Returns:
+        The decorated callable (or framework object).
+
+    Raises:
+        ValueError: If *action* is invalid, or the validator does not support
+            the requested stage.
+        GuardrailBlockException: Raised at runtime by :class:`~._actions.BlockAction`
+            when a violation is detected.
+    """
+    if action is None:
+        raise ValueError("action must be provided")
+    if not isinstance(action, GuardrailAction):
+        raise ValueError("action must be an instance of GuardrailAction")
+    if not isinstance(enabled_for_evals, bool):
+        raise ValueError("enabled_for_evals must be a boolean")
+
+    def _apply(obj: Any) -> Any:
+        # ------------------------------------------------------------------
+        # 1. Adapter-recognised direct object (e.g. BaseTool after @tool)
+        # ------------------------------------------------------------------
+        if is_recognized_by_adapter(obj):
+            validator.validate_stage(stage)
+            evaluator = _make_evaluator(validator, name, description, enabled_for_evals)
+            return wrap_with_adapter(obj, evaluator, action, name, stage)
+
+        # ------------------------------------------------------------------
+        # 2. Plain callable — wrap as pure function
+        # ------------------------------------------------------------------
+        if callable(obj):
+            validator.validate_stage(stage)
+            evaluator = _make_evaluator(validator, name, description, enabled_for_evals)
+            excluded = _get_excluded_params(obj)
+            return _wrap_function(obj, evaluator, action, name, stage, excluded)
+
+        raise ValueError(
+            f"@guardrail cannot be applied to {type(obj)!r}. "
+            "Target must be a callable or a framework-registered object. "
+            "Ensure the relevant framework adapter is imported before using @guardrail."
+        )
+
+    if func is None:
+        return _apply
+    return _apply(func)
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_models.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_models.py
new file mode 100644
index 000000000..8d86fbf39
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_models.py
@@ -0,0 +1,76 @@
+"""Models for guardrail decorators."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+from uipath.core.guardrails import GuardrailValidationResult
+
+
+@dataclass
+class PIIDetectionEntity:
+    """PII entity configuration with detection threshold.
+
+    Args:
+        name: The entity type name (e.g. ``PIIDetectionEntityType.EMAIL``).
+        threshold: Confidence threshold (0.0 to 1.0) for detection.
+    """
+
+    name: str
+    threshold: float = 0.5
+
+    def __post_init__(self) -> None:
+        if not 0.0 <= self.threshold <= 1.0:
+            raise ValueError(
+                f"Threshold must be between 0.0 and 1.0, got {self.threshold}"
+            )
+
+
+@dataclass
+class HarmfulContentEntity:
+    """Harmful content entity configuration with severity threshold.
+
+    Args:
+        name: The entity type name (e.g. ``HarmfulContentEntityType.VIOLENCE``).
+        threshold: Severity threshold (0 to 6) for detection. Defaults to ``2``.
+    """
+
+    name: str
+    threshold: int = 2
+
+    def __post_init__(self) -> None:
+        if not 0 <= self.threshold <= 6:
+            raise ValueError(f"Threshold must be between 0 and 6, got {self.threshold}")
+
+
+class GuardrailAction(ABC):
+    """Interface for defining custom actions when a guardrail violation is detected.
+
+    Subclass this to implement custom behaviour on validation failure, such as
+    logging, blocking, or content sanitisation. Built-in implementations are
+    :class:`LogAction` and :class:`BlockAction`.
+    """
+
+    @abstractmethod
+    def handle_validation_result(
+        self,
+        result: GuardrailValidationResult,
+        data: str | dict[str, Any],
+        guardrail_name: str,
+    ) -> "str | dict[str, Any] | None":
+        """Handle a guardrail validation result.
+
+        Called when guardrail validation fails. May return modified data to
+        sanitise/filter the validated content before execution continues, or
+        ``None`` to leave it unchanged.
+
+        Args:
+            result: The validation result from the guardrails service.
+            data: The data that was validated (string or dictionary). Depending
+                on context this can be tool input, tool output, or message text.
+            guardrail_name: The name of the guardrail that triggered.
+
+        Returns:
+            Modified data if the action wants to replace the original, or
+            ``None`` if no modification is needed.
+        """
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_registry.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_registry.py
new file mode 100644
index 000000000..c4b7773b5
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/_registry.py
@@ -0,0 +1,105 @@
+"""Adapter registry for guardrail target recognition and wrapping."""
+
+from typing import Any, Protocol, runtime_checkable
+
+from ._core import _EvaluatorFn
+from ._enums import GuardrailExecutionStage
+from ._models import GuardrailAction
+
+
+@runtime_checkable
+class GuardrailTargetAdapter(Protocol):
+    """Protocol for framework-specific guardrail adapters.
+
+    Implement this protocol to teach :func:`guardrail` how to handle objects
+    from a particular framework. Register instances via
+    :func:`register_guardrail_adapter`.
+    """
+
+    def recognize(self, target: Any) -> bool:
+        """Return ``True`` if this adapter handles *target*.
+
+        Args:
+            target: Object being decorated or returned by a factory function.
+
+        Returns:
+            ``True`` if this adapter can wrap *target*, ``False`` otherwise.
+        """
+        ...
+
+    def wrap(
+        self,
+        target: Any,
+        evaluator: _EvaluatorFn,
+        action: GuardrailAction,
+        name: str,
+        stage: GuardrailExecutionStage,
+    ) -> Any:
+        """Wrap *target* with guardrail enforcement logic.
+
+        Args:
+            target: Object to wrap.
+            evaluator: Unified evaluation callable from :func:`_make_evaluator`.
+            action: Action to invoke on validation failure.
+            name: Human-readable guardrail name.
+            stage: When to evaluate (PRE, POST, or PRE_AND_POST).
+
+        Returns:
+            Wrapped object, same type or duck-type compatible.
+        """
+        ...
+
+
+# Module-level registry. Later-registered adapters take priority (inserted at 0).
+_adapters: list[GuardrailTargetAdapter] = []
+
+
+def register_guardrail_adapter(adapter: GuardrailTargetAdapter) -> None:
+    """Register a framework adapter for the ``@guardrail`` decorator.
+
+    Later-registered adapters are tried first.
+
+    Args:
+        adapter: An instance implementing :class:`GuardrailTargetAdapter`.
+    """
+    _adapters.insert(0, adapter)
+
+
+def is_recognized_by_adapter(target: Any) -> bool:
+    """Return ``True`` if any registered adapter recognizes *target*.
+
+    Args:
+        target: The object being decorated.
+
+    Returns:
+        ``True`` if a registered adapter handles *target*.
+    """
+    for adapter in _adapters:
+        if adapter.recognize(target):
+            return True
+    return False
+
+
+def wrap_with_adapter(
+    target: Any,
+    evaluator: _EvaluatorFn,
+    action: GuardrailAction,
+    name: str,
+    stage: GuardrailExecutionStage,
+) -> Any:
+    """Ask the first matching adapter to wrap *target*.
+
+    Args:
+        target: The object to wrap.
+        evaluator: Unified evaluation callable.
+        action: Action on violation.
+        name: Guardrail name.
+        stage: Execution stage.
+
+    Returns:
+        Wrapped object, or *target* unchanged if no adapter handles it.
+    """
+    for adapter in _adapters:
+        if adapter.recognize(target):
+            return adapter.wrap(target, evaluator, action, name, stage)
+    return target
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/__init__.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/__init__.py
new file mode 100644
index 000000000..bbcf29039
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/__init__.py
@@ -0,0 +1,26 @@
+"""Guardrail validators for the ``@guardrail`` decorator."""
+
+from ._base import (
+    BuiltInGuardrailValidator,
+    CustomGuardrailValidator,
+    GuardrailValidatorBase,
+)
+from .custom import CustomValidator, RuleFunction
+from .harmful_content import HarmfulContentValidator
+from .intellectual_property import IntellectualPropertyValidator
+from .pii import PIIValidator
+from .prompt_injection import PromptInjectionValidator
+from .user_prompt_attacks import UserPromptAttacksValidator
+
+__all__ = [
+    "GuardrailValidatorBase",
+    "BuiltInGuardrailValidator",
+    "CustomGuardrailValidator",
+    "HarmfulContentValidator",
+    "IntellectualPropertyValidator",
+    "PIIValidator",
+    "PromptInjectionValidator",
+    "UserPromptAttacksValidator",
+    "CustomValidator",
+    "RuleFunction",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/_base.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/_base.py
new file mode 100644
index 000000000..a9eaf5afd
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/_base.py
@@ -0,0 +1,182 @@
+"""Abstract base classes for guardrail validators."""
+
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+from uipath.core.guardrails import GuardrailValidationResult
+
+from uipath.platform.guardrails.guardrails import BuiltInValidatorGuardrail
+
+from .._enums import GuardrailExecutionStage
+
+
+class GuardrailValidatorBase:
+    """Root base class for guardrail validators.
+
+    Concrete validators should subclass either
+    :class:`BuiltInGuardrailValidator` (for UiPath API-backed validation)
+    or :class:`CustomGuardrailValidator` (for in-process Python validation).
+    """
+
+    supported_stages: ClassVar[list[GuardrailExecutionStage]] = []
+    """Stages this validator supports. Empty list means all stages are allowed."""
+
+    def validate_stage(self, stage: GuardrailExecutionStage) -> None:
+        """Raise ``ValueError`` if *stage* is not in :attr:`supported_stages`.
+
+        Args:
+            stage: Requested execution stage.
+
+        Raises:
+            ValueError: If :attr:`supported_stages` is non-empty and *stage* is absent.
+        """
+        if self.supported_stages and stage not in self.supported_stages:
+            raise ValueError(
+                f"{type(self).__name__} does not support stage {stage!r}. "
+                f"Supported stages: {[s.value for s in self.supported_stages]}"
+            )
+
+    def run(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+        data: "str | dict[str, Any]",
+        stage: GuardrailExecutionStage,
+        input_data: "dict[str, Any] | None",
+        output_data: "dict[str, Any] | None",
+    ) -> GuardrailValidationResult:
+        """Execute the guardrail evaluation.
+
+        Called by the ``@guardrail`` decorator at each function invocation.
+        Subclasses override this via :class:`BuiltInGuardrailValidator` or
+        :class:`CustomGuardrailValidator`.
+
+        Raises:
+            NotImplementedError: Always — subclass one of the two ABCs instead.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} must subclass BuiltInGuardrailValidator "
+            "or CustomGuardrailValidator and implement the required abstract method."
+        )
+
+
+class BuiltInGuardrailValidator(GuardrailValidatorBase, ABC):
+    """Base for validators that delegate to the UiPath Guardrails API.
+
+    Subclass this and implement :meth:`get_built_in_guardrail` to create an
+    API-backed guardrail validator (e.g. PII detection, prompt injection).
+
+    Example::
+
+        class MyValidator(BuiltInGuardrailValidator):
+            def get_built_in_guardrail(self, name, description, enabled_for_evals):
+                return BuiltInValidatorGuardrail(
+                    id=str(uuid4()),
+                    name=name,
+                    ...
+                )
+    """
+
+    @abstractmethod
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build the UiPath API guardrail definition for this validator.
+
+        Args:
+            name: Name for the guardrail instance.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            :class:`BuiltInValidatorGuardrail` ready to be sent to the API.
+        """
+        ...
+
+    def run(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+        data: "str | dict[str, Any]",
+        stage: GuardrailExecutionStage,
+        input_data: "dict[str, Any] | None",
+        output_data: "dict[str, Any] | None",
+    ) -> GuardrailValidationResult:
+        """Evaluate via the UiPath Guardrails API.
+
+        Lazily initialises the ``UiPath`` client on the first call and reuses
+        it for all subsequent invocations.
+        """
+        built_in = self.get_built_in_guardrail(name, description, enabled_for_evals)
+        if not hasattr(self, "_uipath"):
+            from uipath.platform import UiPath
+
+            self._uipath: Any = UiPath()
+        return self._uipath.guardrails.evaluate_guardrail(data, built_in)
+
+
+class CustomGuardrailValidator(GuardrailValidatorBase, ABC):
+    """Base for validators that run entirely in-process.
+
+    Subclass this and implement :meth:`evaluate` to create a local guardrail
+    validator that requires no UiPath API call.
+
+    Example::
+
+        class ProfanityValidator(CustomGuardrailValidator):
+            BANNED = {"badword"}
+
+            def evaluate(self, data, stage, input_data, output_data):
+                text = (input_data or {}).get("message", "")
+                if any(w in text.lower() for w in self.BANNED):
+                    return GuardrailValidationResult(
+                        result=GuardrailValidationResultType.VALIDATION_FAILED,
+                        reason="Profanity detected",
+                    )
+                return GuardrailValidationResult(result=GuardrailValidationResultType.PASSED)
+    """
+
+    @abstractmethod
+    def evaluate(
+        self,
+        data: "str | dict[str, Any]",
+        stage: GuardrailExecutionStage,
+        input_data: "dict[str, Any] | None",
+        output_data: "dict[str, Any] | None",
+    ) -> GuardrailValidationResult:
+        """Perform local validation without a UiPath API call.
+
+        Return a result with ``VALIDATION_FAILED`` to **trigger** the guardrail
+        (causing the configured :class:`~uipath.platform.guardrails.decorators.GuardrailAction`
+        to fire), or ``PASSED`` to let execution continue unchanged.
+
+        Args:
+            data: Primary data being evaluated.
+            stage: Current execution stage (PRE or POST).
+            input_data: Normalised function input dict, or ``None``.
+            output_data: Normalised function output dict, or ``None`` at PRE stage.
+
+        Returns:
+            :class:`~uipath.core.guardrails.GuardrailValidationResult` —
+            return ``VALIDATION_FAILED`` to activate the guardrail,
+            ``PASSED`` to allow execution to continue.
+        """
+        ...
+
+    def run(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+        data: "str | dict[str, Any]",
+        stage: GuardrailExecutionStage,
+        input_data: "dict[str, Any] | None",
+        output_data: "dict[str, Any] | None",
+    ) -> GuardrailValidationResult:
+        """Delegate to :meth:`evaluate`."""
+        return self.evaluate(data, stage, input_data, output_data)
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/custom.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/custom.py
new file mode 100644
index 000000000..df6549600
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/custom.py
@@ -0,0 +1,125 @@
+"""Custom (rule-based) guardrail validator."""
+
+import inspect
+from typing import Any, Callable
+
+from uipath.core.guardrails import (
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+)
+
+from .._enums import GuardrailExecutionStage
+from ._base import CustomGuardrailValidator
+
+RuleFunction = (
+    Callable[[dict[str, Any]], bool] | Callable[[dict[str, Any], dict[str, Any]], bool]
+)
+"""Type alias for custom rule functions passed to :class:`CustomValidator`.
+
+The rule must return ``True`` to **trigger** the guardrail (i.e. signal a
+violation that causes the configured action to fire), or ``False`` to let
+execution continue unchanged.
+
+It accepts either one parameter (the input or output dict) or two parameters
+(input dict, output dict — POST stage only).
+
+Examples::
+
+    # Triggered when "donkey" appears in the joke argument
+    CustomValidator(lambda args: "donkey" in args.get("joke", "").lower())
+
+    # Triggered when the output joke exceeds 500 characters
+    CustomValidator(lambda args: len(args.get("joke", "")) > 500)
+
+    # Two-parameter form: triggered at POST when output contains input keyword
+    CustomValidator(lambda inp, out: inp.get("topic", "") in out.get("joke", ""))
+"""
+
+
+class CustomValidator(CustomGuardrailValidator):
+    """Validate function input/output using a local Python rule function.
+
+    No UiPath API call is made. Applicable at any stage.
+
+    The *rule* is called with the collected parameter dict (PRE stage) or the
+    serialised return-value dict (POST stage).  It must return ``True`` to
+    **activate** the guardrail — i.e. to signal a violation and invoke the
+    configured :class:`~uipath.platform.guardrails.decorators.GuardrailAction`.
+    Return ``False`` (or any falsy value) to let execution continue unchanged.
+
+    Args:
+        rule: A :data:`RuleFunction` that returns ``True`` to trigger the
+            guardrail.  Must accept 1 or 2 parameters.
+
+    Raises:
+        ValueError: If *rule* is not callable or has an unsupported parameter count.
+    """
+
+    def __init__(self, rule: RuleFunction) -> None:
+        """Initialize CustomValidator with a rule callable."""
+        if not callable(rule):
+            raise ValueError(f"rule must be callable, got {type(rule)}")
+        sig = inspect.signature(rule)
+        param_count = len(sig.parameters)
+        if param_count not in (1, 2):
+            raise ValueError(f"rule must have 1 or 2 parameters, got {param_count}")
+        self.rule = rule
+        self._param_count = param_count
+
+    def evaluate(
+        self,
+        data: str | dict[str, Any],
+        stage: GuardrailExecutionStage,
+        input_data: dict[str, Any] | None,
+        output_data: dict[str, Any] | None,
+    ) -> GuardrailValidationResult:
+        """Run the rule against the collected input or output dict.
+
+        The rule receives the PRE parameter dict or POST return-value dict and
+        must return ``True`` to **trigger** the guardrail (VALIDATION_FAILED),
+        or ``False`` to pass.
+
+        Args:
+            data: Unused; the rule operates on *input_data* or *output_data*.
+            stage: Current stage (PRE or POST).
+            input_data: Collected function input dict.
+            output_data: Collected function output dict, or ``None`` at PRE stage.
+
+        Returns:
+            :class:`~uipath.core.guardrails.GuardrailValidationResult` —
+            ``VALIDATION_FAILED`` when the rule returns ``True`` (guardrail
+            triggered), ``PASSED`` otherwise.
+        """
+        try:
+            if self._param_count == 2:
+                if input_data is None or output_data is None:
+                    return GuardrailValidationResult(
+                        result=GuardrailValidationResultType.PASSED,
+                        reason="Two-parameter rule skipped: input or output data unavailable",
+                    )
+                violation = self.rule(input_data, output_data)  # type: ignore[call-arg]
+            else:
+                target = (
+                    input_data if stage == GuardrailExecutionStage.PRE else output_data
+                )
+                if target is None:
+                    return GuardrailValidationResult(
+                        result=GuardrailValidationResultType.PASSED,
+                        reason="Rule skipped: data unavailable at this stage",
+                    )
+                violation = self.rule(target)  # type: ignore[call-arg]
+        except Exception as exc:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.PASSED,
+                reason=f"Rule raised exception: {exc}",
+            )
+
+        if violation:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.VALIDATION_FAILED,
+                reason="Rule detected violation",
+            )
+        return GuardrailValidationResult(
+            result=GuardrailValidationResultType.PASSED,
+            reason="Rule passed",
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/harmful_content.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/harmful_content.py
new file mode 100644
index 000000000..d186341d7
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/harmful_content.py
@@ -0,0 +1,77 @@
+"""Harmful content detection guardrail validator."""
+
+from typing import Any, Sequence
+from uuid import uuid4
+
+from uipath.platform.guardrails.guardrails import (
+    BuiltInValidatorGuardrail,
+    EnumListParameterValue,
+    MapEnumParameterValue,
+)
+
+from .._models import HarmfulContentEntity
+from ._base import BuiltInGuardrailValidator
+
+
+class HarmfulContentValidator(BuiltInGuardrailValidator):
+    """Validate data for harmful content using the UiPath API.
+
+    Supported at all stages (PRE, POST, PRE_AND_POST).
+
+    Args:
+        entities: One or more :class:`~uipath.platform.guardrails.decorators.HarmfulContentEntity`
+            instances specifying which harmful content categories to detect
+            and their severity thresholds.
+
+    Raises:
+        ValueError: If *entities* is empty.
+    """
+
+    def __init__(self, entities: Sequence[HarmfulContentEntity]) -> None:
+        """Initialize HarmfulContentValidator with entities to detect."""
+        if not entities:
+            raise ValueError("entities must be provided and non-empty")
+        self.entities = list(entities)
+
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build a harmful content :class:`BuiltInValidatorGuardrail`.
+
+        Args:
+            name: Name for the guardrail.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            Configured :class:`BuiltInValidatorGuardrail` for harmful content detection.
+        """
+        entity_names = [entity.name for entity in self.entities]
+        entity_thresholds: dict[str, Any] = {
+            entity.name: entity.threshold for entity in self.entities
+        }
+
+        return BuiltInValidatorGuardrail(
+            id=str(uuid4()),
+            name=name,
+            description=description
+            or f"Detects harmful content: {', '.join(entity_names)}",
+            enabled_for_evals=enabled_for_evals,
+            guardrail_type="builtInValidator",
+            validator_type="harmful_content",
+            validator_parameters=[
+                EnumListParameterValue(
+                    parameter_type="enum-list",
+                    id="harmfulContentEntities",
+                    value=entity_names,
+                ),
+                MapEnumParameterValue(
+                    parameter_type="map-enum",
+                    id="harmfulContentEntityThresholds",
+                    value=entity_thresholds,
+                ),
+            ],
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/intellectual_property.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/intellectual_property.py
new file mode 100644
index 000000000..8a18e6a37
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/intellectual_property.py
@@ -0,0 +1,67 @@
+"""Intellectual property detection guardrail validator."""
+
+from typing import Sequence
+from uuid import uuid4
+
+from uipath.platform.guardrails.guardrails import (
+    BuiltInValidatorGuardrail,
+    EnumListParameterValue,
+)
+
+from .._enums import GuardrailExecutionStage
+from ._base import BuiltInGuardrailValidator
+
+
+class IntellectualPropertyValidator(BuiltInGuardrailValidator):
+    """Validate output for intellectual property violations using the UiPath API.
+
+    Restricted to POST stage only — IP detection is an output-only concern.
+
+    Args:
+        entities: One or more entity type strings (e.g.
+            ``IntellectualPropertyEntityType.TEXT``).
+
+    Raises:
+        ValueError: If *entities* is empty.
+    """
+
+    supported_stages = [GuardrailExecutionStage.POST]
+
+    def __init__(self, entities: Sequence[str]) -> None:
+        """Initialize IntellectualPropertyValidator with entities to detect."""
+        if not entities:
+            raise ValueError("entities must be provided and non-empty")
+        self.entities = list(entities)
+
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build an intellectual property :class:`BuiltInValidatorGuardrail`.
+
+        Args:
+            name: Name for the guardrail.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            Configured :class:`BuiltInValidatorGuardrail` for IP detection.
+        """
+        return BuiltInValidatorGuardrail(
+            id=str(uuid4()),
+            name=name,
+            description=description
+            or f"Detects intellectual property: {', '.join(self.entities)}",
+            enabled_for_evals=enabled_for_evals,
+            guardrail_type="builtInValidator",
+            validator_type="intellectual_property",
+            validator_parameters=[
+                EnumListParameterValue(
+                    parameter_type="enum-list",
+                    id="ipEntities",
+                    value=self.entities,
+                ),
+            ],
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/pii.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/pii.py
new file mode 100644
index 000000000..64d0a47aa
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/pii.py
@@ -0,0 +1,76 @@
+"""PII detection guardrail validator."""
+
+from typing import Any, Sequence
+from uuid import uuid4
+
+from uipath.platform.guardrails.guardrails import (
+    BuiltInValidatorGuardrail,
+    EnumListParameterValue,
+    MapEnumParameterValue,
+)
+
+from .._models import PIIDetectionEntity
+from ._base import BuiltInGuardrailValidator
+
+
+class PIIValidator(BuiltInGuardrailValidator):
+    """Validate data for PII entities using the UiPath PII detection API.
+
+    Supported at all stages.
+
+    Args:
+        entities: One or more :class:`~uipath.platform.guardrails.decorators.PIIDetectionEntity`
+            instances specifying which PII types to detect and their confidence thresholds.
+
+    Raises:
+        ValueError: If *entities* is empty.
+    """
+
+    def __init__(self, entities: Sequence[PIIDetectionEntity]) -> None:
+        """Initialize PIIValidator with a list of entities to detect."""
+        if not entities:
+            raise ValueError("entities must be provided and non-empty")
+        self.entities = list(entities)
+
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build a PII detection :class:`BuiltInValidatorGuardrail`.
+
+        Args:
+            name: Name for the guardrail.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            Configured :class:`BuiltInValidatorGuardrail` for PII detection.
+        """
+        entity_names = [entity.name for entity in self.entities]
+        entity_thresholds: dict[str, Any] = {
+            entity.name: entity.threshold for entity in self.entities
+        }
+
+        return BuiltInValidatorGuardrail(
+            id=str(uuid4()),
+            name=name,
+            description=description
+            or f"Detects PII entities: {', '.join(entity_names)}",
+            enabled_for_evals=enabled_for_evals,
+            guardrail_type="builtInValidator",
+            validator_type="pii_detection",
+            validator_parameters=[
+                EnumListParameterValue(
+                    parameter_type="enum-list",
+                    id="entities",
+                    value=entity_names,
+                ),
+                MapEnumParameterValue(
+                    parameter_type="map-enum",
+                    id="entityThresholds",
+                    value=entity_thresholds,
+                ),
+            ],
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/prompt_injection.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/prompt_injection.py
new file mode 100644
index 000000000..b0943b396
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/prompt_injection.py
@@ -0,0 +1,65 @@
+"""Prompt injection detection guardrail validator."""
+
+from uuid import uuid4
+
+from uipath.platform.guardrails.guardrails import (
+    BuiltInValidatorGuardrail,
+    NumberParameterValue,
+)
+
+from .._enums import GuardrailExecutionStage
+from ._base import BuiltInGuardrailValidator
+
+
+class PromptInjectionValidator(BuiltInGuardrailValidator):
+    """Validate input for prompt injection attacks via the UiPath API.
+
+    Restricted to PRE stage only — prompt injection is an input-only concern.
+
+    Args:
+        threshold: Detection confidence threshold (0.0–1.0). Defaults to ``0.5``.
+
+    Raises:
+        ValueError: If *threshold* is outside [0.0, 1.0].
+    """
+
+    supported_stages = [GuardrailExecutionStage.PRE]
+
+    def __init__(self, threshold: float = 0.5) -> None:
+        """Initialize PromptInjectionValidator with a detection threshold."""
+        if not 0.0 <= threshold <= 1.0:
+            raise ValueError(f"threshold must be between 0.0 and 1.0, got {threshold}")
+        self.threshold = threshold
+
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build a prompt injection :class:`BuiltInValidatorGuardrail`.
+
+        Args:
+            name: Name for the guardrail.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            Configured :class:`BuiltInValidatorGuardrail` for prompt injection.
+        """
+        return BuiltInValidatorGuardrail(
+            id=str(uuid4()),
+            name=name,
+            description=description
+            or f"Detects prompt injection with threshold {self.threshold}",
+            enabled_for_evals=enabled_for_evals,
+            guardrail_type="builtInValidator",
+            validator_type="prompt_injection",
+            validator_parameters=[
+                NumberParameterValue(
+                    parameter_type="number",
+                    id="threshold",
+                    value=self.threshold,
+                ),
+            ],
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/user_prompt_attacks.py b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/user_prompt_attacks.py
new file mode 100644
index 000000000..7275acc25
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/decorators/validators/user_prompt_attacks.py
@@ -0,0 +1,44 @@
+"""User prompt attacks detection guardrail validator."""
+
+from uuid import uuid4
+
+from uipath.platform.guardrails.guardrails import BuiltInValidatorGuardrail
+
+from .._enums import GuardrailExecutionStage
+from ._base import BuiltInGuardrailValidator
+
+
+class UserPromptAttacksValidator(BuiltInGuardrailValidator):
+    """Validate input for user prompt attacks via the UiPath API.
+
+    Restricted to PRE stage only — prompt attacks are an input-only concern.
+    Takes no parameters.
+    """
+
+    supported_stages = [GuardrailExecutionStage.PRE]
+
+    def get_built_in_guardrail(
+        self,
+        name: str,
+        description: str | None,
+        enabled_for_evals: bool,
+    ) -> BuiltInValidatorGuardrail:
+        """Build a user prompt attacks :class:`BuiltInValidatorGuardrail`.
+
+        Args:
+            name: Name for the guardrail.
+            description: Optional description.
+            enabled_for_evals: Whether active in evaluation scenarios.
+
+        Returns:
+            Configured :class:`BuiltInValidatorGuardrail` for user prompt attacks.
+        """
+        return BuiltInValidatorGuardrail(
+            id=str(uuid4()),
+            name=name,
+            description=description or "Detects user prompt attacks",
+            enabled_for_evals=enabled_for_evals,
+            guardrail_type="builtInValidator",
+            validator_type="user_prompt_attacks",
+            validator_parameters=[],
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/guardrails/guardrails.py b/packages/uipath-platform/src/uipath/platform/guardrails/guardrails.py
new file mode 100644
index 000000000..16262ca5e
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/guardrails/guardrails.py
@@ -0,0 +1,97 @@
+"""Guardrails models for UiPath Platform."""
+
+from enum import Enum
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+from uipath.core.guardrails import BaseGuardrail
+
+
+class EnumListParameterValue(BaseModel):
+    """Enum list parameter value."""
+
+    parameter_type: Literal["enum-list"] = Field(alias="$parameterType")
+    id: str
+    value: list[str]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class MapEnumParameterValue(BaseModel):
+    """Map enum parameter value."""
+
+    parameter_type: Literal["map-enum"] = Field(alias="$parameterType")
+    id: str
+    value: dict[str, float]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class NumberParameterValue(BaseModel):
+    """Number parameter value."""
+
+    parameter_type: Literal["number"] = Field(alias="$parameterType")
+    id: str
+    value: float
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class EnumParameterValue(BaseModel):
+    """Single-select enum parameter value."""
+
+    parameter_type: Literal["enum"] = Field(alias="$parameterType")
+    id: str
+    value: str
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class TextParameterValue(BaseModel):
+    """Free-text parameter value."""
+
+    parameter_type: Literal["text"] = Field(alias="$parameterType")
+    id: str
+    value: str
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class TextListParameterValue(BaseModel):
+    """List-of-text parameter value."""
+
+    parameter_type: Literal["text-list"] = Field(alias="$parameterType")
+    id: str
+    value: list[str]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+ValidatorParameter = Annotated[
+    EnumListParameterValue
+    | MapEnumParameterValue
+    | NumberParameterValue
+    | EnumParameterValue
+    | TextParameterValue
+    | TextListParameterValue,
+    Field(discriminator="parameter_type"),
+]
+
+
+class BuiltInValidatorGuardrail(BaseGuardrail):
+    """Built-in validator guardrail model."""
+
+    guardrail_type: Literal["builtInValidator"] = Field(alias="$guardrailType")
+    validator_type: str = Field(alias="validatorType")
+    validator_parameters: list[ValidatorParameter] = Field(
+        default_factory=list, alias="validatorParameters"
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class GuardrailType(str, Enum):
+    """Guardrail type enumeration."""
+
+    BUILT_IN_VALIDATOR = "builtInValidator"
+    CUSTOM = "custom"
diff --git a/packages/uipath-platform/src/uipath/platform/identity/__init__.py b/packages/uipath-platform/src/uipath/platform/identity/__init__.py
new file mode 100644
index 000000000..c01c44c87
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/identity/__init__.py
@@ -0,0 +1,5 @@
+"""UiPath Identity Service."""
+
+from ._identity_service import IdentityService
+
+__all__ = ["IdentityService"]
diff --git a/packages/uipath-platform/src/uipath/platform/identity/_identity_service.py b/packages/uipath-platform/src/uipath/platform/identity/_identity_service.py
new file mode 100644
index 000000000..6a803a1f5
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/identity/_identity_service.py
@@ -0,0 +1,148 @@
+"""Identity service for UiPath authentication token operations."""
+
+from typing import Optional
+
+import httpx
+
+from ..common._http_config import get_httpx_client_kwargs
+from ..common.auth import TokenData
+
+
+class IdentityService:
+    """Service for interacting with the UiPath Identity server."""
+
+    def __init__(self, domain: str):
+        """Initialize the IdentityService.
+
+        Args:
+            domain: The base URL of the UiPath identity server (e.g., "https://cloud.uipath.com").
+        """
+        self._domain = domain
+
+    def refresh_access_token(
+        self,
+        refresh_token: str,
+        client_id: str,
+    ) -> TokenData:
+        """Refresh an access token using a refresh token.
+
+        Args:
+            refresh_token: The refresh token to exchange for a new access token.
+            client_id: The client ID of the application.
+
+        Returns:
+            TokenData containing the new access token and related information.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        url = f"{self._domain}/identity_/connect/token"
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": client_id,
+        }
+
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
+            response = client.post(url, data=data)
+            response.raise_for_status()
+            return TokenData.model_validate(response.json())
+
+    async def refresh_access_token_async(
+        self,
+        refresh_token: str,
+        client_id: str,
+    ) -> TokenData:
+        """Refresh an access token using a refresh token.
+
+        Args:
+            refresh_token: The refresh token to exchange for a new access token.
+            client_id: The client ID of the application.
+
+        Returns:
+            TokenData containing the new access token and related information.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        url = f"{self._domain}/identity_/connect/token"
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": client_id,
+        }
+
+        async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
+            response = await client.post(url, data=data)
+            response.raise_for_status()
+            return TokenData.model_validate(response.json())
+
+    def get_client_credentials_token(
+        self,
+        client_id: str,
+        client_secret: str,
+        scope: Optional[str] = "OR.Execution",
+    ) -> TokenData:
+        """Obtain an access token using client credentials grant.
+
+        Args:
+            client_id: The client ID of the application.
+            client_secret: The client secret of the application.
+            scope: The requested OAuth scopes (optional, default: "OR.Execution").
+
+        Returns:
+            TokenData containing the access token and related information.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        scope = scope or "OR.Execution"
+        url = f"{self._domain}/identity_/connect/token"
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "scope": scope,
+        }
+
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
+            response = client.post(url, data=data)
+            response.raise_for_status()
+            return TokenData.model_validate(response.json())
+
+    async def get_client_credentials_token_async(
+        self,
+        client_id: str,
+        client_secret: str,
+        scope: Optional[str] = "OR.Execution",
+    ) -> TokenData:
+        """Obtain an access token using client credentials grant.
+
+        Args:
+            client_id: The client ID of the application.
+            client_secret: The client secret of the application.
+            scope: The requested OAuth scopes (optional, default: "OR.Execution").
+
+        Returns:
+            TokenData containing the access token and related information.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        scope = scope or "OR.Execution"
+        url = f"{self._domain}/identity_/connect/token"
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "scope": scope,
+        }
+
+        async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
+            response = await client.post(url, data=data)
+            response.raise_for_status()
+            return TokenData.model_validate(response.json())
diff --git a/packages/uipath-platform/src/uipath/platform/memory/__init__.py b/packages/uipath-platform/src/uipath/platform/memory/__init__.py
new file mode 100644
index 000000000..31e364814
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/memory/__init__.py
@@ -0,0 +1,39 @@
+"""Init file for memory module."""
+
+from ._memory_service import MemoryService
+from .memory import (
+    CachedRecall,
+    EscalationMemoryIngestRequest,
+    EscalationMemoryMatch,
+    EscalationMemorySearchResponse,
+    FieldSettings,
+    MemoryMatch,
+    MemoryMatchField,
+    MemorySearchRequest,
+    MemorySearchResponse,
+    MemorySpace,
+    MemorySpaceCreateRequest,
+    MemorySpaceListResponse,
+    SearchField,
+    SearchMode,
+    SearchSettings,
+)
+
+__all__ = [
+    "CachedRecall",
+    "EscalationMemoryIngestRequest",
+    "EscalationMemoryMatch",
+    "EscalationMemorySearchResponse",
+    "FieldSettings",
+    "MemoryMatch",
+    "MemoryMatchField",
+    "MemorySearchRequest",
+    "MemorySearchResponse",
+    "MemoryService",
+    "MemorySpace",
+    "MemorySpaceCreateRequest",
+    "MemorySpaceListResponse",
+    "SearchField",
+    "SearchMode",
+    "SearchSettings",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/memory/_memory_service.py b/packages/uipath-platform/src/uipath/platform/memory/_memory_service.py
new file mode 100644
index 000000000..73d788f80
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/memory/_memory_service.py
@@ -0,0 +1,493 @@
+"""Memory Spaces service.
+
+Memory space CRUD (create/list) goes through ECS v2.
+Search and escalation memory operations go through LLMOps, which
+enriches traces/feedback before forwarding to ECS.
+"""
+
+from typing import Any, Optional
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator._folder_service import FolderService
+from .memory import (
+    EscalationMemoryIngestRequest,
+    EscalationMemorySearchResponse,
+    MemorySearchRequest,
+    MemorySearchResponse,
+    MemorySpace,
+    MemorySpaceCreateRequest,
+    MemorySpaceListResponse,
+)
+
+_MEMORY_SPACES_BASE = "/ecs_/v2/episodicmemories"
+_LLMOPS_AGENT_BASE = "/llmopstenant_/api/Agent/memory"
+
+
+class MemoryService(FolderContext, BaseService):
+    """Service for Agent Memory Spaces.
+
+    Agent Memory allows agents to persist context across jobs using dynamic
+    few-shot retrieval. Memory spaces are folder-scoped and managed via ECS.
+    Search is routed through LLMOps, which handles trace/feedback enrichment
+    and system prompt injection. Escalation memory enables agents to recall
+    previously resolved escalation outcomes.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: FolderService,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    # ── Memory space operations (ECS) ──────────────────────────────────
+
+    @resource_override(resource_type="memorySpace")
+    @traced(name="memory_create", run_type="uipath")
+    def create(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        is_encrypted: Optional[bool] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySpace:
+        """Create a new memory space.
+
+        Args:
+            name: The name of the memory space (max 128 chars).
+            description: Optional description (max 1024 chars).
+            is_encrypted: Whether the memory space should be encrypted.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySpace: The created memory space.
+        """
+        spec = self._create_spec(
+            name, description, is_encrypted, folder_key, folder_path
+        )
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        ).json()
+        return MemorySpace.model_validate(response)
+
+    @resource_override(resource_type="memorySpace")
+    @traced(name="memory_create", run_type="uipath")
+    async def create_async(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        is_encrypted: Optional[bool] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySpace:
+        """Asynchronously create a new memory space.
+
+        Args:
+            name: The name of the memory space (max 128 chars).
+            description: Optional description (max 1024 chars).
+            is_encrypted: Whether the memory space should be encrypted.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySpace: The created memory space.
+        """
+        spec = self._create_spec(
+            name, description, is_encrypted, folder_key, folder_path
+        )
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                json=spec.json,
+                headers=spec.headers,
+            )
+        ).json()
+        return MemorySpace.model_validate(response)
+
+    @traced(name="memory_list", run_type="uipath")
+    def list(
+        self,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        top: Optional[int] = None,
+        skip: Optional[int] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySpaceListResponse:
+        """List memory spaces with optional OData query parameters.
+
+        Args:
+            filter: OData $filter expression.
+            orderby: OData $orderby expression.
+            top: Maximum number of results.
+            skip: Number of results to skip.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySpaceListResponse: The list of memory spaces.
+        """
+        spec = self._list_spec(filter, orderby, top, skip, folder_key, folder_path)
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+        return MemorySpaceListResponse.model_validate(response)
+
+    @traced(name="memory_list", run_type="uipath")
+    async def list_async(
+        self,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        top: Optional[int] = None,
+        skip: Optional[int] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySpaceListResponse:
+        """Asynchronously list memory spaces.
+
+        Args:
+            filter: OData $filter expression.
+            orderby: OData $orderby expression.
+            top: Maximum number of results.
+            skip: Number of results to skip.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySpaceListResponse: The list of memory spaces.
+        """
+        spec = self._list_spec(filter, orderby, top, skip, folder_key, folder_path)
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+        return MemorySpaceListResponse.model_validate(response)
+
+    # ── Search (LLMOps) ───────────────────────────────────────────────
+
+    @traced(name="memory_search", run_type="uipath")
+    def search(
+        self,
+        memory_space_id: str,
+        request: MemorySearchRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySearchResponse:
+        """Search a memory space via LLMOps.
+
+        Returns search results with scores and a systemPromptInjection
+        string ready for the agent loop.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The search request payload.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySearchResponse: Results, metadata, and system prompt injection.
+        """
+        spec = self._search_spec(memory_space_id, folder_key, folder_path)
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+            headers=spec.headers,
+        ).json()
+        return MemorySearchResponse.model_validate(response)
+
+    @traced(name="memory_search", run_type="uipath")
+    async def search_async(
+        self,
+        memory_space_id: str,
+        request: MemorySearchRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> MemorySearchResponse:
+        """Asynchronously search a memory space via LLMOps.
+
+        Returns search results with scores and a systemPromptInjection
+        string ready for the agent loop.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The search request payload.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            MemorySearchResponse: Results, metadata, and system prompt injection.
+        """
+        spec = self._search_spec(memory_space_id, folder_key, folder_path)
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                json=request.model_dump(by_alias=True, exclude_none=True),
+                headers=spec.headers,
+            )
+        ).json()
+        return MemorySearchResponse.model_validate(response)
+
+    # ── Escalation memory (LLMOps) ────────────────────────────────────
+
+    @traced(name="memory_escalation_search", run_type="uipath")
+    def escalation_search(
+        self,
+        memory_space_id: str,
+        request: MemorySearchRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> EscalationMemorySearchResponse:
+        """Search escalation memory for previously resolved outcomes.
+
+        Allows agents to recall past escalation resolutions to avoid
+        re-escalating for similar situations.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The search request payload (same as regular search).
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            EscalationMemorySearchResponse: Matched escalation outcomes.
+        """
+        spec = self._escalation_search_spec(memory_space_id, folder_key, folder_path)
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+            headers=spec.headers,
+        ).json()
+        return EscalationMemorySearchResponse.model_validate(response)
+
+    @traced(name="memory_escalation_search", run_type="uipath")
+    async def escalation_search_async(
+        self,
+        memory_space_id: str,
+        request: MemorySearchRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> EscalationMemorySearchResponse:
+        """Asynchronously search escalation memory for previously resolved outcomes.
+
+        Allows agents to recall past escalation resolutions to avoid
+        re-escalating for similar situations.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The search request payload (same as regular search).
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+
+        Returns:
+            EscalationMemorySearchResponse: Matched escalation outcomes.
+        """
+        spec = self._escalation_search_spec(memory_space_id, folder_key, folder_path)
+        response = (
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                json=request.model_dump(by_alias=True, exclude_none=True),
+                headers=spec.headers,
+            )
+        ).json()
+        return EscalationMemorySearchResponse.model_validate(response)
+
+    @traced(name="memory_escalation_ingest", run_type="uipath")
+    def escalation_ingest(
+        self,
+        memory_space_id: str,
+        request: EscalationMemoryIngestRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Ingest a resolved escalation outcome into memory.
+
+        Persists the outcome so future agent runs can recall it
+        without re-escalating.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The escalation ingest payload.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+        """
+        spec = self._escalation_ingest_spec(memory_space_id, folder_key, folder_path)
+        self.request(
+            spec.method,
+            spec.endpoint,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+            headers=spec.headers,
+        )
+
+    @traced(name="memory_escalation_ingest", run_type="uipath")
+    async def escalation_ingest_async(
+        self,
+        memory_space_id: str,
+        request: EscalationMemoryIngestRequest,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously ingest a resolved escalation outcome into memory.
+
+        Persists the outcome so future agent runs can recall it
+        without re-escalating.
+
+        Args:
+            memory_space_id: The GUID of the memory space.
+            request: The escalation ingest payload.
+            folder_key: The folder key for the operation.
+            folder_path: The folder path for the operation.
+        """
+        spec = self._escalation_ingest_spec(memory_space_id, folder_key, folder_path)
+        await self.request_async(
+            spec.method,
+            spec.endpoint,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+            headers=spec.headers,
+        )
+
+    # ── Private spec builders ─────────────────────────────────────────
+
+    def _resolve_folder(
+        self,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Resolve the folder key, supporting folder_path lookup for serverless.
+
+        Priority:
+        1. Explicit folder_key argument
+        2. Explicit folder_path argument → resolve via FolderService
+        3. UIPATH_FOLDER_KEY env var (via FolderContext._folder_key)
+        4. UIPATH_FOLDER_PATH env var → resolve via FolderService
+        """
+        if folder_key is None and folder_path is not None:
+            folder_key = self._folders_service.retrieve_key(folder_path=folder_path)
+
+        if folder_key is None and folder_path is None:
+            folder_key = self._folder_key or (
+                self._folders_service.retrieve_key(folder_path=self._folder_path)
+                if self._folder_path
+                else None
+            )
+
+        return folder_key
+
+    # -- ECS specs --
+
+    def _create_spec(
+        self,
+        name: str,
+        description: Optional[str],
+        is_encrypted: Optional[bool],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder(folder_key, folder_path)
+        body = MemorySpaceCreateRequest(
+            name=name,
+            description=description,
+            is_encrypted=is_encrypted,
+        )
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"{_MEMORY_SPACES_BASE}/create"),
+            json=body.model_dump(by_alias=True, exclude_none=True),
+            headers={**header_folder(folder_key, None)},
+        )
+
+    def _list_spec(
+        self,
+        filter: Optional[str],
+        orderby: Optional[str],
+        top: Optional[int],
+        skip: Optional[int],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder(folder_key, folder_path)
+        params: dict[str, Any] = {}
+        if filter is not None:
+            params["$filter"] = filter
+        if orderby is not None:
+            params["$orderby"] = orderby
+        if top is not None:
+            params["$top"] = top
+        if skip is not None:
+            params["$skip"] = skip
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(_MEMORY_SPACES_BASE),
+            params=params,
+            headers={**header_folder(folder_key, None)},
+        )
+
+    # -- LLMOps specs --
+
+    def _search_spec(
+        self,
+        memory_space_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder(folder_key, folder_path)
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(f"{_LLMOPS_AGENT_BASE}/{memory_space_id}/search"),
+            headers={**header_folder(folder_key, None)},
+        )
+
+    def _escalation_search_spec(
+        self,
+        memory_space_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder(folder_key, folder_path)
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"{_LLMOPS_AGENT_BASE}/{memory_space_id}/escalation/search"
+            ),
+            headers={**header_folder(folder_key, None)},
+        )
+
+    def _escalation_ingest_spec(
+        self,
+        memory_space_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder(folder_key, folder_path)
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"{_LLMOPS_AGENT_BASE}/{memory_space_id}/escalation/ingest"
+            ),
+            headers={**header_folder(folder_key, None)},
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/memory/memory.py b/packages/uipath-platform/src/uipath/platform/memory/memory.py
new file mode 100644
index 000000000..aadffbc79
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/memory/memory.py
@@ -0,0 +1,191 @@
+"""Pydantic models for the Memory Spaces API.
+
+Memory space CRUD goes through ECS v2. Search goes through LLMOps,
+which enriches traces/feedback before forwarding to ECS.
+Escalation memory operations also go through LLMOps.
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+# ── Enums ──────────────────────────────────────────────────────────────
+
+
+class SearchMode(str, Enum):
+    """Search mode for memory space queries."""
+
+    Hybrid = "Hybrid"
+    Semantic = "Semantic"
+
+
+# ── Shared field models (used by both ECS and LLMOps) ─────────────────
+
+
+class FieldSettings(BaseModel):
+    """Per-field search settings (optional overrides)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    weight: float = Field(default=1.0, alias="weight", ge=0.0, le=1.0)
+    threshold: Optional[float] = Field(None, alias="threshold", ge=0.0, le=1.0)
+    search_mode: Optional[SearchMode] = Field(None, alias="searchMode")
+
+
+class SearchField(BaseModel):
+    """A field in a search request, with per-field settings."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    key_path: List[str] = Field(..., alias="keyPath", min_length=1)
+    value: str = Field(..., alias="value", min_length=1)
+    settings: FieldSettings = Field(default_factory=FieldSettings, alias="settings")
+
+
+class SearchSettings(BaseModel):
+    """Top-level search settings."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    threshold: float = Field(default=0.0, alias="threshold", ge=0.0, le=1.0)
+    result_count: int = Field(default=1, alias="resultCount", ge=1, le=10)
+    search_mode: SearchMode = Field(..., alias="searchMode")
+
+
+class MemoryMatchField(BaseModel):
+    """A field within a search result, with scoring details."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    key_path: List[str] = Field(..., alias="keyPath")
+    value: str = Field(..., alias="value")
+    weight: float = Field(..., alias="weight")
+    score: float = Field(..., alias="score")
+    weighted_score: float = Field(..., alias="weightedScore")
+
+
+# ── ECS request models (memory space CRUD) ────────────────────────────
+
+
+class MemorySpaceCreateRequest(BaseModel):
+    """Request payload for creating a memory space (ECS)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str = Field(..., alias="name", max_length=128, min_length=1)
+    description: Optional[str] = Field(None, alias="description", max_length=1024)
+    is_encrypted: Optional[bool] = Field(None, alias="isEncrypted")
+
+
+# ── ECS response models ───────────────────────────────────────────────
+
+
+class MemorySpace(BaseModel):
+    """A memory space (folder-scoped, from ECS)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str = Field(..., alias="id")
+    name: str = Field(..., alias="name")
+    description: Optional[str] = Field(None, alias="description")
+    last_queried: Optional[str] = Field(None, alias="lastQueried")
+    memories_count: int = Field(default=0, alias="memoriesCount")
+    folder_key: str = Field(..., alias="folderKey")
+    created_by_user_id: Optional[str] = Field(None, alias="createdByUserId")
+    is_encrypted: bool = Field(default=False, alias="isEncrypted")
+
+
+class MemorySpaceListResponse(BaseModel):
+    """OData response from listing memory spaces (ECS)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    value: List[MemorySpace] = Field(default_factory=list, alias="value")
+
+
+# ── LLMOps search models ──────────────────────────────────────────────
+
+
+class MemorySearchRequest(BaseModel):
+    """Request payload for searching memory via LLMOps.
+
+    Includes definitionSystemPrompt so LLMOps can generate the
+    systemPromptInjection for the agent loop.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    fields: List[SearchField] = Field(..., alias="fields", min_length=1, max_length=20)
+    settings: SearchSettings = Field(..., alias="settings")
+    definition_system_prompt: Optional[str] = Field(
+        None, alias="definitionSystemPrompt"
+    )
+
+
+class MemoryMatch(BaseModel):
+    """A single matched memory from a search operation (LLMOps)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    memory_item_id: str = Field(..., alias="memoryItemId")
+    score: float = Field(..., alias="score")
+    semantic_score: float = Field(..., alias="semanticScore")
+    weighted_score: float = Field(..., alias="weightedScore")
+    fields: List[MemoryMatchField] = Field(..., alias="fields")
+    span: Optional[Any] = Field(None, alias="span")
+    feedback: Optional[Any] = Field(None, alias="feedback")
+
+
+class MemorySearchResponse(BaseModel):
+    """Response from LLMOps search, including system prompt injection."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    results: List[MemoryMatch] = Field(default_factory=list, alias="results")
+    metadata: Dict[str, str] = Field(default_factory=dict, alias="metadata")
+    system_prompt_injection: str = Field("", alias="systemPromptInjection")
+
+
+# ── LLMOps escalation memory models ──────────────────────────────────
+
+
+class EscalationMemoryIngestRequest(BaseModel):
+    """Request payload for ingesting an escalation outcome into memory.
+
+    Used by the escalation tool to persist resolved outcomes so
+    future runs can recall them without re-escalating.
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    span_id: str = Field(..., alias="spanId")
+    trace_id: str = Field(..., alias="traceId")
+    answer: str = Field(..., alias="answer")
+    attributes: str = Field(..., alias="attributes")
+    user_id: Optional[str] = Field(None, alias="userId")
+
+
+class CachedRecall(BaseModel):
+    """A cached escalation answer retrieved from memory."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    output: Optional[Any] = Field(None, alias="output")
+    outcome: Optional[str] = Field(None, alias="outcome")
+
+
+class EscalationMemoryMatch(BaseModel):
+    """A single match from an escalation memory search."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    answer: Optional[CachedRecall] = Field(None, alias="answer")
+
+
+class EscalationMemorySearchResponse(BaseModel):
+    """Response from LLMOps escalation memory search."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    results: Optional[List[EscalationMemoryMatch]] = Field(None, alias="results")
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/__init__.py b/packages/uipath-platform/src/uipath/platform/orchestrator/__init__.py
new file mode 100644
index 000000000..79d6dde30
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/__init__.py
@@ -0,0 +1,64 @@
+"""UiPath Orchestrator Models.
+
+This module contains models related to UiPath Orchestrator services.
+"""
+
+from ._assets_service import AssetsService
+from ._attachments_service import AttachmentsService
+from ._buckets_service import BucketsService
+from ._folder_service import FolderService
+from ._jobs_service import JobsService
+from ._mcp_service import McpService
+from ._orchestrator_setup_service import OrchestratorSetupService
+from ._processes_service import ProcessesService
+from ._queues_service import QueuesService
+from ._server_version import (
+    get_server_info_async,
+    get_server_version,
+    get_server_version_async,
+)
+from .assets import Asset, UserAsset
+from .attachment import Attachment
+from .buckets import Bucket, BucketFile
+from .job import Job, JobErrorInfo, JobState
+from .mcp import McpServer, McpServerStatus, McpServerType
+from .processes import Process
+from .queues import (
+    CommitType,
+    QueueItem,
+    QueueItemPriority,
+    TransactionItem,
+    TransactionItemResult,
+)
+
+__all__ = [
+    "AssetsService",
+    "AttachmentsService",
+    "BucketsService",
+    "FolderService",
+    "JobsService",
+    "McpService",
+    "ProcessesService",
+    "QueuesService",
+    "OrchestratorSetupService",
+    "get_server_info_async",
+    "get_server_version",
+    "get_server_version_async",
+    "Asset",
+    "UserAsset",
+    "Attachment",
+    "Bucket",
+    "BucketFile",
+    "Job",
+    "JobErrorInfo",
+    "JobState",
+    "Process",
+    "CommitType",
+    "QueueItem",
+    "QueueItemPriority",
+    "TransactionItem",
+    "TransactionItemResult",
+    "McpServer",
+    "McpServerStatus",
+    "McpServerType",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_assets_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_assets_service.py
new file mode 100644
index 000000000..2e673fb7c
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_assets_service.py
@@ -0,0 +1,717 @@
+from typing import Any, Dict, Optional
+
+from httpx import Response
+from uipath.core import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..common.paging import PagedResult
+from ..common.validation import validate_pagination_params
+from .assets import Asset, UserAsset
+
+
+class AssetsService(FolderContext, BaseService):
+    """Service for managing UiPath assets.
+
+    Assets are key-value pairs that can be used to store configuration data,
+    credentials, and other settings used by automation processes.
+    """
+
+    # Pagination limits
+    MAX_PAGE_SIZE = 1000  # Maximum items per page
+    MAX_SKIP_OFFSET = 10000  # Maximum skip offset
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._base_url = "assets"
+
+    @traced(name="assets_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Asset]:
+        """List assets using OData API with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+
+        Args:
+            folder_path: Folder path to filter assets.
+            folder_key: Folder key (mutually exclusive with folder_path).
+            filter: OData $filter expression (e.g., "ValueType eq 'Text'").
+            orderby: OData $orderby expression (e.g., "Name asc").
+            skip: Number of items to skip (default 0, max 10000).
+            top: Maximum items per page (default 100, max 1000).
+
+        Returns:
+            PagedResult[Asset]: Page of assets with pagination metadata.
+
+        Raises:
+            ValueError: If skip or top parameters are invalid.
+
+        Examples:
+            ```python
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            # List all assets in the default folder
+            result = client.assets.list(top=100)
+            for asset in result.items:
+                print(asset.name, asset.value_type)
+
+            # List with filter
+            result = client.assets.list(filter="ValueType eq 'Text'")
+
+            # Paginate through all assets
+            skip = 0
+            while True:
+                result = client.assets.list(skip=skip, top=100)
+                for asset in result.items:
+                    print(asset.name)
+                if not result.has_more:
+                    break
+                skip += 100
+            ```
+        """
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=self.MAX_SKIP_OFFSET,
+            max_top=self.MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            filter=filter,
+            orderby=orderby,
+            skip=skip,
+            top=top,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        items = response.get("value", [])
+        assets = [Asset.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=assets,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @traced(name="assets_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Asset]:
+        """Asynchronously list assets using OData API with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+
+        Args:
+            folder_path: Folder path to filter assets.
+            folder_key: Folder key (mutually exclusive with folder_path).
+            filter: OData $filter expression (e.g., "ValueType eq 'Text'").
+            orderby: OData $orderby expression (e.g., "Name asc").
+            skip: Number of items to skip (default 0, max 10000).
+            top: Maximum items per page (default 100, max 1000).
+
+        Returns:
+            PagedResult[Asset]: Page of assets with pagination metadata.
+
+        Raises:
+            ValueError: If skip or top parameters are invalid.
+        """
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=self.MAX_SKIP_OFFSET,
+            max_top=self.MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            filter=filter,
+            orderby=orderby,
+            skip=skip,
+            top=top,
+        )
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        items = response.get("value", [])
+        assets = [Asset.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=assets,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @resource_override(resource_type="asset")
+    @traced(
+        name="assets_retrieve", run_type="uipath", hide_input=True, hide_output=True
+    )
+    def retrieve(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> UserAsset | Asset:
+        """Retrieve an asset by its name.
+
+        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
+
+        Args:
+            name (str): The name of the asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+           UserAsset: The asset data.
+
+        Examples:
+            ```python
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            client.assets.retrieve(name="MyAsset")
+            ```
+        """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        spec = self._retrieve_spec(
+            name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            content=spec.content,
+            headers=spec.headers,
+            json=spec.json,
+        )
+
+        if is_user:
+            return UserAsset.model_validate(response.json())
+        else:
+            return Asset.model_validate(response.json()["value"][0])
+
+    @resource_override(resource_type="asset")
+    @traced(
+        name="assets_retrieve", run_type="uipath", hide_input=True, hide_output=True
+    )
+    async def retrieve_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> UserAsset | Asset:
+        """Asynchronously retrieve an asset by its name.
+
+        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
+
+        Args:
+            name (str): The name of the asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            UserAsset: The asset data.
+        """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        spec = self._retrieve_spec(
+            name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            content=spec.content,
+            headers=spec.headers,
+            json=spec.json,
+        )
+
+        if is_user:
+            return UserAsset.model_validate(response.json())
+        else:
+            return Asset.model_validate(response.json()["value"][0])
+
+    def _resolve_robot_key(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Return the robot key, or ``None`` if the asset opts into direct API access.
+
+        Raises ``ValueError`` when no robot key is available and ``AllowDirectApiAccess``
+        is not enabled on the asset.
+        """
+        try:
+            robot_key = self._execution_context.robot_key
+        except ValueError:
+            robot_key = None
+
+        if robot_key is None:
+            asset = self.retrieve(
+                name=name, folder_key=folder_key, folder_path=folder_path
+            )
+            if not asset.allow_direct_api_access:
+                raise ValueError(
+                    f"No robot key available and 'AllowDirectApiAccess' is disabled for asset '{name}'."
+                )
+        return robot_key
+
+    async def _resolve_robot_key_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Async variant of :meth:`_resolve_robot_key`."""
+        try:
+            robot_key = self._execution_context.robot_key
+        except ValueError:
+            robot_key = None
+
+        if robot_key is None:
+            asset = await self.retrieve_async(
+                name=name, folder_key=folder_key, folder_path=folder_path
+            )
+            if not asset.allow_direct_api_access:
+                raise ValueError(
+                    f"No robot key available and 'AllowDirectApiAccess' is disabled for asset '{name}'."
+                )
+        return robot_key
+
+    @resource_override(resource_type="asset")
+    @traced(
+        name="assets_credential", run_type="uipath", hide_input=True, hide_output=True
+    )
+    def retrieve_credential(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Get the decrypted password of a Credential asset.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable).
+        If no robot key is available, the asset's `AllowDirectApiAccess` flag is checked: when
+        enabled, the credential is fetched without a robot key; otherwise a `ValueError` is raised.
+
+        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
+
+        Args:
+            name (str): The name of the credential asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted credential password.
+
+        Raises:
+            ValueError: If no robot key is available and the asset does not have `AllowDirectApiAccess` enabled.
+        """
+        robot_key = self._resolve_robot_key(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._retrieve_credential_spec(
+            name,
+            robot_key=robot_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        return UserAsset.model_validate(response.json()).credential_password
+
+    @resource_override(resource_type="asset")
+    @traced(
+        name="assets_credential", run_type="uipath", hide_input=True, hide_output=True
+    )
+    async def retrieve_credential_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Asynchronously get the decrypted password of a Credential asset.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable).
+        If no robot key is available, the asset's `AllowDirectApiAccess` flag is checked: when
+        enabled, the credential is fetched without a robot key; otherwise a `ValueError` is raised.
+
+        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
+
+        Args:
+            name (str): The name of the credential asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted credential password.
+
+        Raises:
+            ValueError: If no robot key is available and the asset does not have `AllowDirectApiAccess` enabled.
+        """
+        robot_key = await self._resolve_robot_key_async(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._retrieve_credential_spec(
+            name,
+            robot_key=robot_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        return UserAsset.model_validate(response.json()).credential_password
+
+    @resource_override(resource_type="asset")
+    @traced(name="assets_secret", run_type="uipath", hide_input=True, hide_output=True)
+    def retrieve_secret(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Get the decrypted value of a Secret asset.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable).
+        If no robot key is available, the asset's `AllowDirectApiAccess` flag is checked: when
+        enabled, the secret is fetched without a robot key; otherwise a `ValueError` is raised.
+
+        Args:
+            name (str): The name of the secret asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted secret value.
+
+        Raises:
+            ValueError: If no robot key is available and the asset does not have `AllowDirectApiAccess` enabled.
+        """
+        robot_key = self._resolve_robot_key(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._retrieve_credential_spec(
+            name,
+            robot_key=robot_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        return UserAsset.model_validate(response.json()).secret_value
+
+    @resource_override(resource_type="asset")
+    @traced(name="assets_secret", run_type="uipath", hide_input=True, hide_output=True)
+    async def retrieve_secret_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Asynchronously get the decrypted value of a Secret asset.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable).
+        If no robot key is available, the asset's `AllowDirectApiAccess` flag is checked: when
+        enabled, the secret is fetched without a robot key; otherwise a `ValueError` is raised.
+
+        Args:
+            name (str): The name of the secret asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted secret value.
+
+        Raises:
+            ValueError: If no robot key is available and the asset does not have `AllowDirectApiAccess` enabled.
+        """
+        robot_key = await self._resolve_robot_key_async(
+            name, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._retrieve_credential_spec(
+            name,
+            robot_key=robot_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+        return UserAsset.model_validate(response.json()).secret_value
+
+    @traced(name="assets_update", run_type="uipath", hide_input=True, hide_output=True)
+    def update(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Update an asset's value.
+
+        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
+
+        Args:
+            robot_asset (UserAsset): The asset object containing the updated values.
+
+        Returns:
+            Response: The HTTP response confirming the update.
+
+        Raises:
+            ValueError: If the method is called for a user asset.
+        """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        if not is_user:
+            raise ValueError("This method can only be used for robot assets.")
+
+        spec = self._update_spec(
+            robot_asset, folder_key=folder_key, folder_path=folder_path
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return response.json()
+
+    @traced(name="assets_update", run_type="uipath", hide_input=True, hide_output=True)
+    async def update_async(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously update an asset's value.
+
+        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
+
+        Args:
+            robot_asset (UserAsset): The asset object containing the updated values.
+
+        Returns:
+            Response: The HTTP response confirming the update.
+        """
+        spec = self._update_spec(
+            robot_asset, folder_key=folder_key, folder_path=folder_path
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return response.json()
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _retrieve_spec(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        try:
+            robot_key = self._execution_context.robot_key
+        except ValueError:
+            robot_key = None
+
+        if robot_key is None:
+            return RequestSpec(
+                method="GET",
+                endpoint=Endpoint(
+                    "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered",
+                ),
+                params={"$filter": f"Name eq '{name}'", "$top": 1},
+                headers={
+                    **header_folder(folder_key, folder_path),
+                },
+            )
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+            ),
+            json={
+                "assetName": name,
+                "robotKey": robot_key,
+                "supportsCredentialsProxyDisconnected": True,
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_credential_spec(
+        self,
+        name: str,
+        *,
+        robot_key: Optional[str],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        body: Dict[str, Any] = {
+            "assetName": name,
+            "supportsCredentialsProxyDisconnected": True,
+        }
+        if robot_key is not None:
+            body["robotKey"] = robot_key
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+            ),
+            json=body,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _update_spec(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
+            ),
+            json={
+                "robotKey": self._execution_context.robot_key,
+                "robotAsset": robot_asset.model_dump(by_alias=True, exclude_none=True),
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _list_spec(
+        self,
+        folder_path: Optional[str],
+        folder_key: Optional[str],
+        filter: Optional[str],
+        orderby: Optional[str],
+        skip: int,
+        top: int,
+    ) -> RequestSpec:
+        params: Dict[str, Any] = {"$skip": skip, "$top": top}
+        if filter:
+            params["$filter"] = filter
+        if orderby:
+            params["$orderby"] = orderby
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered"
+            ),
+            params=params,
+            headers={**header_folder(folder_key, folder_path)},
+        )
diff --git a/src/uipath/_services/attachments_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_attachments_service.py
similarity index 61%
rename from src/uipath/_services/attachments_service.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/_attachments_service.py
index 5da302e0e..73775c994 100644
--- a/src/uipath/_services/attachments_service.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_attachments_service.py
@@ -1,23 +1,28 @@
+import copy
 import os
 import shutil
 import tempfile
 import uuid
+from contextlib import asynccontextmanager, contextmanager
 from pathlib import Path
-from typing import Any, Dict, Optional, Union, overload
+from typing import Any, AsyncIterator, Iterator, Tuple, overload
 
 import httpx
+from httpx import Response
+from httpx._types import RequestContent
+from uipath.core.tracing import traced
 
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder
-from .._utils._ssl_context import get_httpx_client_kwargs
-from .._utils.constants import TEMP_ATTACHMENTS_FOLDER
-from ..tracing._traced import traced
-from ._base_service import BaseService
+from ..attachments import Attachment, AttachmentMode, BlobFileAccessInfo
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._http_config import get_httpx_client_kwargs
+from ..common._models import Endpoint, RequestSpec
+from ..common.constants import TEMP_ATTACHMENTS_FOLDER
 
 
-def _upload_attachment_input_processor(inputs: Dict[str, Any]) -> Dict[str, Any]:
+def _upload_attachment_input_processor(inputs: dict[str, Any]) -> dict[str, Any]:
     """Process attachment upload inputs to avoid logging large content."""
     processed_inputs = inputs.copy()
     if "source_path" in processed_inputs:
@@ -39,18 +44,180 @@ class AttachmentsService(FolderContext, BaseService):
     Reference: https://docs.uipath.com/orchestrator/reference/api-attachments
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
         self._temp_dir = os.path.join(tempfile.gettempdir(), TEMP_ATTACHMENTS_FOLDER)
 
+    @traced(name="attachments_open", run_type="uipath")
+    @contextmanager
+    def open(
+        self,
+        *,
+        attachment: Attachment,
+        mode: AttachmentMode = AttachmentMode.READ,
+        content: RequestContent | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> Iterator[Tuple[Attachment, Response]]:
+        """Open an attachment.
+
+        Args:
+            attachment (Attachment): The attachment to open.
+            mode (AttachmentMode): The mode to use.
+            content (RequestContent | None): An optional request content to upload.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            str: The name of the downloaded attachment.
+
+        Raises:
+            Exception: If the download fails and no local file is found.
+        """
+        try:
+            if mode == AttachmentMode.READ:
+                assert attachment.id, "Attachment ID is required to open an attachment."
+                spec = self._retrieve_download_uri_spec(
+                    key=attachment.id,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+            else:
+                spec = self._create_attachment_and_retrieve_upload_uri_spec(
+                    name=attachment.full_name,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+
+            result = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+                json=spec.json,
+            ).json()
+            resource: Attachment = copy.deepcopy(attachment)
+            resource.id = uuid.UUID(result["Id"])
+
+            resource_uri = result["BlobFileAccess"]["Uri"]
+            headers = {
+                key: value
+                for key, value in zip(
+                    result["BlobFileAccess"]["Headers"]["Keys"],
+                    result["BlobFileAccess"]["Headers"]["Values"],
+                    strict=False,
+                )
+            }
+
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                raise Exception(
+                    "Attachment access not supported via UiPath Coded Agents."
+                )
+            else:
+                http_verb = "GET" if mode == AttachmentMode.READ else "PUT"
+                with httpx.Client(**get_httpx_client_kwargs()) as client:
+                    with client.stream(
+                        http_verb,
+                        resource_uri,
+                        headers=headers,
+                        content=content,
+                    ) as response:
+                        yield resource, response
+        except Exception as e:
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(f"Attachment access failed with error: {e}") from e
+
+    @traced(name="attachments_open", run_type="uipath")
+    @asynccontextmanager
+    async def open_async(
+        self,
+        *,
+        attachment: Attachment,
+        mode: AttachmentMode = AttachmentMode.READ,
+        content: RequestContent | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> AsyncIterator[Tuple[Attachment, Response]]:
+        """Open an attachment asynchronously.
+
+        Args:
+            attachment (Attachment): The attachment to open.
+            mode (AttachmentMode): The mode to use.
+            content (RequestContent): An optional request content to upload.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            str: The name of the downloaded attachment.
+
+        Raises:
+            Exception: If the download fails and no local file is found.
+        """
+        try:
+            if mode == AttachmentMode.READ:
+                assert attachment.id, "Attachment ID is required to open an attachment."
+                spec = self._retrieve_download_uri_spec(
+                    key=attachment.id,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+            else:
+                spec = self._create_attachment_and_retrieve_upload_uri_spec(
+                    name=attachment.full_name,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+
+            result = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                    json=spec.json,
+                )
+            ).json()
+            resource: Attachment = copy.deepcopy(attachment)
+            resource.id = uuid.UUID(result["Id"])
+
+            resource_uri = result["BlobFileAccess"]["Uri"]
+            headers = {
+                key: value
+                for key, value in zip(
+                    result["BlobFileAccess"]["Headers"]["Keys"],
+                    result["BlobFileAccess"]["Headers"]["Values"],
+                    strict=False,
+                )
+            }
+
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                raise Exception(
+                    "Attachment access not supported via UiPath Coded Agents."
+                )
+            else:
+                http_verb = "GET" if mode == AttachmentMode.READ else "PUT"
+                async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
+                    async with client.stream(
+                        http_verb,
+                        resource_uri,
+                        headers=headers,
+                        content=content,
+                    ) as response:
+                        yield resource, response
+        except Exception as e:
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(f"Attachment access failed with error: {e}") from e
+
     @traced(name="attachments_download", run_type="uipath")
     def download(
         self,
         *,
         key: uuid.UUID,
         destination_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> str:
         """Download an attachment.
 
@@ -65,8 +232,8 @@ def download(
         Args:
             key (uuid.UUID): The key of the attachment to download.
             destination_path (str): The local path where the attachment will be saved.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Returns:
             str: The name of the downloaded attachment.
@@ -76,7 +243,7 @@ def download(
 
         Examples:
             ```python
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -163,8 +330,8 @@ async def download_async(
         *,
         key: uuid.UUID,
         destination_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> str:
         """Download an attachment asynchronously.
 
@@ -179,8 +346,8 @@ async def download_async(
         Args:
             key (uuid.UUID): The key of the attachment to download.
             destination_path (str): The local path where the attachment will be saved.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Returns:
             str: The name of the downloaded attachment.
@@ -191,7 +358,7 @@ async def download_async(
         Examples:
             ```python
             import asyncio
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -280,9 +447,9 @@ def upload(
         self,
         *,
         name: str,
-        content: Union[str, bytes],
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        content: str | bytes,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID: ...
 
     @overload
@@ -291,8 +458,8 @@ def upload(
         *,
         name: str,
         source_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID: ...
 
     @traced(
@@ -304,10 +471,10 @@ def upload(
         self,
         *,
         name: str,
-        content: Optional[Union[str, bytes]] = None,
-        source_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        content: str | bytes | None = None,
+        source_path: str | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID:
         """Upload a file or content to UiPath as an attachment.
 
@@ -316,10 +483,10 @@ def upload(
 
         Args:
             name (str): The name of the attachment file.
-            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
-            source_path (Optional[str]): The local path of the file to upload.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            content (str | bytes | None): The content to upload (string or bytes).
+            source_path (str | None): The local path of the file to upload.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Returns:
             uuid.UUID: The UUID of the created attachment.
@@ -330,7 +497,7 @@ def upload(
 
         Examples:
             ```python
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -412,9 +579,9 @@ async def upload_async(
         self,
         *,
         name: str,
-        content: Union[str, bytes],
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        content: str | bytes,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID: ...
 
     @overload
@@ -423,8 +590,8 @@ async def upload_async(
         *,
         name: str,
         source_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID: ...
 
     @traced(
@@ -436,10 +603,10 @@ async def upload_async(
         self,
         *,
         name: str,
-        content: Optional[Union[str, bytes]] = None,
-        source_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        content: str | bytes | None = None,
+        source_path: str | None = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> uuid.UUID:
         """Upload a file or content to UiPath as an attachment asynchronously.
 
@@ -448,10 +615,10 @@ async def upload_async(
 
         Args:
             name (str): The name of the attachment file.
-            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
-            source_path (Optional[str]): The local path of the file to upload.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            content (str | bytes | None): The content to upload (string or bytes).
+            source_path (str | None): The local path of the file to upload.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Returns:
             uuid.UUID: The UUID of the created attachment.
@@ -463,7 +630,7 @@ async def upload_async(
         Examples:
             ```python
             import asyncio
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -545,13 +712,131 @@ async def main():
 
         return attachment_key
 
+    @traced(name="attachments_get_blob_uri", run_type="uipath")
+    def get_blob_file_access_uri(
+        self,
+        *,
+        key: uuid.UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> BlobFileAccessInfo:
+        """Get the BlobFileAccess information for an attachment.
+
+        This method retrieves the blob storage URI and filename for downloading
+        an attachment without actually downloading the file.
+
+        Args:
+            key (uuid.UUID): The key of the attachment.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            BlobFileAccessInfo: Object containing the blob storage URI and attachment name.
+
+        Raises:
+            Exception: If the attachment is not found or the request fails.
+
+        Examples:
+            ```python
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            info = client.attachments.get_blob_file_access_uri(
+                key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+            )
+            print(f"Attachment ID: {info.id}")
+            print(f"Blob URI: {info.uri}")
+            print(f"File name: {info.name}")
+            ```
+        """
+        spec = self._retrieve_download_uri_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        return BlobFileAccessInfo(
+            id=key,
+            uri=result["BlobFileAccess"]["Uri"],
+            name=result["Name"],
+        )
+
+    @traced(name="attachments_get_blob_uri", run_type="uipath")
+    async def get_blob_file_access_uri_async(
+        self,
+        *,
+        key: uuid.UUID,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> BlobFileAccessInfo:
+        """Get the BlobFileAccess information for an attachment asynchronously.
+
+        This method asynchronously retrieves the blob storage URI and filename
+        for downloading an attachment without actually downloading the file.
+
+        Args:
+            key (uuid.UUID): The key of the attachment.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            BlobFileAccessInfo: Object containing the blob storage URI and attachment name.
+
+        Raises:
+            Exception: If the attachment is not found or the request fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            async def main():
+                info = await client.attachments.get_blob_file_access_uri_async(
+                    key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+                )
+                print(f"Attachment ID: {info.id}")
+                print(f"Blob URI: {info.uri}")
+                print(f"File name: {info.name}")
+            ```
+        """
+        spec = self._retrieve_download_uri_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        return BlobFileAccessInfo(
+            id=key,
+            uri=result["BlobFileAccess"]["Uri"],
+            name=result["Name"],
+        )
+
     @traced(name="attachments_delete", run_type="uipath")
     def delete(
         self,
         *,
         key: uuid.UUID,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> None:
         """Delete an attachment.
 
@@ -565,15 +850,15 @@ def delete(
 
         Args:
             key (uuid.UUID): The key of the attachment to delete.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Raises:
             Exception: If the deletion fails and no local file is found.
 
         Examples:
             ```python
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -620,8 +905,8 @@ async def delete_async(
         self,
         *,
         key: uuid.UUID,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> None:
         """Delete an attachment asynchronously.
 
@@ -635,8 +920,8 @@ async def delete_async(
 
         Args:
             key (uuid.UUID): The key of the attachment to delete.
-            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+            folder_key (str | None): The key of the folder. Override the default one set in the SDK config.
+            folder_path (str | None): The path of the folder. Override the default one set in the SDK config.
 
         Raises:
             Exception: If the deletion fails and no local file is found.
@@ -644,7 +929,7 @@ async def delete_async(
         Examples:
             ```python
             import asyncio
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -688,15 +973,15 @@ async def main():
             ) from e
 
     @property
-    def custom_headers(self) -> Dict[str, str]:
+    def custom_headers(self) -> dict[str, str]:
         """Return custom headers for API requests."""
         return self.folder_headers
 
     def _create_attachment_and_retrieve_upload_uri_spec(
         self,
         name: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> RequestSpec:
         return RequestSpec(
             method="POST",
@@ -712,8 +997,8 @@ def _create_attachment_and_retrieve_upload_uri_spec(
     def _retrieve_download_uri_spec(
         self,
         key: uuid.UUID,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> RequestSpec:
         return RequestSpec(
             method="GET",
@@ -726,8 +1011,8 @@ def _retrieve_download_uri_spec(
     def _delete_attachment_spec(
         self,
         key: uuid.UUID,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
     ) -> RequestSpec:
         return RequestSpec(
             method="DELETE",
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_buckets_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_buckets_service.py
new file mode 100644
index 000000000..fc1d84db3
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_buckets_service.py
@@ -0,0 +1,1803 @@
+import asyncio
+import mimetypes
+import uuid
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import httpx
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._http_config import get_httpx_client_kwargs
+from ..common._models import Endpoint, RequestSpec
+from ..common.paging import PagedResult
+from ..common.validation import validate_pagination_params
+from .buckets import Bucket, BucketFile
+
+# Pagination limits
+MAX_PAGE_SIZE = 1000  # Maximum items per page (top parameter)
+MAX_SKIP_OFFSET = 10000  # Maximum skip offset for offset-based pagination
+
+
+class BucketsService(FolderContext, BaseService):
+    """Service for managing UiPath storage buckets.
+
+    Buckets are cloud storage containers that can be used to store and manage files
+    used by automation processes.
+    """
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self.custom_client = httpx.Client(**get_httpx_client_kwargs())
+        self.custom_client_async = httpx.AsyncClient(**get_httpx_client_kwargs())
+
+    @traced(name="buckets_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        name: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Bucket]:
+        """List buckets using OData API with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+
+        Args:
+            folder_path: Folder path to filter buckets
+            folder_key: Folder key (mutually exclusive with folder_path)
+            name: Filter by bucket name (contains match)
+            skip: Number of buckets to skip (default 0, max 10000)
+            top: Maximum number of buckets to return (default 100, max 1000)
+
+        Returns:
+            PagedResult[Bucket]: Page containing buckets and pagination metadata
+
+        Raises:
+            ValueError: If skip < 0, skip > 10000, top < 1, or top > 1000
+
+        Examples:
+            >>> # Get first page
+            >>> result = sdk.buckets.list(top=100)
+            >>> for bucket in result.items:
+            ...     print(bucket.name)
+            >>>
+            >>> # Check pagination metadata
+            >>> if result.has_more:
+            ...     print(f"More results available. Current: skip={result.skip}, top={result.top}")
+            >>>
+            >>> # Manual pagination to get all buckets
+            >>> skip = 0
+            >>> top = 100
+            >>> all_buckets = []
+            >>> while True:
+            ...     result = sdk.buckets.list(skip=skip, top=top, name="invoice")
+            ...     all_buckets.extend(result.items)
+            ...     if not result.has_more:
+            ...         break
+            ...     skip += top
+            >>>
+            >>> # Helper function for complete iteration
+            >>> def iter_all_buckets(sdk, top=100, **filters):
+            ...     skip = 0
+            ...     while True:
+            ...         result = sdk.buckets.list(skip=skip, top=top, **filters)
+            ...         yield from result.items
+            ...         if not result.has_more:
+            ...             break
+            ...         skip += top
+            >>>
+            >>> # Usage
+            >>> for bucket in iter_all_buckets(sdk, name="invoice"):
+            ...     process_bucket(bucket)
+        """
+        # Validate parameters using shared utility
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=MAX_SKIP_OFFSET,
+            max_top=MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            name=name,
+            skip=skip,
+            top=top,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        items = response.get("value", [])
+        buckets = [Bucket.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=buckets,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @traced(name="buckets_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        name: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Bucket]:
+        """Async version of list() with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+
+        Args:
+            folder_path: Folder path to filter buckets
+            folder_key: Folder key (mutually exclusive with folder_path)
+            name: Filter by bucket name (contains match)
+            skip: Number of buckets to skip (default 0, max 10000)
+            top: Maximum number of buckets to return (default 100, max 1000)
+
+        Returns:
+            PagedResult[Bucket]: Page containing buckets and pagination metadata
+
+        Raises:
+            ValueError: If skip < 0, skip > 10000, top < 1, or top > 1000
+
+        Examples:
+            >>> # Get first page
+            >>> result = await sdk.buckets.list_async(top=100)
+            >>> for bucket in result.items:
+            ...     print(bucket.name)
+            >>>
+            >>> # Manual pagination
+            >>> skip = 0
+            >>> top = 100
+            >>> all_buckets = []
+            >>> while True:
+            ...     result = await sdk.buckets.list_async(skip=skip, top=top)
+            ...     all_buckets.extend(result.items)
+            ...     if not result.has_more:
+            ...         break
+            ...     skip += top
+        """
+        # Validate parameters using shared utility
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=MAX_SKIP_OFFSET,
+            max_top=MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            name=name,
+            skip=skip,
+            top=top,
+        )
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        items = response.get("value", [])
+        buckets = [Bucket.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=buckets,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @traced(name="buckets_exists", run_type="uipath")
+    def exists(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> bool:
+        """Check if bucket exists.
+
+        Args:
+            name: Bucket name
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            bool: True if bucket exists
+
+        Examples:
+            >>> if sdk.buckets.exists("my-storage"):
+            ...     print("Bucket found")
+        """
+        try:
+            self.retrieve(name=name, folder_key=folder_key, folder_path=folder_path)
+            return True
+        except LookupError:
+            return False
+
+    @traced(name="buckets_exists", run_type="uipath")
+    async def exists_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> bool:
+        """Async version of exists()."""
+        try:
+            await self.retrieve_async(
+                name=name, folder_key=folder_key, folder_path=folder_path
+            )
+            return True
+        except LookupError:
+            return False
+
+    @traced(name="buckets_create", run_type="uipath")
+    def create(
+        self,
+        name: str,
+        *,
+        description: Optional[str] = None,
+        identifier: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> Bucket:
+        """Create a new bucket.
+
+        Args:
+            name: Bucket name (must be unique within folder)
+            description: Optional description
+            identifier: UUID identifier (auto-generated if not provided)
+            folder_path: Folder to create bucket in
+            folder_key: Folder key
+
+        Returns:
+            Bucket: Newly created bucket resource
+
+        Raises:
+            Exception: If bucket creation fails
+
+        Examples:
+            >>> bucket = sdk.buckets.create("my-storage")
+            >>> bucket = sdk.buckets.create(
+            ...     "data-storage",
+            ...     description="Production data"
+            ... )
+        """
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            identifier=identifier or str(uuid.uuid4()),
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        ).json()
+
+        bucket = Bucket.model_validate(response)
+        return bucket
+
+    @traced(name="buckets_create", run_type="uipath")
+    async def create_async(
+        self,
+        name: str,
+        *,
+        description: Optional[str] = None,
+        identifier: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> Bucket:
+        """Async version of create()."""
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            identifier=identifier or str(uuid.uuid4()),
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                json=spec.json,
+                headers=spec.headers,
+            )
+        ).json()
+
+        bucket = Bucket.model_validate(response)
+        return bucket
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_delete", run_type="uipath")
+    def delete(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> None:
+        """Delete a bucket.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier (UUID)
+            folder_path: Folder path
+            folder_key: Folder key
+
+        Raises:
+            LookupError: If bucket is not found
+
+        Examples:
+            >>> sdk.buckets.delete(name="old-storage")
+            >>> sdk.buckets.delete(key="abc-123-def")
+        """
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        self.request(
+            "DELETE",
+            url=f"/orchestrator_/odata/Buckets({bucket.id})",
+            headers={**header_folder(folder_key, folder_path)},
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_delete", run_type="uipath")
+    async def delete_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> None:
+        """Async version of delete()."""
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        await self.request_async(
+            "DELETE",
+            url=f"/orchestrator_/odata/Buckets({bucket.id})",
+            headers={**header_folder(folder_key, folder_path)},
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_download", run_type="uipath")
+    def download(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        destination_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Download a file from a bucket.
+
+        Args:
+            key (Optional[str]): The key of the bucket.
+            name (Optional[str]): The name of the bucket.
+            blob_file_path (str): The path to the file in the bucket.
+            destination_path (str): The local path where the file will be saved.
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Raises:
+            ValueError: If neither key nor name is provided.
+            Exception: If the bucket with the specified key is not found.
+        """
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+        spec = self._retrieve_readUri_spec(
+            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
+        )
+        result = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        read_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        with open(destination_path, "wb") as file:
+            if result["RequiresAuth"]:
+                file_content = self.request("GET", read_uri, headers=headers).content
+            else:
+                file_content = self.custom_client.get(read_uri, headers=headers).content
+            file.write(file_content)
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_download", run_type="uipath")
+    async def download_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        destination_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Download a file from a bucket asynchronously.
+
+        Args:
+            key (Optional[str]): The key of the bucket.
+            name (Optional[str]): The name of the bucket.
+            blob_file_path (str): The path to the file in the bucket.
+            destination_path (str): The local path where the file will be saved.
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Raises:
+            ValueError: If neither key nor name is provided.
+            Exception: If the bucket with the specified key is not found.
+        """
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+        spec = self._retrieve_readUri_spec(
+            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
+        )
+        result = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        read_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        if result["RequiresAuth"]:
+            file_content = (
+                await self.request_async("GET", read_uri, headers=headers)
+            ).content
+        else:
+            file_content = (
+                await self.custom_client_async.get(read_uri, headers=headers)
+            ).content
+
+        await asyncio.to_thread(Path(destination_path).write_bytes, file_content)
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_upload", run_type="uipath")
+    def upload(
+        self,
+        *,
+        key: Optional[str] = None,
+        name: Optional[str] = None,
+        blob_file_path: str,
+        content_type: Optional[str] = None,
+        source_path: Optional[str] = None,
+        content: Optional[Union[str, bytes]] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Upload a file to a bucket.
+
+        Args:
+            key (Optional[str]): The key of the bucket.
+            name (Optional[str]): The name of the bucket.
+            blob_file_path (str): The path where the file will be stored in the bucket.
+            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
+            source_path (Optional[str]): The local path of the file to upload.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Raises:
+            ValueError: If neither key nor name is provided.
+            Exception: If the bucket with the specified key or name is not found.
+        """
+        if content is not None and source_path is not None:
+            raise ValueError("Content and source_path are mutually exclusive")
+        if content is None and source_path is None:
+            raise ValueError("Either content or source_path must be provided")
+
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        if source_path:
+            _content_type, _ = mimetypes.guess_type(source_path)
+        else:
+            _content_type = content_type
+        _content_type = _content_type or "application/octet-stream"
+
+        spec = self._retrieve_writeri_spec(
+            bucket.id,
+            _content_type,
+            blob_file_path,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        write_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        headers["Content-Type"] = _content_type
+
+        if content is not None:
+            if isinstance(content, str):
+                content = content.encode("utf-8")
+
+            if result["RequiresAuth"]:
+                self.request("PUT", write_uri, headers=headers, content=content)
+            else:
+                self.custom_client.put(write_uri, headers=headers, content=content)
+
+        if source_path is not None:
+            with open(source_path, "rb") as file:
+                file_content = file.read()
+                if result["RequiresAuth"]:
+                    self.request(
+                        "PUT", write_uri, headers=headers, content=file_content
+                    )
+                else:
+                    self.custom_client.put(
+                        write_uri, headers=headers, content=file_content
+                    )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_upload", run_type="uipath")
+    async def upload_async(
+        self,
+        *,
+        key: Optional[str] = None,
+        name: Optional[str] = None,
+        blob_file_path: str,
+        content_type: Optional[str] = None,
+        source_path: Optional[str] = None,
+        content: Optional[Union[str, bytes]] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Upload a file to a bucket asynchronously.
+
+        Args:
+            key (Optional[str]): The key of the bucket.
+            name (Optional[str]): The name of the bucket.
+            blob_file_path (str): The path where the file will be stored in the bucket.
+            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
+            source_path (Optional[str]): The local path of the file to upload.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Raises:
+            ValueError: If neither key nor name is provided.
+            Exception: If the bucket with the specified key or name is not found.
+        """
+        if content is not None and source_path is not None:
+            raise ValueError("Content and source_path are mutually exclusive")
+        if content is None and source_path is None:
+            raise ValueError("Either content or source_path must be provided")
+
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        if source_path:
+            _content_type, _ = mimetypes.guess_type(source_path)
+        else:
+            _content_type = content_type
+        _content_type = _content_type or "application/octet-stream"
+
+        spec = self._retrieve_writeri_spec(
+            bucket.id,
+            _content_type,
+            blob_file_path,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        write_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        headers["Content-Type"] = _content_type
+
+        if content is not None:
+            if isinstance(content, str):
+                content = content.encode("utf-8")
+
+            if result["RequiresAuth"]:
+                await self.request_async(
+                    "PUT", write_uri, headers=headers, content=content
+                )
+            else:
+                await self.custom_client_async.put(
+                    write_uri, headers=headers, content=content
+                )
+
+        if source_path is not None:
+            file_content = await asyncio.to_thread(Path(source_path).read_bytes)
+            if result["RequiresAuth"]:
+                await self.request_async(
+                    "PUT", write_uri, headers=headers, content=file_content
+                )
+            else:
+                await self.custom_client_async.put(
+                    write_uri, headers=headers, content=file_content
+                )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_retrieve", run_type="uipath")
+    def retrieve(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Bucket:
+        """Retrieve bucket information by its name.
+
+        Args:
+            name (Optional[str]): The name of the bucket to retrieve.
+            key (Optional[str]): The key of the bucket.
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Returns:
+            Bucket: The bucket resource instance.
+
+        Raises:
+            ValueError: If neither bucket key nor bucket name is provided.
+            Exception: If the bucket with the specified name is not found.
+
+        Examples:
+            >>> bucket = sdk.buckets.retrieve(name="my-storage")
+            >>> print(bucket.name, bucket.identifier)
+        """
+        if key:
+            spec = self._retrieve_by_key_spec(
+                key, folder_key=folder_key, folder_path=folder_path
+            )
+            try:
+                response = self.request(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                ).json()
+                if "value" in response:
+                    items = response.get("value", [])
+                    if not items:
+                        raise LookupError(f"Bucket with key '{key}' not found")
+                    bucket_data = items[0]
+                else:
+                    bucket_data = response
+            except (KeyError, IndexError) as e:
+                raise LookupError(f"Bucket with key '{key}' not found") from e
+        else:
+            if not name:
+                raise ValueError("Must specify a bucket name or bucket key")
+            spec = self._retrieve_spec(
+                name,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+            try:
+                response = self.request(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                ).json()
+                items = response.get("value", [])
+                if not items:
+                    raise LookupError(f"Bucket with name '{name}' not found")
+                bucket_data = items[0]
+            except (KeyError, IndexError) as e:
+                raise LookupError(f"Bucket with name '{name}' not found") from e
+
+        bucket = Bucket.model_validate(bucket_data)
+        return bucket
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_retrieve", run_type="uipath")
+    async def retrieve_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Bucket:
+        """Asynchronously retrieve bucket information by its name.
+
+        Args:
+            name (Optional[str]): The name of the bucket to retrieve.
+            key (Optional[str]): The key of the bucket.
+            folder_key (Optional[str]): The key of the folder where the bucket resides.
+            folder_path (Optional[str]): The path of the folder where the bucket resides.
+
+        Returns:
+            Bucket: The bucket resource instance.
+
+        Raises:
+            ValueError: If neither bucket key nor bucket name is provided.
+            Exception: If the bucket with the specified name is not found.
+
+        Examples:
+            >>> bucket = await sdk.buckets.retrieve_async(name="my-storage")
+            >>> print(bucket.name, bucket.identifier)
+        """
+        if key:
+            spec = self._retrieve_by_key_spec(
+                key, folder_key=folder_key, folder_path=folder_path
+            )
+            try:
+                response = (
+                    await self.request_async(
+                        spec.method,
+                        url=spec.endpoint,
+                        params=spec.params,
+                        headers=spec.headers,
+                    )
+                ).json()
+                if "value" in response:
+                    items = response.get("value", [])
+                    if not items:
+                        raise LookupError(f"Bucket with key '{key}' not found")
+                    bucket_data = items[0]
+                else:
+                    bucket_data = response
+            except (KeyError, IndexError) as e:
+                raise LookupError(f"Bucket with key '{key}' not found") from e
+        else:
+            if not name:
+                raise ValueError("Must specify a bucket name or bucket key")
+            spec = self._retrieve_spec(
+                name,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+            try:
+                response = (
+                    await self.request_async(
+                        spec.method,
+                        url=spec.endpoint,
+                        params=spec.params,
+                        headers=spec.headers,
+                    )
+                ).json()
+                items = response.get("value", [])
+                if not items:
+                    raise LookupError(f"Bucket with name '{name}' not found")
+                bucket_data = items[0]
+            except (KeyError, IndexError) as e:
+                raise LookupError(f"Bucket with name '{name}' not found") from e
+
+        bucket = Bucket.model_validate(bucket_data)
+        return bucket
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_list_files", run_type="uipath")
+    def list_files(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        prefix: str = "",
+        take_hint: int = 500,
+        continuation_token: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> PagedResult[BucketFile]:
+        """List files in a bucket using cursor-based pagination.
+
+        Returns a single page of results with continuation token for manual pagination.
+        This method uses the REST API with continuation tokens for efficient pagination
+        of large file sets. Recommended for sequential iteration over millions of files.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            prefix: Filter files by prefix
+            take_hint: Minimum number of files to return (default 500, max 1000).
+                      The API may return up to 2x this value in some cases.
+            continuation_token: Token from previous response. Pass None for first page.
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            PagedResult[BucketFile]: Page containing files and continuation token metadata
+
+        Raises:
+            ValueError: If take_hint is not between 1 and 1000
+
+        Examples:
+            >>> # Get first page
+            >>> result = sdk.buckets.list_files(name="my-storage")
+            >>> print(f"Got {len(result.items)} files")
+            >>>
+            >>> # Manual pagination to get all files
+            >>> all_files = []
+            >>> token = None
+            >>> while True:
+            ...     result = sdk.buckets.list_files(
+            ...         name="my-storage",
+            ...         prefix="reports/2024/",
+            ...         continuation_token=token
+            ...     )
+            ...     all_files.extend(result.items)
+            ...     if not result.continuation_token:
+            ...         break
+            ...     token = result.continuation_token
+            >>>
+            >>> # Helper function for iteration
+            >>> def iter_all_files(sdk, bucket_name, prefix=""):
+            ...     token = None
+            ...     while True:
+            ...         result = sdk.buckets.list_files(
+            ...             name=bucket_name,
+            ...             prefix=prefix,
+            ...             continuation_token=token
+            ...         )
+            ...         yield from result.items
+            ...         if not result.continuation_token:
+            ...             break
+            ...         token = result.continuation_token
+            >>>
+            >>> # Usage
+            >>> for file in iter_all_files(sdk, "my-storage", "reports/"):
+            ...     print(file.path)
+
+        Performance:
+            Cursor-based pagination scales efficiently to millions of files.
+            Each page requires one API call regardless of dataset size.
+
+            For sequential processing, this is the most efficient method.
+            For filtered queries, consider get_files() with OData filters.
+        """
+        # Validate parameters
+        if take_hint < 1 or take_hint > 1000:
+            raise ValueError("take_hint must be between 1 and 1000")
+
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._list_files_spec(
+            bucket.id,
+            prefix,
+            continuation_token=continuation_token,
+            take_hint=take_hint,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        items = response.get("items", [])
+        files = [BucketFile.model_validate(item) for item in items]
+        next_token = response.get("continuationToken")
+
+        return PagedResult(
+            items=files,
+            continuation_token=next_token,
+            has_more=next_token is not None,
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_list_files", run_type="uipath")
+    async def list_files_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        prefix: str = "",
+        take_hint: int = 500,
+        continuation_token: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> PagedResult[BucketFile]:
+        """Async version of list_files() with cursor-based pagination.
+
+        Returns a single page of results with continuation token for manual pagination.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            prefix: Filter files by prefix
+            take_hint: Minimum number of files to return (default 500, max 1000).
+                      The API may return up to 2x this value in some cases.
+            continuation_token: Token from previous response. Pass None for first page.
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            PagedResult[BucketFile]: Page containing files and continuation token metadata
+
+        Raises:
+            ValueError: If take_hint is not between 1 and 1000
+
+        Examples:
+            >>> # Get first page
+            >>> result = await sdk.buckets.list_files_async(name="my-storage")
+            >>> print(f"Got {len(result.items)} files")
+            >>>
+            >>> # Manual pagination
+            >>> all_files = []
+            >>> token = None
+            >>> while True:
+            ...     result = await sdk.buckets.list_files_async(
+            ...         name="my-storage",
+            ...         continuation_token=token
+            ...     )
+            ...     all_files.extend(result.items)
+            ...     if not result.continuation_token:
+            ...         break
+            ...     token = result.continuation_token
+        """
+        # Validate parameters
+        if take_hint < 1 or take_hint > 1000:
+            raise ValueError("take_hint must be between 1 and 1000")
+
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._list_files_spec(
+            bucket.id,
+            prefix,
+            continuation_token=continuation_token,
+            take_hint=take_hint,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        items = response.get("items", [])
+        files = [BucketFile.model_validate(item) for item in items]
+        next_token = response.get("continuationToken")
+
+        return PagedResult(
+            items=files,
+            continuation_token=next_token,
+            has_more=next_token is not None,
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_exists_file", run_type="uipath")
+    def exists_file(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> bool:
+        """Check if a file exists in a bucket.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            blob_file_path: Path to the file in the bucket (cannot be empty)
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            bool: True if file exists, False otherwise
+
+        Note:
+            This method uses short-circuit iteration to stop at the first match,
+            making it memory-efficient even for large buckets. It will raise
+            LookupError if the bucket itself doesn't exist.
+
+        Raises:
+            ValueError: If blob_file_path is empty or whitespace-only
+            LookupError: If bucket is not found
+
+        Examples:
+            >>> if sdk.buckets.exists_file(name="my-storage", blob_file_path="data/file.csv"):
+            ...     print("File exists")
+            >>> # Check in specific folder
+            >>> exists = sdk.buckets.exists_file(
+            ...     name="my-storage",
+            ...     blob_file_path="reports/2024/summary.pdf",
+            ...     folder_path="Production"
+            ... )
+        """
+        if not blob_file_path or not blob_file_path.strip():
+            raise ValueError("blob_file_path cannot be empty or whitespace-only")
+
+        normalized_target = (
+            blob_file_path if blob_file_path.startswith("/") else f"/{blob_file_path}"
+        )
+
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        token = None
+        while True:
+            spec = self._list_files_spec(
+                bucket.id,
+                normalized_target,  # Use normalized path for prefix
+                continuation_token=token,
+                take_hint=1,  # Performance optimization: only need first match
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            ).json()
+
+            items = response.get("items", [])
+            for item in items:
+                file = BucketFile.model_validate(item)
+                if file.path == normalized_target:
+                    return True
+
+            token = response.get("continuationToken")
+            if not token:
+                break
+
+        return False
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_exists_file", run_type="uipath")
+    async def exists_file_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> bool:
+        """Async version of exists_file().
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            blob_file_path: Path to the file in the bucket (cannot be empty)
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            bool: True if file exists, False otherwise
+
+        Raises:
+            ValueError: If blob_file_path is empty or whitespace-only
+            LookupError: If bucket is not found
+
+        Examples:
+            >>> if await sdk.buckets.exists_file_async(name="my-storage", blob_file_path="data/file.csv"):
+            ...     print("File exists")
+        """
+        if not blob_file_path or not blob_file_path.strip():
+            raise ValueError("blob_file_path cannot be empty or whitespace-only")
+
+        normalized_target = (
+            blob_file_path if blob_file_path.startswith("/") else f"/{blob_file_path}"
+        )
+
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        token = None
+        while True:
+            spec = self._list_files_spec(
+                bucket.id,
+                normalized_target,  # Use normalized path for prefix
+                continuation_token=token,
+                take_hint=1,  # Performance optimization: only need first match
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                )
+            ).json()
+
+            items = response.get("items", [])
+            for item in items:
+                file = BucketFile.model_validate(item)
+                if file.path == normalized_target:
+                    return True
+
+            token = response.get("continuationToken")
+            if not token:
+                break
+
+        return False
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_delete_file", run_type="uipath")
+    def delete_file(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete a file from a bucket.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            blob_file_path: Path to the file in the bucket
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Examples:
+            >>> sdk.buckets.delete_file(name="my-storage", blob_file_path="data/file.txt")
+        """
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+        spec = self._delete_file_spec(
+            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
+        )
+        self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_delete_file", run_type="uipath")
+    async def delete_file_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete a file from a bucket asynchronously.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            blob_file_path: Path to the file in the bucket
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Examples:
+            >>> await sdk.buckets.delete_file_async(name="my-storage", blob_file_path="data/file.txt")
+        """
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+        spec = self._delete_file_spec(
+            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
+        )
+        await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_get_files", run_type="uipath")
+    def get_files(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        prefix: str = "",
+        recursive: bool = False,
+        file_name_glob: Optional[str] = None,
+        skip: int = 0,
+        top: int = 500,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> PagedResult[BucketFile]:
+        """Get files using OData GetFiles API with offset-based pagination.
+
+        This method uses the OData API with $skip/$top for pagination.
+        Supports recursive traversal, glob filtering, and OData features.
+        Automatically excludes directories from results.
+
+        Note: Offset-based pagination can degrade performance with very
+        large skip values (e.g., skip > 10000). For sequential iteration
+        over large datasets, consider list_files() instead.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            prefix: Directory path to filter files (default: root)
+            recursive: Recurse subdirectories for flat view (default: False)
+            file_name_glob: File filter pattern (e.g., "*.pdf", "data_*.csv")
+            skip: Number of files to skip (default 0, max 10000). Used for pagination.
+            top: Maximum number of files to return (default 500, max 1000).
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            PagedResult[BucketFile]: Page containing files (directories excluded) and pagination metadata
+
+        Raises:
+            ValueError: If skip < 0, skip > 10000, top < 1, top > 1000, neither name nor key is provided, or file_name_glob is empty
+            LookupError: If bucket not found
+
+        Examples:
+            >>> # Get first page
+            >>> result = sdk.buckets.get_files(name="my-storage")
+            >>> for file in result.items:
+            ...     print(file.name)
+            >>>
+            >>> # Filter with glob pattern
+            >>> result = sdk.buckets.get_files(
+            ...     name="my-storage",
+            ...     recursive=True,
+            ...     file_name_glob="*.pdf"
+            ... )
+            >>>
+            >>> # Manual offset-based pagination
+            >>> skip = 0
+            >>> top = 500
+            >>> all_files = []
+            >>> while True:
+            ...     result = sdk.buckets.get_files(
+            ...         name="my-storage",
+            ...         prefix="reports/",
+            ...         skip=skip,
+            ...         top=top
+            ...     )
+            ...     all_files.extend(result.items)
+            ...     if not result.has_more:
+            ...         break
+            ...     skip += top
+            >>>
+            >>> # Helper function
+            >>> def iter_all_files_odata(sdk, bucket_name, **filters):
+            ...     skip = 0
+            ...     top = 500
+            ...     while True:
+            ...         result = sdk.buckets.get_files(
+            ...             name=bucket_name,
+            ...             skip=skip,
+            ...             top=top,
+            ...             **filters
+            ...         )
+            ...         yield from result.items
+            ...         if not result.has_more:
+            ...             break
+            ...         skip += top
+            >>>
+            >>> # Usage with filters
+            >>> for file in iter_all_files_odata(
+            ...     sdk,
+            ...     "my-storage",
+            ...     recursive=True,
+            ...     file_name_glob="*.pdf"
+            ... ):
+            ...     process_file(file)
+
+        Performance:
+            Best for: Filtered queries, random access, sorted results.
+            Consider list_files() for: Sequential iteration over large datasets.
+
+            Performance degrades with large skip values due to database offset costs.
+        """
+        if skip < 0:
+            raise ValueError("skip must be >= 0")
+        if skip > MAX_SKIP_OFFSET:
+            raise ValueError(
+                f"skip must be <= {MAX_SKIP_OFFSET} (requested: {skip}). "
+                f"For large datasets, use list_files() with continuation tokens instead of offset-based pagination."
+            )
+        if top < 1:
+            raise ValueError("top must be >= 1")
+        if top > MAX_PAGE_SIZE:
+            raise ValueError(
+                f"top must be <= {MAX_PAGE_SIZE} (requested: {top}). "
+                f"Use pagination with skip and top parameters to retrieve larger datasets."
+            )
+
+        if not (name or key):
+            raise ValueError("Must specify either bucket name or key")
+
+        if file_name_glob is not None and not file_name_glob.strip():
+            raise ValueError("file_name_glob cannot be empty")
+
+        bucket = self.retrieve(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._get_files_spec(
+            bucket.id,
+            prefix=prefix,
+            recursive=recursive,
+            file_name_glob=file_name_glob,
+            skip=skip,
+            top=top,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        items = response.get("value", [])
+
+        files = []
+        for item in items:
+            if not item.get("IsDirectory", False):
+                try:
+                    files.append(BucketFile.model_validate(item))
+                except Exception as e:
+                    raise ValueError(
+                        f"Failed to parse file entry: {e}. Item: {item}"
+                    ) from e
+
+        return PagedResult(
+            items=files,
+            has_more=len(items) == top,  # Raw count, not len(files)
+            skip=skip,
+            top=top,
+        )
+
+    @resource_override(resource_type="bucket")
+    @traced(name="buckets_get_files", run_type="uipath")
+    async def get_files_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        key: Optional[str] = None,
+        prefix: str = "",
+        recursive: bool = False,
+        file_name_glob: Optional[str] = None,
+        skip: int = 0,
+        top: int = 500,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> PagedResult[BucketFile]:
+        """Async version of get_files() with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+        Automatically excludes directories from results.
+
+        Args:
+            name: Bucket name
+            key: Bucket identifier
+            prefix: Directory path to filter files
+            recursive: Recurse subdirectories for flat view
+            file_name_glob: File filter pattern (e.g., "*.pdf")
+            skip: Number of files to skip (default 0, max 10000)
+            top: Maximum number of files to return (default 500, max 1000)
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            PagedResult[BucketFile]: Page containing files (directories excluded) and pagination metadata
+
+        Raises:
+            ValueError: If skip < 0, skip > 10000, top < 1, top > 1000, neither name nor key is provided, or file_name_glob is empty
+            LookupError: If bucket not found
+
+        Examples:
+            >>> # Get first page
+            >>> result = await sdk.buckets.get_files_async(
+            ...     name="my-storage",
+            ...     recursive=True,
+            ...     file_name_glob="*.pdf"
+            ... )
+            >>> for file in result.items:
+            ...     print(file.name)
+            >>>
+            >>> # Manual pagination
+            >>> skip = 0
+            >>> top = 500
+            >>> all_files = []
+            >>> while True:
+            ...     result = await sdk.buckets.get_files_async(
+            ...         name="my-storage",
+            ...         skip=skip,
+            ...         top=top
+            ...     )
+            ...     all_files.extend(result.items)
+            ...     if not result.has_more:
+            ...         break
+            ...     skip += top
+        """
+        if skip < 0:
+            raise ValueError("skip must be >= 0")
+        if skip > MAX_SKIP_OFFSET:
+            raise ValueError(
+                f"skip must be <= {MAX_SKIP_OFFSET} (requested: {skip}). "
+                f"For large datasets, use list_files() with continuation tokens instead of offset-based pagination."
+            )
+        if top < 1:
+            raise ValueError("top must be >= 1")
+        if top > MAX_PAGE_SIZE:
+            raise ValueError(
+                f"top must be <= {MAX_PAGE_SIZE} (requested: {top}). "
+                f"Use pagination with skip and top parameters to retrieve larger datasets."
+            )
+
+        if not (name or key):
+            raise ValueError("Must specify either bucket name or key")
+
+        if file_name_glob is not None and not file_name_glob.strip():
+            raise ValueError("file_name_glob cannot be empty")
+
+        bucket = await self.retrieve_async(
+            name=name, key=key, folder_key=folder_key, folder_path=folder_path
+        )
+
+        spec = self._get_files_spec(
+            bucket.id,
+            prefix=prefix,
+            recursive=recursive,
+            file_name_glob=file_name_glob,
+            skip=skip,
+            top=top,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        items = response.get("value", [])
+
+        files = []
+        for item in items:
+            if not item.get("IsDirectory", False):
+                try:
+                    files.append(BucketFile.model_validate(item))
+                except Exception as e:
+                    raise ValueError(
+                        f"Failed to parse file entry: {e}. Item: {item}"
+                    ) from e
+
+        return PagedResult(
+            items=files,
+            has_more=len(items) == top,  # Raw count, not len(files)
+            skip=skip,
+            top=top,
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _list_spec(
+        self,
+        folder_path: Optional[str],
+        folder_key: Optional[str],
+        name: Optional[str],
+        skip: int,
+        top: int,
+    ) -> RequestSpec:
+        """Build OData request for listing buckets."""
+        filters = []
+        if name:
+            escaped_name = name.replace("'", "''")
+            filters.append(f"contains(tolower(Name), tolower('{escaped_name}'))")
+
+        filter_str = " and ".join(filters) if filters else None
+
+        params: Dict[str, Any] = {"$skip": skip, "$top": top}
+        if filter_str:
+            params["$filter"] = filter_str
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/Buckets"),
+            params=params,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _create_spec(
+        self,
+        name: str,
+        description: Optional[str],
+        identifier: str,
+        folder_path: Optional[str],
+        folder_key: Optional[str],
+    ) -> RequestSpec:
+        """Build request for creating bucket."""
+        body = {
+            "Name": name,
+            "Identifier": identifier,
+        }
+        if description:
+            body["Description"] = description
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/orchestrator_/odata/Buckets"),
+            json=body,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_spec(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        escaped_name = name.replace("'", "''")
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/Buckets"),
+            params={"$filter": f"Name eq '{escaped_name}'", "$top": 1},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_readUri_spec(
+        self,
+        bucket_id: int,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetReadUri"
+            ),
+            params={"path": blob_file_path},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_writeri_spec(
+        self,
+        bucket_id: int,
+        content_type: str,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetWriteUri"
+            ),
+            params={"path": blob_file_path, "contentType": content_type},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_by_key_spec(
+        self,
+        key: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        escaped_key = key.replace("'", "''")
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{escaped_key}')"
+            ),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _list_files_spec(
+        self,
+        bucket_id: int,
+        prefix: str,
+        continuation_token: Optional[str] = None,
+        take_hint: int = 500,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        """Build REST API request for listing files in a bucket.
+
+        Uses the /api/Buckets/{id}/ListFiles endpoint which supports cursor-based pagination.
+
+        Args:
+            bucket_id: The bucket ID
+            prefix: Path prefix for filtering
+            continuation_token: Token for pagination
+            take_hint: Minimum number of files to return (default 500, max 1000)
+            folder_key: Folder key
+            folder_path: Folder path
+        """
+        params: Dict[str, Any] = {}
+        if prefix:
+            params["prefix"] = prefix
+        if continuation_token is not None:
+            params["continuationToken"] = continuation_token
+        params["takeHint"] = take_hint
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/api/Buckets/{bucket_id}/ListFiles"),
+            params=params,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _delete_file_spec(
+        self,
+        bucket_id: int,
+        blob_file_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        """Build request for deleting a file from a bucket."""
+        return RequestSpec(
+            method="DELETE",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.DeleteFile"
+            ),
+            params={"path": blob_file_path},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _get_files_spec(
+        self,
+        bucket_id: int,
+        prefix: str = "",
+        recursive: bool = False,
+        file_name_glob: Optional[str] = None,
+        skip: int = 0,
+        top: int = 500,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        """Build OData request for GetFiles endpoint.
+
+        Args:
+            bucket_id: Bucket ID
+            prefix: Directory path prefix
+            recursive: Recurse subdirectories
+            file_name_glob: File name filter pattern
+            skip: Number of items to skip (pagination)
+            top: Number of items to return (pagination)
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            RequestSpec: OData request specification
+        """
+        params: Dict[str, Any] = {}
+
+        params["directory"] = "/" if not prefix else prefix
+
+        if recursive:
+            params["recursive"] = "true"
+
+        if file_name_glob:
+            params["fileNameGlob"] = file_name_glob
+
+        if skip > 0:
+            params["$skip"] = skip
+        params["$top"] = top
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetFiles"
+            ),
+            params=params,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_folder_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_folder_service.py
new file mode 100644
index 000000000..84c5abdb3
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_folder_service.py
@@ -0,0 +1,222 @@
+from typing import Optional
+
+from typing_extensions import deprecated
+from uipath.core import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from ..errors import FolderNotFoundException
+from .folder import PersonalWorkspace
+
+
+class FolderService(BaseService):
+    """Service for managing UiPath Folders.
+
+    A folder represents a single area for data organization
+    and access control - it is created when you need to categorize, manage, and enforce authorization rules for a group
+    of UiPath resources (i.e. processes, assets, connections, storage buckets etc.) or other folders
+    """
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def retrieve_folder_key(self, folder_path: str | None) -> str | None:
+        """Resolve a folder path to its corresponding folder key.
+
+        Args:
+            folder_path: Folder path to resolve to a key
+
+        Returns:
+            The resolved folder key
+
+        Raises:
+            ValueError: If folder_path is None or if folder_path is not found
+        """
+        if folder_path is None:
+            raise ValueError("Cannot obtain folder_key without providing folder_path")
+
+        resolved_folder_key = self.retrieve_key(folder_path=folder_path)
+        if not resolved_folder_key:
+            raise FolderNotFoundException(folder_path)
+        return resolved_folder_key
+
+    async def retrieve_folder_key_async(self, folder_path: str | None) -> str | None:
+        """Asynchronously resolve a folder path to its corresponding folder key.
+
+        Args:
+            folder_path: Folder path to resolve to a key
+
+        Returns:
+            The resolved folder key
+
+        Raises:
+            ValueError: If folder_path is None or if folder_path is not found
+        """
+        if folder_path is None:
+            raise ValueError("Cannot obtain folder_key without providing folder_path")
+
+        resolved_folder_key = await self.retrieve_key_async(folder_path=folder_path)
+        if not resolved_folder_key:
+            raise FolderNotFoundException(folder_path)
+        return resolved_folder_key
+
+    @traced(name="folder_retrieve_key_by_folder_path", run_type="uipath")
+    @deprecated("Use retrieve_key instead")
+    def retrieve_key_by_folder_path(self, folder_path: str) -> Optional[str]:
+        return self.retrieve_key(folder_path=folder_path)
+
+    @traced(name="folder_retrieve_key", run_type="uipath")
+    def retrieve_key(self, *, folder_path: str) -> Optional[str]:
+        """Retrieve the folder key by folder path with pagination support.
+
+        Args:
+            folder_path: The fully qualified folder path to search for.
+
+        Returns:
+            The folder key if found, None otherwise.
+        """
+        skip = 0
+        take = 20
+
+        while True:
+            spec = self._retrieve_spec(folder_path, skip=skip, take=take)
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+            ).json()
+
+            # Search for the folder in current page
+            folder_key = next(
+                (
+                    item["Key"]
+                    for item in response["PageItems"]
+                    if item["FullyQualifiedName"] == folder_path
+                ),
+                None,
+            )
+
+            if folder_key is not None:
+                return folder_key
+
+            page_items = response["PageItems"]
+            if len(page_items) < take:
+                break
+
+            skip += take
+
+        return None
+
+    @traced(name="folder_retrieve_key", run_type="uipath")
+    async def retrieve_key_async(self, *, folder_path: str) -> Optional[str]:
+        """Retrieve the folder key by folder path with pagination support.
+
+        Args:
+            folder_path: The fully qualified folder path to search for.
+
+        Returns:
+            The folder key if found, None otherwise.
+        """
+        skip = 0
+        take = 20
+
+        while True:
+            spec = self._retrieve_spec(folder_path, skip=skip, take=take)
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                )
+            ).json()
+
+            # Search for the folder in current page
+            folder_key = next(
+                (
+                    item["Key"]
+                    for item in response["PageItems"]
+                    if item["FullyQualifiedName"] == folder_path
+                ),
+                None,
+            )
+
+            if folder_key is not None:
+                return folder_key
+
+            page_items = response["PageItems"]
+            if len(page_items) < take:
+                break
+
+            skip += take
+
+        return None
+
+    def _retrieve_spec(
+        self, folder_path: str, *, skip: int = 0, take: int = 20
+    ) -> RequestSpec:
+        folder_name = folder_path.split("/")[-1]
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                "orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser"
+            ),
+            params={
+                "searchText": folder_name,
+                "skip": skip,
+                "take": take,
+            },
+        )
+
+    @traced(name="folder_get_personal_workspace", run_type="uipath")
+    def get_personal_workspace(self) -> PersonalWorkspace:
+        """Retrieve the personal workspace folder for the current user.
+
+        Returns:
+            PersonalWorkspace: The personal workspace information.
+
+        Raises:
+            ValueError: If the user does not have a personal workspace.
+        """
+        response = self.request(
+            "GET",
+            url=Endpoint(
+                "orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended"
+            ),
+            params={"$select": "PersonalWorkspace", "$expand": "PersonalWorkspace"},
+        ).json()
+
+        personal_workspace = response.get("PersonalWorkspace")
+        if personal_workspace is None:
+            raise ValueError("Failed to fetch personal workspace")
+
+        return PersonalWorkspace.model_validate(personal_workspace)
+
+    @traced(name="folder_get_personal_workspace_async", run_type="uipath")
+    async def get_personal_workspace_async(self) -> PersonalWorkspace:
+        """Asynchronously retrieve the personal workspace folder for the current user.
+
+        Returns:
+            PersonalWorkspace: The personal workspace information.
+
+        Raises:
+            ValueError: If the personal workspace cannot be fetched.
+        """
+        response = (
+            await self.request_async(
+                "GET",
+                url=Endpoint(
+                    "orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended"
+                ),
+                params={"$select": "PersonalWorkspace", "$expand": "PersonalWorkspace"},
+            )
+        ).json()
+
+        personal_workspace = response.get("PersonalWorkspace")
+        if personal_workspace is None:
+            raise ValueError("Failed to fetch personal workspace")
+
+        return PersonalWorkspace.model_validate(personal_workspace)
diff --git a/src/uipath/_services/jobs_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_jobs_service.py
similarity index 57%
rename from src/uipath/_services/jobs_service.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/_jobs_service.py
index 55068e204..a9a132e02 100644
--- a/src/uipath/_services/jobs_service.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_jobs_service.py
@@ -1,4 +1,3 @@
-import json
 import os
 import shutil
 import tempfile
@@ -6,15 +5,20 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union, cast, overload
 
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder
-from .._utils.constants import TEMP_ATTACHMENTS_FOLDER
-from ..models.job import Job
-from ..tracing._traced import traced
-from ._base_service import BaseService
-from .attachments_service import AttachmentsService
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..common.constants import TEMP_ATTACHMENTS_FOLDER
+from ..common.paging import PagedResult
+from ..common.validation import validate_pagination_params
+from ..errors import EnrichedException
+from ._attachments_service import AttachmentsService
+from .job import Job
 
 
 class JobsService(FolderContext, BaseService):
@@ -25,7 +29,13 @@ class JobsService(FolderContext, BaseService):
       start time, and any input/output data.
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    # Pagination limits
+    MAX_PAGE_SIZE = 1000  # Maximum items per page
+    MAX_SKIP_OFFSET = 10000  # Maximum skip offset
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
         self._attachments_service = AttachmentsService(config, execution_context)
         # Define the temp directory path for local attachments
@@ -81,7 +91,7 @@ def resume(
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
-            content=spec.content,
+            json=spec.json,
         )
 
     async def resume_async(
@@ -106,7 +116,7 @@ async def resume_async(
             ```python
             import asyncio
 
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             sdk = UiPath()
 
@@ -142,19 +152,339 @@ async def main():  # noqa: D103
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
-            content=spec.content,
+            json=spec.json,
         )
 
     @property
     def custom_headers(self) -> Dict[str, str]:
         return self.folder_headers
 
-    def retrieve(
+    @traced(name="jobs_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Job]:
+        """List jobs using OData API with offset-based pagination.
+
+        Returns a single page of results with pagination metadata.
+
+        Args:
+            folder_path: Folder path to filter jobs
+            folder_key: Folder key (mutually exclusive with folder_path)
+            filter: OData $filter expression (e.g., "State eq 'Successful'")
+            orderby: OData $orderby expression (e.g., "CreationTime desc")
+            skip: Number of items to skip (default 0, max 10000)
+            top: Maximum items per page (default 100, max 1000)
+
+        Returns:
+            PagedResult[Job]: Page of jobs with pagination metadata
+
+        Raises:
+            ValueError: If skip or top parameters are invalid
+
+        Examples:
+            >>> result = sdk.jobs.list(top=100)
+            >>> for job in result.items:
+            ...     print(job.key, job.state)
+            >>> print(f"Has more: {result.has_more}")
+        """
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=self.MAX_SKIP_OFFSET,
+            max_top=self.MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            filter=filter,
+            orderby=orderby,
+            skip=skip,
+            top=top,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        items = response.get("value", [])
+        jobs = [Job.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=jobs,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @traced(name="jobs_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        filter: Optional[str] = None,
+        orderby: Optional[str] = None,
+        skip: int = 0,
+        top: int = 100,
+    ) -> PagedResult[Job]:
+        """Async version of list() with offset-based pagination."""
+        validate_pagination_params(
+            skip=skip,
+            top=top,
+            max_skip=self.MAX_SKIP_OFFSET,
+            max_top=self.MAX_PAGE_SIZE,
+        )
+
+        spec = self._list_spec(
+            folder_path=folder_path,
+            folder_key=folder_key,
+            filter=filter,
+            orderby=orderby,
+            skip=skip,
+            top=top,
+        )
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        items = response.get("value", [])
+        jobs = [Job.model_validate(item) for item in items]
+
+        return PagedResult(
+            items=jobs,
+            has_more=len(items) == top,
+            skip=skip,
+            top=top,
+        )
+
+    @traced(name="jobs_stop", run_type="uipath")
+    def stop(
+        self,
+        *,
+        job_keys: List[str],
+        strategy: str = "SoftStop",
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> None:
+        """Stop one or more jobs with specified strategy.
+
+        This method uses bulk resolution to efficiently stop multiple jobs,
+        preventing N+1 query issues. Requests are automatically chunked for
+        large job lists to avoid URL length constraints.
+
+        Args:
+            job_keys: List of job UUID keys to stop
+            strategy: Stop strategy - "SoftStop" (graceful) or "Kill" (force)
+            folder_path: Folder path
+            folder_key: Folder key
+
+        Raises:
+            ValueError: If any job key is not a valid UUID format
+            LookupError: If any job keys are not found
+
+        Examples:
+            >>> sdk.jobs.stop(job_keys=["ee9327fd-237d-419e-86ef-9946b34461e3"])
+            >>> sdk.jobs.stop(job_keys=["key1", "key2"], strategy="Kill")
+
+        Note:
+            Large batches are automatically chunked (50 keys per request) to
+            avoid URL length limits. The method supports stopping hundreds of
+            jobs efficiently.
+        """
+        job_ids = self._resolve_job_identifiers(
+            job_keys=job_keys,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        spec = self._stop_spec(
+            job_ids=job_ids,
+            strategy=strategy,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+    @traced(name="jobs_stop", run_type="uipath")
+    async def stop_async(
+        self,
+        *,
+        job_keys: List[str],
+        strategy: str = "SoftStop",
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> None:
+        """Async version of stop()."""
+        job_ids = await self._resolve_job_identifiers_async(
+            job_keys=job_keys,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        spec = self._stop_spec(
+            job_ids=job_ids,
+            strategy=strategy,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+    @traced(name="jobs_restart", run_type="uipath")
+    def restart(
+        self,
+        *,
+        job_key: str,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> Job:
+        """Restart a completed or failed job.
+
+        Args:
+            job_key: Job UUID key to restart
+            folder_path: Folder path
+            folder_key: Folder key
+
+        Returns:
+            Job: The restarted job
+
+        Examples:
+            >>> restarted_job = sdk.jobs.restart(job_key="ee9327fd-237d-419e-86ef-9946b34461e3")
+            >>> print(restarted_job.state)
+        """
+        job_ids = self._resolve_job_identifiers(
+            job_keys=[job_key],
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        spec = self._restart_spec(
+            job_id=job_ids[0],
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return Job.model_validate(response.json())
+
+    @traced(name="jobs_restart", run_type="uipath")
+    async def restart_async(
+        self,
+        *,
+        job_key: str,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+    ) -> Job:
+        """Async version of restart()."""
+        job_ids = await self._resolve_job_identifiers_async(
+            job_keys=[job_key],
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        spec = self._restart_spec(
+            job_id=job_ids[0],
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+        )
+
+        return Job.model_validate(response.json())
+
+    @traced(name="jobs_exists", run_type="uipath")
+    def exists(
+        self,
+        job_key: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> bool:
+        """Check if job exists.
+
+        Args:
+            job_key: Job UUID key
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            bool: True if job exists, False otherwise
+
+        Examples:
+            >>> if sdk.jobs.exists(job_key="ee9327fd-237d-419e-86ef-9946b34461e3"):
+            ...     print("Job found")
+        """
+        try:
+            self.retrieve(
+                job_key=job_key, folder_key=folder_key, folder_path=folder_path
+            )
+            return True
+        except LookupError:
+            return False
+
+    @traced(name="jobs_exists", run_type="uipath")
+    async def exists_async(
         self,
         job_key: str,
         *,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
+    ) -> bool:
+        """Async version of exists()."""
+        try:
+            await self.retrieve_async(
+                job_key=job_key, folder_key=folder_key, folder_path=folder_path
+            )
+            return True
+        except LookupError:
+            return False
+
+    @resource_override(resource_type="process", resource_identifier="process_name")
+    @traced(name="jobs_retrieve", run_type="uipath")
+    def retrieve(
+        self,
+        job_key: str,
+        *,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+        process_name: str | None = None,
     ) -> Job:
         """Retrieve a job identified by its key.
 
@@ -162,13 +492,17 @@ def retrieve(
             job_key (str): The job unique identifier.
             folder_key (Optional[str]): The key of the folder in which the job was executed.
             folder_path (Optional[str]): The path of the folder in which the job was executed.
+            process_name: process name hint for resource override
 
         Returns:
             Job: The retrieved job.
 
+        Raises:
+            LookupError: If the job with the specified key is not found.
+
         Examples:
             ```python
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             sdk = UiPath()
             job = sdk.jobs.retrieve(job_key="ee9327fd-237d-419e-86ef-9946b34461e3", folder_path="Shared")
@@ -177,20 +511,27 @@ def retrieve(
         spec = self._retrieve_spec(
             job_key=job_key, folder_key=folder_key, folder_path=folder_path
         )
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            headers=spec.headers,
-        )
-
-        return Job.model_validate(response.json())
-
+        try:
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                headers=spec.headers,
+            )
+            return Job.model_validate(response.json())
+        except EnrichedException as e:
+            if e.status_code == 404:
+                raise LookupError(f"Job with key '{job_key}' not found") from e
+            raise
+
+    @resource_override(resource_type="process", resource_identifier="process_name")
+    @traced(name="jobs_retrieve_async", run_type="uipath")
     async def retrieve_async(
         self,
         job_key: str,
         *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+        process_name: str | None = None,
     ) -> Job:
         """Asynchronously retrieve a job identified by its key.
 
@@ -198,15 +539,19 @@ async def retrieve_async(
             job_key (str): The job unique identifier.
             folder_key (Optional[str]): The key of the folder in which the job was executed.
             folder_path (Optional[str]): The path of the folder in which the job was executed.
+            process_name: process name hint for resource override
 
         Returns:
             Job: The retrieved job.
 
+        Raises:
+            LookupError: If the job with the specified key is not found.
+
         Examples:
             ```python
             import asyncio
 
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             sdk = UiPath()
 
@@ -220,13 +565,17 @@ async def main():  # noqa: D103
         spec = self._retrieve_spec(
             job_key=job_key, folder_key=folder_key, folder_path=folder_path
         )
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            headers=spec.headers,
-        )
-
-        return Job.model_validate(response.json())
+        try:
+            response = await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                headers=spec.headers,
+            )
+            return Job.model_validate(response.json())
+        except EnrichedException as e:
+            if e.status_code == 404:
+                raise LookupError(f"Job with key '{job_key}' not found") from e
+            raise
 
     def _retrieve_inbox_id(
         self,
@@ -325,11 +674,57 @@ def _retrieve_api_payload_spec(
             },
         )
 
+    def retrieve_inbox_payload(self, inbox_id: str) -> Any:
+        """Fetch payload data for Integration Services (Inbox) triggers.
+
+        Unlike `retrieve_api_payload`, this returns the response body as-is.
+        Orchestrator's `GET /JobTriggers/GetPayload/{inboxId}` returns the
+        stored payload directly without an envelope.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The stored payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        return response.json()
+
+    async def retrieve_inbox_payload_async(self, inbox_id: str) -> Any:
+        """Asynchronously fetch payload data for Integration Services (Inbox) triggers.
+
+        Unlike `retrieve_api_payload_async`, this returns the response body
+        as-is. Orchestrator's `GET /JobTriggers/GetPayload/{inboxId}` returns
+        the stored payload directly without an envelope.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The stored payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        return response.json()
+
     def _extract_first_inbox_id(self, response: Any) -> str:
         if len(response["value"]) > 0:
             return response["value"][0]["ItemKey"]
         else:
-            raise Exception("No inbox found")
+            raise LookupError("No inbox found")
 
     def _retrieve_inbox_id_spec(
         self,
@@ -351,6 +746,54 @@ def _retrieve_inbox_id_spec(
             },
         )
 
+    def extract_output(self, job: Job) -> Optional[str]:
+        """Get the actual output data, downloading from attachment if necessary.
+
+        Args:
+            job: The job instance to fetch output data from.
+
+        Returns:
+            Parsed output arguments as dictionary, or None if no output
+        """
+        if job.output_file:
+            # Large output stored as attachment
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir) / f"output_{job.output_file}"
+                self._attachments_service.download(
+                    key=uuid.UUID(job.output_file), destination_path=temp_path
+                )
+                with open(temp_path, "r", encoding="utf-8") as f:
+                    return f.read()
+        elif job.output_arguments:
+            # Small output stored inline
+            return job.output_arguments
+        else:
+            return None
+
+    async def extract_output_async(self, job: Job) -> Optional[str]:
+        """Asynchronously fetch the actual output data, downloading from attachment if necessary.
+
+        Args:
+            job: The job instance to fetch output data from.
+
+        Returns:
+            Parsed output arguments as dictionary, or None if no output
+        """
+        if job.output_file:
+            # Large output stored as attachment
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir) / f"output_{job.output_file}"
+                await self._attachments_service.download_async(
+                    key=uuid.UUID(job.output_file), destination_path=temp_path
+                )
+                with open(temp_path, "r", encoding="utf-8") as f:
+                    return f.read()
+        elif job.output_arguments:
+            # Small output stored inline
+            return job.output_arguments
+        else:
+            return None
+
     def _resume_spec(
         self,
         *,
@@ -364,7 +807,7 @@ def _resume_spec(
             endpoint=Endpoint(
                 f"/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
             ),
-            content=json.dumps({"payload": payload}),
+            json={"payload": payload},
             headers={
                 **header_folder(folder_key, folder_path),
             },
@@ -451,7 +894,7 @@ async def list_attachments_async(
         Examples:
             ```python
             import asyncio
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -636,7 +1079,7 @@ def create_attachment(
 
         Examples:
             ```python
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -776,7 +1219,7 @@ async def create_attachment_async(
         Examples:
             ```python
             import asyncio
-            from uipath import UiPath
+            from uipath.platform import UiPath
 
             client = UiPath()
 
@@ -873,3 +1316,221 @@ async def main():
 
             # Return only the UUID
             return attachment_id
+
+    def _list_spec(
+        self,
+        folder_path: Optional[str],
+        folder_key: Optional[str],
+        filter: Optional[str],
+        orderby: Optional[str],
+        skip: int,
+        top: int,
+    ) -> RequestSpec:
+        """Build OData request for listing jobs."""
+        params: Dict[str, Any] = {"$skip": skip, "$top": top}
+        if filter:
+            params["$filter"] = filter
+        if orderby:
+            params["$orderby"] = orderby
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/Jobs"),
+            params=params,
+            headers={**header_folder(folder_key, folder_path)},
+        )
+
+    def _stop_spec(
+        self,
+        job_ids: List[int],
+        strategy: str,
+        folder_key: Optional[str],
+        folder_path: Optional[str],
+    ) -> RequestSpec:
+        """Build request for stopping jobs with strategy.
+
+        Pure function - no HTTP calls, no side effects.
+
+        Args:
+            job_ids: List of job integer IDs (already resolved)
+            strategy: Stop strategy ("SoftStop" or "Kill")
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            RequestSpec: Request specification for StopJobs endpoint
+        """
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StopJobs"
+            ),
+            json={
+                "jobIds": job_ids,
+                "strategy": strategy,
+            },
+            headers={**header_folder(folder_key, folder_path)},
+        )
+
+    def _restart_spec(
+        self,
+        job_id: int,
+        folder_key: Optional[str],
+        folder_path: Optional[str],
+    ) -> RequestSpec:
+        """Build request for restarting a job."""
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.RestartJob"
+            ),
+            json={"jobId": job_id},
+            headers={**header_folder(folder_key, folder_path)},
+        )
+
+    def _resolve_job_identifiers(
+        self,
+        job_keys: List[str],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[int]:
+        """Resolve job keys to job IDs in chunked bulk queries.
+
+        This method prevents N+1 query issues by fetching all job IDs using
+        OData $filter with 'in' operator. Requests are chunked to avoid URL
+        length limits (max 50 keys per request).
+
+        Args:
+            job_keys: List of job UUID keys to resolve
+            folder_key: Folder key
+            folder_path: Folder path
+
+        Returns:
+            List[int]: List of job integer IDs in same order as job_keys
+
+        Raises:
+            ValueError: If any job key is not a valid UUID
+            LookupError: If any job key is not found
+
+        Note:
+            Duplicate keys in input are allowed and will return corresponding IDs.
+        """
+        if not job_keys:
+            return []
+
+        for key in job_keys:
+            try:
+                uuid.UUID(key)
+            except ValueError as e:
+                raise ValueError(f"Invalid job key format: {key}") from e
+
+        unique_keys = []
+        seen = set()
+        for key in job_keys:
+            if key not in seen:
+                unique_keys.append(key)
+                seen.add(key)
+
+        CHUNK_SIZE = 50
+        all_key_to_id: Dict[str, int] = {}
+
+        for i in range(0, len(unique_keys), CHUNK_SIZE):
+            chunk = unique_keys[i : i + CHUNK_SIZE]
+            keys_formatted = "','".join(chunk)
+            filter_expr = f"Key in ('{keys_formatted}')"
+
+            spec = RequestSpec(
+                method="GET",
+                endpoint=Endpoint("/orchestrator_/odata/Jobs"),
+                params={
+                    "$filter": filter_expr,
+                    "$select": "Id,Key",
+                    "$top": len(chunk),
+                },
+                headers={**header_folder(folder_key, folder_path)},
+            )
+
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            ).json()
+
+            items = response.get("value", [])
+
+            # Accumulate mappings from this chunk
+            for item in items:
+                all_key_to_id[item["Key"]] = item["Id"]
+
+        # Verify all unique keys were found
+        if len(all_key_to_id) != len(unique_keys):
+            found_keys = set(all_key_to_id.keys())
+            missing_keys = set(unique_keys) - found_keys
+            raise LookupError(f"Jobs not found for keys: {', '.join(missing_keys)}")
+
+        # Build result preserving original order (including duplicates)
+        return [all_key_to_id[key] for key in job_keys]
+
+    async def _resolve_job_identifiers_async(
+        self,
+        job_keys: List[str],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[int]:
+        """Async version of _resolve_job_identifiers()."""
+        if not job_keys:
+            return []
+
+        for key in job_keys:
+            try:
+                uuid.UUID(key)
+            except ValueError as e:
+                raise ValueError(f"Invalid job key format: {key}") from e
+
+        unique_keys = []
+        seen = set()
+        for key in job_keys:
+            if key not in seen:
+                unique_keys.append(key)
+                seen.add(key)
+
+        CHUNK_SIZE = 50
+        all_key_to_id: Dict[str, int] = {}
+
+        for i in range(0, len(unique_keys), CHUNK_SIZE):
+            chunk = unique_keys[i : i + CHUNK_SIZE]
+            keys_formatted = "','".join(chunk)
+            filter_expr = f"Key in ('{keys_formatted}')"
+
+            spec = RequestSpec(
+                method="GET",
+                endpoint=Endpoint("/orchestrator_/odata/Jobs"),
+                params={
+                    "$filter": filter_expr,
+                    "$select": "Id,Key",
+                    "$top": len(chunk),
+                },
+                headers={**header_folder(folder_key, folder_path)},
+            )
+
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                )
+            ).json()
+
+            items = response.get("value", [])
+
+            for item in items:
+                all_key_to_id[item["Key"]] = item["Id"]
+
+        if len(all_key_to_id) != len(unique_keys):
+            found_keys = set(all_key_to_id.keys())
+            missing_keys = set(unique_keys) - found_keys
+            raise LookupError(f"Jobs not found for keys: {', '.join(missing_keys)}")
+
+        return [all_key_to_id[key] for key in job_keys]
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_mcp_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_mcp_service.py
new file mode 100644
index 000000000..195eb8240
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_mcp_service.py
@@ -0,0 +1,237 @@
+from typing import List
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ._folder_service import FolderService
+from .mcp import McpServer
+
+
+class McpService(FolderContext, BaseService):
+    """Service for managing MCP (Model Context Protocol) servers in UiPath.
+
+    MCP servers provide contextual information and capabilities that can be used
+    by AI agents and automation processes.
+    """
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folders_service: FolderService,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
+
+    @traced(name="mcp_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        folder_path: str | None = None,
+    ) -> List[McpServer]:
+        """List all MCP servers.
+
+        Args:
+            folder_path (Optional[str]): The path of the folder to list servers from.
+
+        Returns:
+            List[McpServer]: A list of MCP servers with their configuration.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            servers = client.mcp.list(folder_path="MyFolder")
+            for server in servers:
+                print(f"{server.name} - {server.slug}")
+            ```
+        """
+        spec = self._list_spec(
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return [McpServer.model_validate(server) for server in response.json()]
+
+    @traced(name="mcp_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        folder_path: str | None = None,
+    ) -> List[McpServer]:
+        """Asynchronously list all MCP servers.
+
+        Args:
+            folder_path (Optional[str]): The path of the folder to list servers from.
+
+        Returns:
+            List[McpServer]: A list of MCP servers with their configuration.
+
+        Examples:
+            ```python
+            import asyncio
+
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                servers = await sdk.mcp.list_async(folder_path="MyFolder")
+                for server in servers:
+                    print(f"{server.name} - {server.slug}")
+
+            asyncio.run(main())
+            ```
+        """
+        spec = self._list_spec(
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return [McpServer.model_validate(server) for server in response.json()]
+
+    @resource_override(resource_type="mcpServer", resource_identifier="slug")
+    @traced(name="mcp_retrieve", run_type="uipath")
+    def retrieve(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None = None,
+    ) -> McpServer:
+        """Retrieve a specific MCP server by its slug.
+
+        Args:
+            slug (str): The unique slug identifier for the server.
+            folder_path (Optional[str]): The path of the folder where the server is located.
+
+        Returns:
+            McpServer: The MCP server configuration.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            server = client.mcp.retrieve(slug="my-server-slug", folder_path="MyFolder")
+            print(f"Server: {server.name}, URL: {server.mcp_url}")
+            ```
+        """
+        spec = self._retrieve_spec(
+            slug=slug,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return McpServer.model_validate(response.json())
+
+    @resource_override(resource_type="mcpServer", resource_identifier="slug")
+    @traced(name="mcp_retrieve", run_type="uipath")
+    async def retrieve_async(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None = None,
+    ) -> McpServer:
+        """Asynchronously retrieve a specific MCP server by its slug.
+
+        Args:
+            slug (str): The unique slug identifier for the server.
+            folder_path (Optional[str]): The path of the folder where the server is located.
+
+        Returns:
+            McpServer: The MCP server configuration.
+
+        Examples:
+            ```python
+            import asyncio
+
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                server = await sdk.mcp.retrieve_async(slug="my-server-slug", folder_path="MyFolder")
+                print(f"Server: {server.name}, URL: {server.mcp_url}")
+
+            asyncio.run(main())
+            ```
+        """
+        spec = self._retrieve_spec(
+            slug=slug,
+            folder_path=folder_path,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        return McpServer.model_validate(response.json())
+
+    @property
+    def custom_headers(self) -> dict[str, str]:
+        return self.folder_headers
+
+    def _resolve_folder_key(self, folder_path: str | None) -> str | None:
+        """Resolve folder key from folder_path, falling back to FolderContext."""
+        if folder_path is not None:
+            return self._folders_service.retrieve_folder_key(folder_path)
+
+        return self._folder_key
+
+    def _list_spec(
+        self,
+        *,
+        folder_path: str | None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_path)
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/agenthub_/api/servers"),
+            headers={
+                **header_folder(folder_key, None),
+            },
+        )
+
+    def _retrieve_spec(
+        self,
+        slug: str,
+        *,
+        folder_path: str | None,
+    ) -> RequestSpec:
+        folder_key = self._resolve_folder_key(folder_path)
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/agenthub_/api/servers/{slug}"),
+            headers={
+                **header_folder(folder_key, None),
+            },
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_orchestrator_setup_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_orchestrator_setup_service.py
new file mode 100644
index 000000000..9a386ce31
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_orchestrator_setup_service.py
@@ -0,0 +1,58 @@
+"""Orchestrator setup service for UiPath Platform."""
+
+import logging
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+
+logger = logging.getLogger(__name__)
+
+
+class OrchestratorSetupService(BaseService):
+    """Service for orchestrator provisioning and licensing operations."""
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def enable_first_run(self) -> None:
+        """Fire-and-forget POST requests to enable first run for StudioWeb.
+
+        Posts to TryEnableFirstRun and AcquireLicense endpoints.
+        """
+        paths = [
+            "orchestrator_/api/StudioWeb/TryEnableFirstRun",
+            "orchestrator_/api/StudioWeb/AcquireLicense",
+        ]
+
+        for path in paths:
+            try:
+                self.request("POST", path)
+            except Exception as exc:
+                logger.warning(
+                    "OrchestratorSetupService enable_first_run: POST %s failed: %s",
+                    path,
+                    exc,
+                )
+
+    async def enable_first_run_async(self) -> None:
+        """Fire-and-forget POST requests to enable first run for StudioWeb.
+
+        Posts to TryEnableFirstRun and AcquireLicense endpoints.
+        """
+        paths = [
+            "orchestrator_/api/StudioWeb/TryEnableFirstRun",
+            "orchestrator_/api/StudioWeb/AcquireLicense",
+        ]
+
+        for path in paths:
+            try:
+                await self.request_async("POST", path)
+            except Exception as exc:
+                logger.warning(
+                    "OrchestratorSetupService enable_first_run_async: POST %s failed: %s",
+                    path,
+                    exc,
+                )
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_processes_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_processes_service.py
new file mode 100644
index 000000000..e6ecc988a
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_processes_service.py
@@ -0,0 +1,351 @@
+import json
+import os
+import uuid
+from typing import Any, Dict, Optional, Union
+
+from opentelemetry import trace
+from opentelemetry.trace import format_span_id
+from uipath.core.tracing import traced
+
+from ..attachments import Attachment
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig, UiPathConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..common._span_utils import _SpanUtils
+from ..common.constants import ENV_JOB_KEY, HEADER_JOB_KEY
+from ._attachments_service import AttachmentsService
+from .job import Job
+
+
+class ProcessesService(FolderContext, BaseService):
+    """Service for managing and executing UiPath automation processes.
+
+    Processes (also known as automations or workflows) are the core units of
+    automation in UiPath, representing sequences of activities that perform
+    specific business tasks.
+    """
+
+    _INPUT_ARGUMENTS_SIZE_LIMIT = 10000
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        attachment_service: AttachmentsService,
+    ) -> None:
+        self._attachments_service = attachment_service
+        super().__init__(config=config, execution_context=execution_context)
+
+    @resource_override(resource_type="process")
+    @traced(name="processes_invoke", run_type="uipath")
+    def invoke(
+        self,
+        name: str,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        attachments: Optional[list[Attachment]] = None,
+        parent_operation_id: Optional[str] = None,
+        run_as_me: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Job:
+        """Start execution of a process by its name.
+
+        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
+
+        Args:
+            name (str): The name of the process to execute.
+            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
+            attachments (Optional[list]): List of Attachment objects to pass to the process.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+            parent_operation_id (Optional[str]): The parent operation ID for BTS tracking correlation.
+            run_as_me (Optional[bool]): If True, the job will run under the calling user's identity.
+
+        Returns:
+            Job: The job execution details.
+
+        Examples:
+            ```python
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            client.processes.invoke(name="MyProcess")
+            ```
+
+            ```python
+            # if you want to execute the process in a specific folder
+            # another one than the one set in the SDK config
+            from uipath.platform import UiPath
+
+            client = UiPath()
+
+            client.processes.invoke(name="MyProcess", folder_path="my-folder-key")
+            ```
+        """
+        input_data = self._handle_input_arguments(
+            input_arguments=input_arguments,
+            attachments=attachments,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        spec = self._invoke_spec(
+            name,
+            input_data=input_data,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            parent_span_id=kwargs.get("parent_span_id"),
+            parent_operation_id=parent_operation_id,
+            run_as_me=run_as_me,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return Job.model_validate(response.json()["value"][0])
+
+    @resource_override(resource_type="process")
+    @traced(name="processes_invoke", run_type="uipath")
+    async def invoke_async(
+        self,
+        name: str,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        attachments: Optional[list[Attachment]] = None,
+        parent_operation_id: Optional[str] = None,
+        run_as_me: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Job:
+        """Asynchronously start execution of a process by its name.
+
+        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
+
+        Args:
+            name (str): The name of the process to execute.
+            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
+            attachments (Optional[list]): List of Attachment objects to pass to the process.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+            parent_operation_id (Optional[str]): The parent operation ID for BTS tracking correlation.
+            run_as_me (Optional[bool]): If True, the job will run under the calling user's identity.
+
+        Returns:
+            Job: The job execution details.
+
+        Examples:
+            ```python
+            import asyncio
+
+            from uipath.platform import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                job = await sdk.processes.invoke_async("testAppAction")
+                print(job)
+
+            asyncio.run(main())
+            ```
+        """
+        input_data = await self._handle_input_arguments_async(
+            input_arguments=input_arguments,
+            attachments=attachments,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        spec = self._invoke_spec(
+            name,
+            input_data=input_data,
+            folder_key=folder_key,
+            folder_path=folder_path,
+            parent_span_id=kwargs.get("parent_span_id"),
+            parent_operation_id=parent_operation_id,
+            run_as_me=run_as_me,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return Job.model_validate(response.json()["value"][0])
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    @staticmethod
+    def _prepare_link_attachments(
+        attachments: Optional[list[Attachment]],
+    ) -> Optional[list[Dict[str, str]]]:
+        """Format attachments for process invocation payload."""
+        if not attachments:
+            return None
+
+        link_attachments = [
+            {"attachmentId": str(att.id)} for att in attachments if att.id is not None
+        ]
+        return link_attachments if link_attachments else None
+
+    def _handle_input_arguments(
+        self,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        attachments: Optional[list[Attachment]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Handle input arguments and attachments, storing as attachment if they exceed size limit.
+
+        Args:
+            input_arguments: The input arguments to process
+            attachments: List of Attachment objects to pass to the process
+            folder_key: The folder key for attachment storage
+            folder_path: The folder path for attachment storage
+
+        Returns:
+            Dict containing either "InputArguments" or "InputFile" key, and optionally "Attachments"
+        """
+        result: Dict[str, Any] = {}
+
+        # handle input arguments
+        if not input_arguments:
+            result["InputArguments"] = json.dumps({})
+        else:
+            # If payload exceeds limit, store as attachment
+            payload_json = json.dumps(input_arguments)
+            if len(payload_json) > self._INPUT_ARGUMENTS_SIZE_LIMIT:
+                attachment_id = self._attachments_service.upload(
+                    name=f"{uuid.uuid4()}.json",
+                    content=payload_json,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+                result["InputFile"] = str(attachment_id)
+            else:
+                result["InputArguments"] = payload_json
+
+        link_attachments = self._prepare_link_attachments(attachments)
+        if link_attachments:
+            result["Attachments"] = link_attachments
+
+        return result
+
+    async def _handle_input_arguments_async(
+        self,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        attachments: Optional[list[Attachment]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Handle input arguments and attachments, storing as attachment if they exceed size limit.
+
+        Args:
+            input_arguments: The input arguments to process
+            attachments: List of Attachment objects to pass to the process
+            folder_key: The folder key for attachment storage
+            folder_path: The folder path for attachment storage
+
+        Returns:
+            Dict containing either "InputArguments" or "InputFile" key, and optionally "Attachments"
+        """
+        result: Dict[str, Any] = {}
+
+        if not input_arguments:
+            result["InputArguments"] = json.dumps({})
+        else:
+            payload_json = json.dumps(input_arguments)
+            if len(payload_json) > self._INPUT_ARGUMENTS_SIZE_LIMIT:
+                attachment_id = await self._attachments_service.upload_async(
+                    name=f"{uuid.uuid4()}.json",
+                    content=payload_json,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+                result["InputFile"] = str(attachment_id)
+            else:
+                result["InputArguments"] = payload_json
+
+        formatted_attachments = self._prepare_link_attachments(attachments)
+        if formatted_attachments:
+            result["Attachments"] = formatted_attachments
+
+        return result
+
+    @staticmethod
+    def _add_tracing(
+        payload: Dict[str, Any],
+        trace_id: Optional[str] = None,
+        parent_span_id: Optional[Union[str, int]] = None,
+    ) -> None:
+        """Enrich payload with trace context for cross-process correlation."""
+        if not trace_id:
+            return
+
+        payload["TraceId"] = _SpanUtils.normalize_trace_id(trace_id)
+        if not parent_span_id:
+            span_context = trace.get_current_span().get_span_context()
+            if span_context.span_id:
+                parent_span_id = format_span_id(span_context.span_id)
+        if parent_span_id:
+            if isinstance(parent_span_id, int):
+                parent_span_id = format_span_id(parent_span_id)
+            payload["ParentSpanId"] = _SpanUtils.normalize_span_id(parent_span_id)
+
+    def _invoke_spec(
+        self,
+        name: str,
+        input_data: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        parent_span_id: Optional[str] = None,
+        parent_operation_id: Optional[str] = None,
+        run_as_me: Optional[bool] = None,
+    ) -> RequestSpec:
+        payload: Dict[str, Any] = {
+            "ReleaseName": name,
+            **(input_data or {}),
+            "Source": "AgentService",
+        }
+        self._add_tracing(payload, UiPathConfig.trace_id, parent_span_id)
+
+        if parent_operation_id:
+            payload["ParentOperationId"] = parent_operation_id
+
+        if run_as_me is not None:
+            payload["RunAsMe"] = run_as_me
+
+        request_spec = RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+            ),
+            json={"startInfo": payload},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+        job_key = os.environ.get(ENV_JOB_KEY, None)
+        if job_key:
+            request_spec.headers[HEADER_JOB_KEY] = job_key
+
+        return request_spec
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_queues_service.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_queues_service.py
new file mode 100644
index 000000000..1a2985072
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_queues_service.py
@@ -0,0 +1,593 @@
+from typing import Any, Dict, List, Optional, Union
+
+from httpx import Response
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._bindings import resource_override
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from .queues import (
+    CommitType,
+    QueueItem,
+    TransactionItem,
+    TransactionItemResult,
+)
+
+
+class QueuesService(FolderContext, BaseService):
+    """Service for managing UiPath queues and queue items.
+
+    Queues are a fundamental component of UiPath automation that enable distributed
+    and scalable processing of work items.
+    """
+
+    def __init__(
+        self, config: UiPathApiConfig, execution_context: UiPathExecutionContext
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_list_items", run_type="uipath")
+    def list_items(
+        self,
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Retrieves a list of queue items from the Orchestrator.
+
+        Args:
+            queue_name (Optional[str]): The name of the queue to filter items by.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the list of queue items.
+        """
+        spec = self._list_items_spec(
+            queue_name=queue_name, folder_key=folder_key, folder_path=folder_path
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_list_items", run_type="uipath")
+    async def list_items_async(
+        self,
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously retrieves a list of queue items from the Orchestrator.
+
+        Args:
+            queue_name (Optional[str]): The name of the queue to filter items by.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the list of queue items.
+        """
+        spec = self._list_items_spec(
+            queue_name=queue_name, folder_key=folder_key, folder_path=folder_path
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_item", run_type="uipath")
+    def create_item(
+        self,
+        item: Union[Dict[str, Any], QueueItem],
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Creates a new queue item in the Orchestrator.
+
+        Args:
+            item: Queue item data, either as a dictionary or QueueItem instance.
+            queue_name (Optional[str]): The name of the queue. Overrides item.name when provided.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the created queue item details.
+
+        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
+        """
+        spec = self._create_item_spec(
+            item, queue_name=queue_name, folder_key=folder_key, folder_path=folder_path
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_item", run_type="uipath")
+    async def create_item_async(
+        self,
+        item: Union[Dict[str, Any], QueueItem],
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously creates a new queue item in the Orchestrator.
+
+        Args:
+            item: Queue item data, either as a dictionary or QueueItem instance.
+            queue_name (Optional[str]): The name of the queue. Overrides item.name when provided.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the created queue item details.
+
+        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
+        """
+        spec = self._create_item_spec(
+            item, queue_name=queue_name, folder_key=folder_key, folder_path=folder_path
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_items", run_type="uipath")
+    def create_items(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Creates multiple queue items in bulk.
+
+        Args:
+            items: List of queue items to create, each either a dictionary or QueueItem instance.
+            queue_name: Name of the target queue.
+            commit_type: Type of commit operation to use for the bulk operation.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the bulk operation result.
+        """
+        spec = self._create_items_spec(
+            items,
+            queue_name,
+            commit_type,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_items", run_type="uipath")
+    async def create_items_async(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously creates multiple queue items in bulk.
+
+        Args:
+            items: List of queue items to create, each either a dictionary or QueueItem instance.
+            queue_name: Name of the target queue.
+            commit_type: Type of commit operation to use for the bulk operation.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the bulk operation result.
+        """
+        spec = self._create_items_spec(
+            items,
+            queue_name,
+            commit_type,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_transaction_item", run_type="uipath")
+    def create_transaction_item(
+        self,
+        item: Union[Dict[str, Any], TransactionItem],
+        queue_name: Optional[str] = None,
+        no_robot: bool = False,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Creates a new transaction item in a queue.
+
+        Args:
+            item: Transaction item data, either as a dictionary or TransactionItem instance.
+            queue_name (Optional[str]): The name of the queue. Overrides item.name when provided.
+            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the transaction item details.
+        """
+        spec = self._create_transaction_item_spec(
+            item,
+            queue_name=queue_name,
+            no_robot=no_robot,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_create_transaction_item", run_type="uipath")
+    async def create_transaction_item_async(
+        self,
+        item: Union[Dict[str, Any], TransactionItem],
+        queue_name: Optional[str] = None,
+        no_robot: bool = False,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously creates a new transaction item in a queue.
+
+        Args:
+            item: Transaction item data, either as a dictionary or TransactionItem instance.
+            queue_name (Optional[str]): The name of the queue. Overrides item.name when provided.
+            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response containing the transaction item details.
+        """
+        spec = self._create_transaction_item_spec(
+            item,
+            queue_name=queue_name,
+            no_robot=no_robot,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_update_progress_of_transaction_item", run_type="uipath")
+    def update_progress_of_transaction_item(
+        self,
+        transaction_key: str,
+        progress: str,
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Updates the progress of a transaction item.
+
+        Args:
+            transaction_key: Unique identifier of the transaction.
+            progress: Progress message to set.
+            queue_name (Optional[str]): The name of the queue the transaction belongs to.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response confirming the progress update.
+
+        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
+        """
+        spec = self._update_progress_of_transaction_item_spec(
+            transaction_key, progress, folder_key=folder_key, folder_path=folder_path
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_update_progress_of_transaction_item", run_type="uipath")
+    async def update_progress_of_transaction_item_async(
+        self,
+        transaction_key: str,
+        progress: str,
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously updates the progress of a transaction item.
+
+        Args:
+            transaction_key: Unique identifier of the transaction.
+            progress: Progress message to set.
+            queue_name (Optional[str]): The name of the queue the transaction belongs to.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response confirming the progress update.
+
+        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
+        """
+        spec = self._update_progress_of_transaction_item_spec(
+            transaction_key, progress, folder_key=folder_key, folder_path=folder_path
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_complete_transaction_item", run_type="uipath")
+    def complete_transaction_item(
+        self,
+        transaction_key: str,
+        result: Union[Dict[str, Any], TransactionItemResult],
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Completes a transaction item with the specified result.
+
+        Args:
+            transaction_key: Unique identifier of the transaction to complete.
+            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
+            queue_name (Optional[str]): The name of the queue the transaction belongs to.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response confirming the transaction completion.
+
+        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
+        """
+        spec = self._complete_transaction_item_spec(
+            transaction_key, result, folder_key=folder_key, folder_path=folder_path
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @resource_override(resource_type="queue", resource_identifier="queue_name")
+    @traced(name="queues_complete_transaction_item", run_type="uipath")
+    async def complete_transaction_item_async(
+        self,
+        transaction_key: str,
+        result: Union[Dict[str, Any], TransactionItemResult],
+        queue_name: Optional[str] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously completes a transaction item with the specified result.
+
+        Args:
+            transaction_key: Unique identifier of the transaction to complete.
+            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
+            queue_name (Optional[str]): The name of the queue the transaction belongs to.
+            folder_key (Optional[str]): The key of the folder. Overrides the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Overrides the default one set in the SDK config.
+
+        Returns:
+            Response: HTTP response confirming the transaction completion.
+
+        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
+        """
+        spec = self._complete_transaction_item_spec(
+            transaction_key, result, folder_key=folder_key, folder_path=folder_path
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, json=spec.json, headers=spec.headers
+        )
+        return response.json()
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _list_items_spec(
+        self,
+        *,
+        queue_name: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        params = {}
+        if queue_name is not None:
+            params["$filter"] = f"QueueDefinitionName eq '{queue_name}'"
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/QueueItems"),
+            params=params,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _create_item_spec(
+        self,
+        item: Union[Dict[str, Any], QueueItem],
+        *,
+        queue_name: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        if isinstance(item, dict):
+            queue_item = QueueItem(**item)
+        elif isinstance(item, QueueItem):
+            queue_item = item
+
+        item_data = queue_item.model_dump(
+            mode="json", exclude_unset=True, by_alias=True
+        )
+        resolved_name = queue_name or item_data.get("Name")
+        if resolved_name is None:
+            raise ValueError(
+                "queue_name must be provided either via the queue_name parameter or item.name"
+            )
+        item_data["Name"] = resolved_name
+
+        json_payload = {"itemData": item_data}
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem"
+            ),
+            json=json_payload,
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _create_items_spec(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.BulkAddQueueItems"
+            ),
+            json={
+                "queueName": queue_name,
+                "commitType": commit_type.value,
+                "queueItems": [
+                    item.model_dump(mode="json", exclude_unset=True, by_alias=True)
+                    if isinstance(item, QueueItem)
+                    else QueueItem(**item).model_dump(
+                        mode="json", exclude_unset=True, by_alias=True
+                    )
+                    for item in items
+                ],
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _create_transaction_item_spec(
+        self,
+        item: Union[Dict[str, Any], TransactionItem],
+        *,
+        queue_name: Optional[str] = None,
+        no_robot: bool = False,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        if isinstance(item, dict):
+            transaction_item = TransactionItem(**item)
+        elif isinstance(item, TransactionItem):
+            transaction_item = item
+
+        transaction_data = transaction_item.model_dump(
+            mode="json", exclude_unset=True, by_alias=True
+        )
+        resolved_name = queue_name or transaction_data.get("Name")
+        if resolved_name is None:
+            raise ValueError(
+                "queue_name must be provided either via the queue_name parameter or item.name"
+            )
+        transaction_data["Name"] = resolved_name
+        if not no_robot:
+            transaction_data["RobotIdentifier"] = self._execution_context.robot_key
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.StartTransaction"
+            ),
+            json={"transactionData": transaction_data},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _update_progress_of_transaction_item_spec(
+        self,
+        transaction_key: str,
+        progress: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/QueueItems({transaction_key})/UiPathODataSvc.SetTransactionProgress"
+            ),
+            json={"progress": progress},
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _complete_transaction_item_spec(
+        self,
+        transaction_key: str,
+        result: Union[Dict[str, Any], TransactionItemResult],
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        if isinstance(result, dict):
+            transaction_result = TransactionItemResult(**result)
+        elif isinstance(result, TransactionItemResult):
+            transaction_result = result
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Queues({transaction_key})/UiPathODataSvc.SetTransactionResult"
+            ),
+            json={
+                "transactionResult": transaction_result.model_dump(
+                    mode="json", exclude_unset=True, by_alias=True
+                )
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/_server_version.py b/packages/uipath-platform/src/uipath/platform/orchestrator/_server_version.py
new file mode 100644
index 000000000..4cd4f97d9
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/_server_version.py
@@ -0,0 +1,75 @@
+"""Utility for retrieving the Orchestrator server version."""
+
+from typing import Any
+
+import httpx
+
+from ..common._http_config import get_httpx_client_kwargs
+
+
+def get_server_version(domain: str) -> str | None:
+    """Get the Orchestrator server version.
+
+    Args:
+        domain: The base URL of the UiPath platform (e.g., "https://cloud.uipath.com").
+
+    Returns:
+        The server version string, or None if the request fails for any reason.
+    """
+    url = f"{domain}/orchestrator_/api/status/version"
+
+    try:
+        client_kwargs = get_httpx_client_kwargs()
+        client_kwargs["timeout"] = 5.0
+        with httpx.Client(**client_kwargs) as client:
+            response = client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("version")
+    except Exception:
+        return None
+
+
+async def get_server_info_async(domain: str) -> dict[Any, Any] | None:
+    """Get the full Orchestrator server status info.
+
+    Args:
+        domain: The base URL of the UiPath platform (e.g., "https://cloud.uipath.com").
+
+    Returns:
+        The full server status JSON as a dict, or None if the request fails for any reason.
+    """
+    url = f"{domain}/orchestrator_/api/status/version"
+
+    try:
+        client_kwargs = get_httpx_client_kwargs()
+        client_kwargs["timeout"] = 5.0
+        async with httpx.AsyncClient(**client_kwargs) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.json()
+    except Exception:
+        return None
+
+
+async def get_server_version_async(domain: str) -> str | None:
+    """Get the Orchestrator server version.
+
+    Args:
+        domain: The base URL of the UiPath platform (e.g., "https://cloud.uipath.com").
+
+    Returns:
+        The server version string, or None if the request fails for any reason.
+    """
+    url = f"{domain}/orchestrator_/api/status/version"
+
+    try:
+        client_kwargs = get_httpx_client_kwargs()
+        client_kwargs["timeout"] = 5.0
+        async with httpx.AsyncClient(**client_kwargs) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("version")
+    except Exception:
+        return None
diff --git a/src/uipath/models/assets.py b/packages/uipath-platform/src/uipath/platform/orchestrator/assets.py
similarity index 79%
rename from src/uipath/models/assets.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/assets.py
index 9974db31a..122821029 100644
--- a/src/uipath/models/assets.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/assets.py
@@ -1,34 +1,35 @@
-from datetime import datetime
+"""Models for UiPath Orchestrator Assets."""
+
 from typing import Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 
 class CredentialsConnectionData(BaseModel):
+    """Model representing connection data for credentials."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
-
-    url: str
-    body: str
-    bearer_token: str = Field(alias="bearerToken")
+    url: str = Field(alias="Url")
+    body: str = Field(alias="Body")
+    bearer_token: str = Field(alias="BearerToken")
 
 
 class UserAsset(BaseModel):
+    """Model representing a user asset."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
-
     name: Optional[str] = Field(default=None, alias="Name")
     value: Optional[str] = Field(default=None, alias="Value")
     value_type: Optional[str] = Field(default=None, alias="ValueType")
@@ -37,6 +38,7 @@ class UserAsset(BaseModel):
     int_value: Optional[int] = Field(default=None, alias="IntValue")
     credential_username: Optional[str] = Field(default=None, alias="CredentialUsername")
     credential_password: Optional[str] = Field(default=None, alias="CredentialPassword")
+    secret_value: Optional[str] = Field(default=None, alias="SecretValue")
     external_name: Optional[str] = Field(default=None, alias="ExternalName")
     credential_store_id: Optional[int] = Field(default=None, alias="CredentialStoreId")
     key_value_list: Optional[List[Dict[str, str]]] = Field(
@@ -45,10 +47,15 @@ class UserAsset(BaseModel):
     connection_data: Optional[CredentialsConnectionData] = Field(
         default=None, alias="ConnectionData"
     )
+    allow_direct_api_access: Optional[bool] = Field(
+        default=None, alias="AllowDirectApiAccess"
+    )
     id: Optional[int] = Field(default=None, alias="Id")
 
 
 class Asset(BaseModel):
+    """Model representing an orchestrator asset."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
@@ -66,5 +73,9 @@ class Asset(BaseModel):
     int_value: Optional[int] = Field(default=None, alias="IntValue")
     credential_username: Optional[str] = Field(default=None, alias="CredentialUsername")
     credential_password: Optional[str] = Field(default=None, alias="CredentialPassword")
+    secret_value: Optional[str] = Field(default=None, alias="SecretValue")
     external_name: Optional[str] = Field(default=None, alias="ExternalName")
     credential_store_id: Optional[int] = Field(default=None, alias="CredentialStoreId")
+    allow_direct_api_access: Optional[bool] = Field(
+        default=None, alias="AllowDirectApiAccess"
+    )
diff --git a/src/uipath/models/attachment.py b/packages/uipath-platform/src/uipath/platform/orchestrator/attachment.py
similarity index 61%
rename from src/uipath/models/attachment.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/attachment.py
index 1802071b5..3091b72c6 100644
--- a/src/uipath/models/attachment.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/attachment.py
@@ -1,8 +1,10 @@
+"""Module defining the Attachment model for UiPath Orchestrator."""
+
 import uuid
 from datetime import datetime
 from typing import Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
 
 class Attachment(BaseModel):
@@ -17,9 +19,15 @@ class Attachment(BaseModel):
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
+    @field_serializer("creation_time", "last_modification_time", when_used="json")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format for JSON output."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
     name: str = Field(alias="Name")
     creation_time: Optional[datetime] = Field(default=None, alias="CreationTime")
     last_modification_time: Optional[datetime] = Field(
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/buckets.py b/packages/uipath-platform/src/uipath/platform/orchestrator/buckets.py
new file mode 100644
index 000000000..d5b552386
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/buckets.py
@@ -0,0 +1,80 @@
+"""Models for Orchestrator Buckets API responses."""
+
+from typing import Any, List, Optional
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+
+class BucketFile(BaseModel):
+    """Represents a file within a bucket.
+
+    Supports both ListFiles API (lowercase fields) and GetFiles API (PascalCase fields).
+    """
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_by_alias=True,
+        extra="allow",
+    )
+
+    full_path: str = Field(
+        validation_alias=AliasChoices("fullPath", "FullPath"),
+        description="Full path within bucket",
+    )
+    content_type: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("contentType", "ContentType"),
+        description="MIME type",
+    )
+    size: int = Field(
+        validation_alias=AliasChoices("size", "Size"),
+        description="File size in bytes",
+    )
+    last_modified: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("lastModified", "LastModified"),
+        description="Last modification timestamp (ISO format)",
+    )
+    is_directory: bool = Field(
+        default=False,
+        validation_alias=AliasChoices("IsDirectory", "isDirectory"),
+        description="Whether this entry is a directory",
+    )
+
+    @property
+    def path(self) -> str:
+        """Alias for full_path for consistency."""
+        return self.full_path
+
+    @property
+    def name(self) -> str:
+        """Extract filename from full path."""
+        return (
+            self.full_path.split("/")[-1] if "/" in self.full_path else self.full_path
+        )
+
+
+class Bucket(BaseModel):
+    """Represents a bucket in Orchestrator."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    name: str = Field(alias="Name")
+    description: Optional[str] = Field(default=None, alias="Description")
+    identifier: str = Field(alias="Identifier")
+    storage_provider: Optional[str] = Field(default=None, alias="StorageProvider")
+    storage_parameters: Optional[str] = Field(default=None, alias="StorageParameters")
+    storage_container: Optional[str] = Field(default=None, alias="StorageContainer")
+    options: Optional[str] = Field(default=None, alias="Options")
+    credential_store_id: Optional[str] = Field(default=None, alias="CredentialStoreId")
+    external_name: Optional[str] = Field(default=None, alias="ExternalName")
+    password: Optional[str] = Field(default=None, alias="Password")
+    folders_count: Optional[int] = Field(default=None, alias="FoldersCount")
+    encrypted: Optional[bool] = Field(default=None, alias="Encrypted")
+    id: Optional[int] = Field(default=None, alias="Id")
+    tags: Optional[List[Any]] = Field(default=None, alias="Tags")
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/folder.py b/packages/uipath-platform/src/uipath/platform/orchestrator/folder.py
new file mode 100644
index 000000000..8d9a91c9e
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/folder.py
@@ -0,0 +1,15 @@
+"""Models for Orchestrator Folders API responses."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PersonalWorkspace(BaseModel):
+    """Represents a user's personal workspace folder."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
+
+    fully_qualified_name: str = Field(alias="FullyQualifiedName")
+    key: str = Field(alias="Key")
+    id: int = Field(alias="Id")
diff --git a/src/uipath/models/job.py b/packages/uipath-platform/src/uipath/platform/orchestrator/job.py
similarity index 80%
rename from src/uipath/models/job.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/job.py
index 8ab9b5363..6464405b4 100644
--- a/src/uipath/models/job.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/job.py
@@ -1,39 +1,53 @@
-from datetime import datetime
+"""Models for Orchestrator Jobs."""
+
+from enum import Enum
 from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 
+class JobState(str, Enum):
+    """Job state enum."""
+
+    SUCCESSFUL = "successful"
+    FAULTED = "faulted"
+    SUSPENDED = "suspended"
+    RUNNING = "running"
+    PENDING = "pending"
+    RESUMED = "resumed"
+
+
 class JobErrorInfo(BaseModel):
+    """Model representing job error information."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
-
     code: Optional[str] = Field(default=None, alias="Code")
     title: Optional[str] = Field(default=None, alias="Title")
     detail: Optional[str] = Field(default=None, alias="Detail")
     category: Optional[str] = Field(default=None, alias="Category")
-    status: Optional[str] = Field(default=None, alias="Status")
+    status: Optional[int] = Field(default=None, alias="Status")
 
 
 class Job(BaseModel):
+    """Model representing an orchestrator job."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
-
     key: Optional[str] = Field(default=None, alias="Key")
     start_time: Optional[str] = Field(default=None, alias="StartTime")
     end_time: Optional[str] = Field(default=None, alias="EndTime")
+    # 2.3.0 change to JobState enum
     state: Optional[str] = Field(default=None, alias="State")
     job_priority: Optional[str] = Field(default=None, alias="JobPriority")
     specific_priority_value: Optional[int] = Field(
@@ -58,9 +72,12 @@ class Job(BaseModel):
     deleter_user_id: Optional[int] = Field(default=None, alias="DeleterUserId")
     is_deleted: Optional[bool] = Field(default=None, alias="IsDeleted")
     input_arguments: Optional[str] = Field(default=None, alias="InputArguments")
+    input_file: Optional[str] = Field(default=None, alias="InputFile")
     output_arguments: Optional[str] = Field(default=None, alias="OutputArguments")
+    output_file: Optional[str] = Field(default=None, alias="OutputFile")
     host_machine_name: Optional[str] = Field(default=None, alias="HostMachineName")
     has_errors: Optional[bool] = Field(default=None, alias="HasErrors")
     has_warnings: Optional[bool] = Field(default=None, alias="HasWarnings")
     job_error: Optional[JobErrorInfo] = Field(default=None, alias="JobError")
+    folder_key: Optional[str] = Field(default=None, alias="FolderKey")
     id: int = Field(alias="Id")
diff --git a/packages/uipath-platform/src/uipath/platform/orchestrator/mcp.py b/packages/uipath-platform/src/uipath/platform/orchestrator/mcp.py
new file mode 100644
index 000000000..dd96353a0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/mcp.py
@@ -0,0 +1,57 @@
+"""Models for MCP Servers in UiPath Orchestrator."""
+
+from datetime import datetime
+from enum import IntEnum
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class McpServerType(IntEnum):
+    """Enumeration of MCP server types."""
+
+    UiPath = 0  # Processes, Agents, Activities
+    Command = 1  # npx, uvx
+    Coded = 2  # PackageType.McpServer
+    SelfHosted = 3  # tunnel to (externally) self-hosted server
+    Remote = 4  # HTTP connection to remote MCP server
+    ProcessAssistant = 5  # Dynamic user process assistant
+    Platform = 6  # Platform MCP server (e.g: Orchestrator, TestManager)
+
+
+class McpServerStatus(IntEnum):
+    """Enumeration of MCP server statuses."""
+
+    Disconnected = 0
+    Connected = 1
+
+
+class McpServer(BaseModel):
+    """Model representing an MCP server in UiPath Orchestrator."""
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    slug: Optional[str] = None
+    description: Optional[str] = None
+    version: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    is_active: Optional[bool] = None
+    type: Optional[McpServerType] = None
+    status: Optional[McpServerStatus] = None
+    command: Optional[str] = None
+    arguments: Optional[str] = None
+    environment_variables: Optional[str] = None
+    process_key: Optional[str] = None
+    folder_key: Optional[str] = None
+    runtimes_count: Optional[int] = None
+    mcp_url: Optional[str] = None
diff --git a/src/uipath/models/processes.py b/packages/uipath-platform/src/uipath/platform/orchestrator/processes.py
similarity index 94%
rename from src/uipath/models/processes.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/processes.py
index fceea270b..90c9d2799 100644
--- a/src/uipath/models/processes.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/processes.py
@@ -1,19 +1,20 @@
-from datetime import datetime
+"""Models for Orchestrator Processes."""
+
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 
 class Process(BaseModel):
+    """Model representing an orchestrator process."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
-
     key: str = Field(alias="Key")
     process_key: str = Field(alias="ProcessKey")
     process_version: str = Field(alias="ProcessVersion")
diff --git a/src/uipath/models/queues.py b/packages/uipath-platform/src/uipath/platform/orchestrator/queues.py
similarity index 64%
rename from src/uipath/models/queues.py
rename to packages/uipath-platform/src/uipath/platform/orchestrator/queues.py
index 15e4e9252..94cc9a6a6 100644
--- a/src/uipath/models/queues.py
+++ b/packages/uipath-platform/src/uipath/platform/orchestrator/queues.py
@@ -1,37 +1,66 @@
+"""Models for Orchestrator Queues API."""
+
+import warnings
 from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_validator
 from typing_extensions import Annotated
 
 
 class QueueItemPriority(Enum):
+    """Enumeration for Queue Item Priority levels."""
+
     LOW = "Low"
-    MEDIUM = "Medium"
+    NORMAL = "Normal"
     HIGH = "High"
 
 
 class CommitType(Enum):
+    """Enumeration for Commit Types in batch processing."""
+
     ALL_OR_NOTHING = "AllOrNothing"
     STOP_ON_FIRST_FAILURE = "StopOnFirstFailure"
     PROCESS_ALL_INDEPENDENTLY = "ProcessAllIndependently"
 
 
 class QueueItem(BaseModel):
+    """Model representing an item in an Orchestrator queue."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
-    name: str = Field(
-        description="The name of the queue into which the item will be added.",
+    @field_serializer("defer_date", "due_date", "risk_sla_date", when_used="json")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format for JSON output."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
+    name: Optional[str] = Field(
+        default=None,
+        description="Deprecated: use queue_name on the service method instead. The name of the queue into which the item will be added.",
         alias="Name",
     )
+
+    @model_validator(mode="before")
+    @classmethod
+    def warn_name_deprecated(cls, values: Any) -> Any:
+        """Emit a deprecation warning when the 'name' field is used directly."""
+        if isinstance(values, dict) and ("name" in values or "Name" in values):
+            warnings.warn(
+                "The 'name' field on QueueItem is deprecated. Pass queue_name to the service method instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return values
+
     priority: Optional[QueueItemPriority] = Field(
         default=None,
         description="Sets the processing importance for a given item.",
@@ -72,22 +101,51 @@ class QueueItem(BaseModel):
         description="Operation id which started the job.",
         alias="ParentOperationId",
     )
+    reference: Optional[
+        Annotated[str, Field(min_length=0, strict=True, max_length=128)]
+    ] = Field(
+        default=None,
+        description="An optional, user-specified value for queue item identification.",
+        alias="Reference",
+    )
 
 
 class TransactionItem(BaseModel):
+    """Model representing a transaction item in an Orchestrator queue."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
-    name: str = Field(
-        description="The name of the queue in which to search for the next item or in which to insert the item before marking it as InProgress and sending it to the robot.",
+    @field_serializer("defer_date", "due_date", when_used="json")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format for JSON output."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
+    name: Optional[str] = Field(
+        default=None,
+        description="Deprecated: use queue_name on the service method instead. The name of the queue in which to search for the next item or in which to insert the item before marking it as InProgress and sending it to the robot.",
         alias="Name",
     )
+
+    @model_validator(mode="before")
+    @classmethod
+    def warn_name_deprecated(cls, values: Any) -> Any:
+        """Emit a deprecation warning when the 'name' field is used directly."""
+        if isinstance(values, dict) and ("name" in values or "Name" in values):
+            warnings.warn(
+                "The 'name' field on TransactionItem is deprecated. Pass queue_name to the service method instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return values
+
     robot_identifier: Optional[str] = Field(
         default=None,
         description="The unique key identifying the robot that sent the request.",
@@ -118,15 +176,23 @@ class TransactionItem(BaseModel):
 
 
 class TransactionItemResult(BaseModel):
+    """Model representing the result of processing a transaction item in an Orchestrator queue."""
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
     )
 
+    @field_serializer("defer_date", "due_date", when_used="json")
+    def serialize_datetime(self, value):
+        """Serialize datetime fields to ISO 8601 format for JSON output."""
+        if isinstance(value, datetime):
+            return value.isoformat() if value else None
+        return value
+
     is_successful: Optional[bool] = Field(
         default=None,
         description="States if the processing was successful or not.",
diff --git a/packages/uipath-platform/src/uipath/platform/pii_detection/__init__.py b/packages/uipath-platform/src/uipath/platform/pii_detection/__init__.py
new file mode 100644
index 000000000..7ab3b9e26
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/pii_detection/__init__.py
@@ -0,0 +1,36 @@
+"""PiiDetection service package.
+
+Provides the ``PiiDetectionService`` client, Pydantic request/response models for
+the PII detection endpoint, and utilities for rehydrating masked text with
+original PII values after LLM processing.
+"""
+
+from ._pii_detection_service import PiiDetectionService
+from .pii_detection import (
+    PiiDetectionRequest,
+    PiiDetectionResponse,
+    PiiDocument,
+    PiiDocumentResult,
+    PiiEntity,
+    PiiEntityThreshold,
+    PiiFile,
+    PiiFileResult,
+)
+from .pii_utilities import (
+    rehydrate_from_pii_entities,
+    rehydrate_from_pii_response,
+)
+
+__all__ = [
+    "PiiDetectionRequest",
+    "PiiDetectionResponse",
+    "PiiDetectionService",
+    "PiiDocument",
+    "PiiDocumentResult",
+    "PiiEntity",
+    "PiiEntityThreshold",
+    "PiiFile",
+    "PiiFileResult",
+    "rehydrate_from_pii_entities",
+    "rehydrate_from_pii_response",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/pii_detection/_pii_detection_service.py b/packages/uipath-platform/src/uipath/platform/pii_detection/_pii_detection_service.py
new file mode 100644
index 000000000..a39ed4196
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/pii_detection/_pii_detection_service.py
@@ -0,0 +1,80 @@
+"""PiiDetection service for UiPath Platform.
+
+Provides methods for detecting PII in documents and files.
+"""
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from .pii_detection import PiiDetectionRequest, PiiDetectionResponse
+
+_PII_DETECTION_ENDPOINT = Endpoint("llmopstenant_/api/pii-detection")
+
+# PII detection over documents/files can be slow, so override the default
+# httpx client timeout (30s) with a longer per-request timeout.
+_PII_DETECTION_TIMEOUT = 290.0
+
+
+class PiiDetectionService(BaseService):
+    """Service for detecting PII via UiPath."""
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="pii_detection_detect_pii", run_type="uipath")
+    def detect_pii(self, request: PiiDetectionRequest) -> PiiDetectionResponse:
+        """Detect PII in the provided documents and/or files.
+
+        Args:
+            request: The PII detection request payload.
+
+        Returns:
+            The PII detection response.
+        """
+        spec = self._pii_detection_spec(request)
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="tenant",
+            timeout=_PII_DETECTION_TIMEOUT,
+        )
+        return PiiDetectionResponse.model_validate(response.json())
+
+    @traced(name="pii_detection_detect_pii", run_type="uipath")
+    async def detect_pii_async(
+        self, request: PiiDetectionRequest
+    ) -> PiiDetectionResponse:
+        """Detect PII in the provided documents and/or files (async).
+
+        Args:
+            request: The PII detection request payload.
+
+        Returns:
+            The PII detection response.
+        """
+        spec = self._pii_detection_spec(request)
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="tenant",
+            timeout=_PII_DETECTION_TIMEOUT,
+        )
+        return PiiDetectionResponse.model_validate(response.json())
+
+    def _pii_detection_spec(self, request: PiiDetectionRequest) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=_PII_DETECTION_ENDPOINT,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/pii_detection/pii_detection.py b/packages/uipath-platform/src/uipath/platform/pii_detection/pii_detection.py
new file mode 100644
index 000000000..94ac10fca
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/pii_detection/pii_detection.py
@@ -0,0 +1,91 @@
+"""Public Pydantic models for the PiiDetection service."""
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PiiDocument(BaseModel):
+    """A text document to scan for PII."""
+
+    id: str
+    role: str
+    document: str
+
+
+class PiiFile(BaseModel):
+    """A file reference to scan for PII."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    file_name: str = Field(alias="fileName")
+    file_url: str = Field(alias="fileUrl")
+    file_type: str = Field(alias="fileType")
+
+
+class PiiEntityThreshold(BaseModel):
+    """Per-entity confidence threshold override."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    category: str = Field(alias="pii-entity-category")
+    confidence_threshold: float = Field(alias="pii-entity-confidence-threshold")
+
+
+class PiiDetectionRequest(BaseModel):
+    """Request payload for the PII detection endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    documents: Optional[list[PiiDocument]] = None
+    files: Optional[list[PiiFile]] = None
+    language_code: Optional[str] = Field(default=None, alias="languageCode")
+    confidence_threshold: Optional[float] = Field(
+        default=None, alias="confidenceThreshold"
+    )
+    entity_thresholds: Optional[list[PiiEntityThreshold]] = Field(
+        default=None, alias="entityThresholds"
+    )
+
+
+class PiiEntity(BaseModel):
+    """A single detected PII entity."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    pii_text: str = Field(alias="piiText")
+    replacement_text: str = Field(alias="replacementText")
+    pii_type: str = Field(alias="piiType")
+    offset: int
+    confidence_score: float = Field(alias="confidenceScore")
+
+
+class PiiDocumentResult(BaseModel):
+    """PII detection result for a single document."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    role: str
+    masked_document: str = Field(alias="maskedDocument")
+    initial_document: str = Field(alias="initialDocument")
+    pii_entities: list[PiiEntity] = Field(default_factory=list, alias="piiEntities")
+
+
+class PiiFileResult(BaseModel):
+    """PII detection result for a single file (fileUrl is the redacted URL)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    file_name: str = Field(alias="fileName")
+    file_url: str = Field(alias="fileUrl")
+    pii_entities: list[PiiEntity] = Field(default_factory=list, alias="piiEntities")
+
+
+class PiiDetectionResponse(BaseModel):
+    """Response payload from the PII detection endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    response: list[PiiDocumentResult] = Field(default_factory=list)
+    files: list[PiiFileResult] = Field(default_factory=list)
diff --git a/packages/uipath-platform/src/uipath/platform/pii_detection/pii_utilities.py b/packages/uipath-platform/src/uipath/platform/pii_detection/pii_utilities.py
new file mode 100644
index 000000000..b2fa482d0
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/pii_detection/pii_utilities.py
@@ -0,0 +1,98 @@
+"""Utility methods for working with PII data.
+
+Python port of UiPath.SemanticProxy.Client.PiiUtilities (C#).
+"""
+
+import re
+from typing import Callable, Iterable
+
+from .pii_detection import PiiDetectionResponse, PiiEntity
+
+
+def rehydrate_from_pii_entities(
+    masked_text: str, pii_entities: Iterable[PiiEntity]
+) -> str:
+    """Rehydrate masked text by replacing PII placeholders with original values.
+
+    Placeholders (e.g. ``[Person-1]``) are matched case-insensitively and replaced
+    with the corresponding original PII text. The function also replaces variants
+    without the surrounding brackets (e.g. ``Person-1``) in case the LLM stripped
+    them in its output.
+
+    Args:
+        masked_text: The masked text with PII placeholders.
+        pii_entities: The PII entities containing the original values.
+
+    Returns:
+        The rehydrated text with original PII values.
+    """
+    if not masked_text:
+        return masked_text
+
+    entities = [e for e in pii_entities if e.replacement_text]
+    if not entities:
+        return masked_text
+
+    # Sort by replacement text length descending to avoid substring collisions
+    # (e.g. "[Person-10]" must be replaced before "[Person-1]").
+    entities.sort(key=lambda e: len(e.replacement_text), reverse=True)
+
+    rehydrated = masked_text
+    for entity in entities:
+        if not entity.replacement_text or not entity.pii_text:
+            continue
+        # Replace the full placeholder (with brackets) case-insensitively.
+        # ``_literal_replacer`` bypasses regex backreference interpretation in the
+        # replacement string.
+        rehydrated = re.sub(
+            re.escape(entity.replacement_text),
+            _literal_replacer(entity.pii_text),
+            rehydrated,
+            flags=re.IGNORECASE,
+        )
+        # Also replace the content without brackets (in case the LLM dropped them).
+        if entity.replacement_text.startswith("[") and entity.replacement_text.endswith(
+            "]"
+        ):
+            no_brackets = entity.replacement_text[1:-1]
+            rehydrated = re.sub(
+                re.escape(no_brackets),
+                _literal_replacer(entity.pii_text),
+                rehydrated,
+                flags=re.IGNORECASE,
+            )
+
+    return rehydrated
+
+
+def _literal_replacer(replacement: str) -> Callable[[re.Match[str]], str]:
+    """Return a replacement function that ignores regex backreference syntax."""
+
+    def replace(_match: re.Match[str]) -> str:
+        return replacement
+
+    return replace
+
+
+def rehydrate_from_pii_response(
+    masked_text: str, response: PiiDetectionResponse
+) -> str:
+    """Rehydrate masked text using all PII entities from a detection response.
+
+    Merges entities from both ``response.response`` (detected in documents/prompts)
+    and ``response.files`` (detected in files), so placeholders originating from
+    either source are rehydrated.
+
+    Args:
+        masked_text: The masked text with PII placeholders.
+        response: The PII detection response containing entities to rehydrate.
+
+    Returns:
+        The rehydrated text with original PII values.
+    """
+    entities: list[PiiEntity] = []
+    for doc in response.response:
+        entities.extend(doc.pii_entities)
+    for file in response.files:
+        entities.extend(file.pii_entities)
+    return rehydrate_from_pii_entities(masked_text, entities)
diff --git a/packages/uipath-platform/src/uipath/platform/portal/__init__.py b/packages/uipath-platform/src/uipath/platform/portal/__init__.py
new file mode 100644
index 000000000..8d208627d
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/portal/__init__.py
@@ -0,0 +1,11 @@
+"""UiPath Portal Service."""
+
+from ._portal_service import PortalService
+from .portal import OrganizationInfo, TenantInfo, TenantsAndOrganizationInfoResponse
+
+__all__ = [
+    "PortalService",
+    "TenantInfo",
+    "OrganizationInfo",
+    "TenantsAndOrganizationInfoResponse",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/portal/_portal_service.py b/packages/uipath-platform/src/uipath/platform/portal/_portal_service.py
new file mode 100644
index 000000000..268a3b697
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/portal/_portal_service.py
@@ -0,0 +1,79 @@
+"""Portal service for UiPath Platform."""
+
+import httpx
+
+from ..common._http_config import get_httpx_client_kwargs
+from .portal import TenantsAndOrganizationInfoResponse
+
+
+class PortalService:
+    """Service for interacting with the UiPath Portal API.
+
+    This service does not extend BaseService because it may be used before a full
+    execution context is established — e.g., to resolve the current tenant and
+    organization based on a user token, which is a prerequisite for building the
+    base URL that other services depend on.
+
+    The access_token is passed per call rather than stored on the instance because
+    it may change over its lifetime (e.g., after a token refresh).
+    """
+
+    def __init__(self, domain: str):
+        """Initialize the PortalService.
+
+        Args:
+            domain: The base URL of the UiPath platform (e.g., "https://cloud.uipath.com").
+        """
+        self._domain = domain
+
+    def get_tenants_and_organizations(
+        self,
+        prt_id: str,
+        access_token: str,
+    ) -> TenantsAndOrganizationInfoResponse:
+        """Retrieve tenants and organization info for the given organization.
+
+        Args:
+            prt_id: The organization/partition ID used in the URL path.
+            access_token: The Bearer access token for authorization.
+
+        Returns:
+            TenantsAndOrganizationInfoResponse containing tenants and organization info.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        url = f"{self._domain}/{prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+        headers = {"Authorization": f"Bearer {access_token}"}
+
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
+            response = client.get(url, headers=headers)
+            response.raise_for_status()
+            return TenantsAndOrganizationInfoResponse.model_validate(response.json())
+
+    async def get_tenants_and_organizations_async(
+        self,
+        prt_id: str,
+        access_token: str,
+    ) -> TenantsAndOrganizationInfoResponse:
+        """Retrieve tenants and organization info for the given organization.
+
+        Args:
+            prt_id: The organization/partition ID used in the URL path.
+            access_token: The Bearer access token for authorization.
+
+        Returns:
+            TenantsAndOrganizationInfoResponse containing tenants and organization info.
+
+        Raises:
+            httpx.HTTPStatusError: If the server returns a non-2xx response.
+            httpx.ConnectError: If there is a network connectivity issue.
+        """
+        url = f"{self._domain}/{prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+        headers = {"Authorization": f"Bearer {access_token}"}
+
+        async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            return TenantsAndOrganizationInfoResponse.model_validate(response.json())
diff --git a/packages/uipath-platform/src/uipath/platform/portal/portal.py b/packages/uipath-platform/src/uipath/platform/portal/portal.py
new file mode 100644
index 000000000..1bb4da000
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/portal/portal.py
@@ -0,0 +1,24 @@
+"""Models for UiPath Portal service."""
+
+from pydantic import BaseModel
+
+
+class TenantInfo(BaseModel):
+    """Model representing a tenant."""
+
+    name: str
+    id: str
+
+
+class OrganizationInfo(BaseModel):
+    """Model representing an organization."""
+
+    id: str
+    name: str
+
+
+class TenantsAndOrganizationInfoResponse(BaseModel):
+    """Model representing the tenants and organization info response."""
+
+    tenants: list[TenantInfo]
+    organization: OrganizationInfo
diff --git a/packages/uipath-platform/src/uipath/platform/py.typed b/packages/uipath-platform/src/uipath/platform/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath-platform/src/uipath/platform/resource_catalog/__init__.py b/packages/uipath-platform/src/uipath/platform/resource_catalog/__init__.py
new file mode 100644
index 000000000..227db5439
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resource_catalog/__init__.py
@@ -0,0 +1,15 @@
+"""UiPath Resource Catalog Models.
+
+This module contains models related to UiPath Resource Catalog service.
+"""
+
+from ._resource_catalog_service import ResourceCatalogService
+from .resource_catalog import Folder, Resource, ResourceType, Tag
+
+__all__ = [
+    "ResourceCatalogService",
+    "Folder",
+    "Resource",
+    "ResourceType",
+    "Tag",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/resource_catalog/_resource_catalog_service.py b/packages/uipath-platform/src/uipath/platform/resource_catalog/_resource_catalog_service.py
new file mode 100644
index 000000000..e42880e71
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resource_catalog/_resource_catalog_service.py
@@ -0,0 +1,634 @@
+from typing import Any, AsyncGenerator, Dict, Iterator, List, Optional
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._folder_context import FolderContext, header_folder
+from ..common._models import Endpoint, RequestSpec
+from ..orchestrator._folder_service import FolderService
+from .resource_catalog import Resource, ResourceType
+
+
+class ResourceCatalogService(FolderContext, BaseService):
+    """Service for searching and discovering UiPath resources across folders.
+
+    The Resource Catalog Service provides a centralized way to search and retrieve
+    UiPath resources (assets, queues, processes, storage buckets, etc.) across
+    tenant and folder scopes. It enables programmatic discovery of resources with
+    flexible filtering by resource type, name, and folder location.
+
+    See Also:
+        https://docs.uipath.com/orchestrator/standalone/2024.10/user-guide/about-resource-catalog-service
+
+    !!! info "Version Availability"
+        This service is available starting from **uipath** version **2.1.168**.
+    """
+
+    _DEFAULT_PAGE_SIZE = 20
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        folder_service: FolderService,
+    ) -> None:
+        self.folder_service = folder_service
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="resource_catalog_search", run_type="uipath")
+    def search(
+        self,
+        *,
+        name: Optional[str] = None,
+        resource_types: Optional[List[ResourceType]] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> Iterator[Resource]:
+        """Search for tenant scoped resources and folder scoped resources (accessible to the user).
+
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            name: Optional name filter for resources
+            resource_types: Optional list of resource types to filter by
+            resource_sub_types: Optional list of resource subtypes to filter by
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the search criteria
+
+        Examples:
+            >>> # Search for all resources with "invoice" in the name
+            >>> for resource in uipath.resource_catalog.search(name="invoice"):
+            ...     print(f"{resource.name}: {resource.resource_type}")
+
+            >>> # Search for specific resource types
+            >>> for resource in uipath.resource_catalog.search(
+            ...     resource_types=[ResourceType.ASSET]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        while True:
+            spec = self._search_spec(
+                name=name,
+                resource_types=resource_types,
+                resource_sub_types=resource_sub_types,
+                skip=skip,
+                take=take,
+            )
+
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    @traced(name="resource_catalog_search", run_type="uipath")
+    async def search_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        resource_types: Optional[List[ResourceType]] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> AsyncGenerator[Resource, None]:
+        """Asynchronously search for tenant scoped resources and folder scoped resources (accessible to the user).
+
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            name: Optional name filter for resources
+            resource_types: Optional list of resource types to filter by
+            resource_sub_types: Optional list of resource subtypes to filter by
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the search criteria
+
+        Examples:
+            >>> # Search for all resources with "invoice" in the name
+            >>> async for resource in uipath.resource_catalog.search_async(name="invoice"):
+            ...     print(f"{resource.name}: {resource.resource_type}")
+
+            >>> # Search for specific resource types
+            >>> async for resource in uipath.resource_catalog.search_async(
+            ...     resource_types=[ResourceType.ASSET]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        while True:
+            spec = self._search_spec(
+                name=name,
+                resource_types=resource_types,
+                resource_sub_types=resource_sub_types,
+                skip=skip,
+                take=take,
+            )
+
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                )
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    @traced(name="resource_catalog_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        resource_types: Optional[List[ResourceType]] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> Iterator[Resource]:
+        """Get tenant scoped resources and folder scoped resources (accessible to the user).
+
+        If no folder identifier is provided (path or key) only tenant resources will be retrieved.
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            resource_types: Optional list of resource types to filter by
+            resource_sub_types: Optional list of resource subtypes to filter by
+            folder_path: Optional folder path to scope the results
+            folder_key: Optional folder key to scope the results
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the criteria
+
+        Examples:
+            >>> # Get all resources
+            >>> for resource in uipath.resource_catalog.list():
+            ...     print(f"{resource.name}: {resource.resource_type}")
+
+            >>> # Get specific resource types
+            >>> assets = list(uipath.resource_catalog.list(
+            ...     resource_types=[ResourceType.ASSET],
+            ... ))
+
+            >>> # Get resources within a specific folder
+            >>> for resource in uipath.resource_catalog.list(
+            ...     folder_path="/Shared/Finance",
+            ...     resource_types=[ResourceType.ASSET],
+            ...     resource_sub_types=["number"]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        if take <= 0:
+            raise ValueError(f"page_size must be greater than 0. Got {page_size}")
+
+        resolved_folder_key = self.folder_service.retrieve_folder_key(folder_path)
+
+        while True:
+            spec = self._list_spec(
+                resource_types=resource_types,
+                resource_sub_types=resource_sub_types,
+                folder_key=resolved_folder_key,
+                skip=skip,
+                take=take,
+            )
+
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    @traced(name="resource_catalog_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        resource_types: Optional[List[ResourceType]] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> AsyncGenerator[Resource, None]:
+        """Asynchronously get tenant scoped resources and folder scoped resources (accessible to the user).
+
+        If no folder identifier is provided (path or key) only tenant resources will be retrieved.
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            resource_types: Optional list of resource types to filter by
+            resource_sub_types: Optional list of resource subtypes to filter by
+            folder_path: Optional folder path to scope the results
+            folder_key: Optional folder key to scope the results
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the criteria
+
+        Examples:
+            >>> # Get all resources
+            >>> async for resource in uipath.resource_catalog.list_async():
+            ...     print(f"{resource.name}: {resource.resource_type}")
+
+            >>> # Get specific resource types
+            >>> assets = []
+            >>> async for resource in uipath.resource_catalog.list_async(
+            ...     resource_types=[ResourceType.ASSET],
+            ... ):
+            ...     assets.append(resource)
+
+            >>> # Get resources within a specific folder
+            >>> async for resource in uipath.resource_catalog.list_async(
+            ...     folder_path="/Shared/Finance",
+            ...     resource_types=[ResourceType.ASSET],
+            ...     resource_sub_types=["number"]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        if take <= 0:
+            raise ValueError(f"page_size must be greater than 0. Got {page_size}")
+
+        resolved_folder_key = await self.folder_service.retrieve_folder_key_async(
+            folder_path
+        )
+        while True:
+            spec = self._list_spec(
+                resource_types=resource_types,
+                resource_sub_types=resource_sub_types,
+                folder_key=resolved_folder_key,
+                skip=skip,
+                take=take,
+            )
+
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                )
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    @traced(name="list_by_type", run_type="uipath")
+    def list_by_type(
+        self,
+        *,
+        resource_type: ResourceType,
+        name: Optional[str] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> Iterator[Resource]:
+        """Get resources of a specific type (tenant scoped or folder scoped).
+
+        If no folder identifier is provided (path or key) only tenant resources will be retrieved.
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            resource_type: The specific resource type to filter by
+            name: Optional name filter for resources
+            resource_sub_types: Optional list of resource subtypes to filter by
+            folder_path: Optional folder path to scope the results
+            folder_key: Optional folder key to scope the results
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the criteria
+
+        Examples:
+            >>> # Get all assets
+            >>> for resource in uipath.resource_catalog.list_by_type(resource_type=ResourceType.ASSET):
+            ...     print(f"{resource.name}: {resource.resource_sub_type}")
+
+            >>> # Get assets with a specific name pattern
+            >>> assets = list(uipath.resource_catalog.list_by_type(
+            ...     resource_type=ResourceType.ASSET,
+            ...     name="config"
+            ... ))
+
+            >>> # Get assets within a specific folder with subtype filter
+            >>> for resource in uipath.resource_catalog.list_by_type(
+            ...     resource_type=ResourceType.ASSET,
+            ...     folder_path="/Shared/Finance",
+            ...     resource_sub_types=["number"]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        if take <= 0:
+            raise ValueError(f"page_size must be greater than 0. Got {page_size}")
+
+        resolved_folder_key = self.folder_service.retrieve_folder_key(folder_path)
+
+        while True:
+            spec = self._list_by_type_spec(
+                resource_type=resource_type,
+                name=name,
+                resource_sub_types=resource_sub_types,
+                folder_key=resolved_folder_key,
+                skip=skip,
+                take=take,
+            )
+
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    @traced(name="list_by_type_async", run_type="uipath")
+    async def list_by_type_async(
+        self,
+        *,
+        resource_type: ResourceType,
+        name: Optional[str] = None,
+        resource_sub_types: Optional[List[str]] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        page_size: int = _DEFAULT_PAGE_SIZE,
+    ) -> AsyncGenerator[Resource, None]:
+        """Asynchronously get resources of a specific type (tenant scoped or folder scoped).
+
+        If no folder identifier is provided (path or key) only tenant resources will be retrieved.
+        This method automatically handles pagination and yields resources one by one.
+
+        Args:
+            resource_type: The specific resource type to filter by
+            name: Optional name filter for resources
+            resource_sub_types: Optional list of resource subtypes to filter by
+            folder_path: Optional folder path to scope the results
+            folder_key: Optional folder key to scope the results
+            page_size: Number of resources to fetch per API call (default: 20, max: 100)
+
+        Yields:
+            Resource: Each resource matching the criteria
+
+        Examples:
+            >>> # Get all assets asynchronously
+            >>> async for resource in uipath.resource_catalog.list_by_type_async(resource_type=ResourceType.ASSET):
+            ...     print(f"{resource.name}: {resource.resource_sub_type}")
+
+            >>> # Get assets with a specific name pattern
+            >>> assets = []
+            >>> async for resource in uipath.resource_catalog.list_by_type_async(
+            ...     resource_type=ResourceType.ASSET,
+            ...     name="config"
+            ... ):
+            ...     assets.append(resource)
+
+            >>> # Get assets within a specific folder with subtype filter
+            >>> async for resource in uipath.resource_catalog.list_by_type_async(
+            ...     resource_type=ResourceType.ASSET,
+            ...     folder_path="/Shared/Finance",
+            ...     resource_sub_types=["number"]
+            ... ):
+            ...     print(resource.name)
+        """
+        skip = 0
+        take = min(page_size, 100)
+
+        if take <= 0:
+            raise ValueError(f"page_size must be greater than 0. Got {page_size}")
+
+        resolved_folder_key = await self.folder_service.retrieve_folder_key_async(
+            folder_path
+        )
+
+        while True:
+            spec = self._list_by_type_spec(
+                resource_type=resource_type,
+                name=name,
+                resource_sub_types=resource_sub_types,
+                folder_key=resolved_folder_key,
+                skip=skip,
+                take=take,
+            )
+
+            response = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
+                )
+            ).json()
+
+            items = response.get("value", [])
+
+            if not items:
+                break
+
+            for item in items:
+                yield Resource.model_validate(item)
+
+            if len(items) < take:
+                break
+
+            skip += take
+
+    def _search_spec(
+        self,
+        name: Optional[str],
+        resource_types: Optional[List[ResourceType]],
+        resource_sub_types: Optional[List[str]],
+        skip: int,
+        take: int,
+    ) -> RequestSpec:
+        """Build the request specification for searching resources.
+
+        Args:
+            name: Optional name filter
+            resource_types: Optional resource types filter
+            resource_sub_types: Optional resource subtypes filter
+            skip: Number of resources to skip (for pagination)
+            take: Number of resources to take
+
+        Returns:
+            RequestSpec: The request specification for the API call
+        """
+        params: Dict[str, Any] = {
+            "skip": skip,
+            "take": take,
+        }
+
+        if name:
+            params["name"] = name
+
+        if resource_types:
+            params["entityTypes"] = [x.value for x in resource_types]
+
+        if resource_sub_types:
+            params["entitySubType"] = resource_sub_types
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("resourcecatalog_/Entities/Search"),
+            params=params,
+        )
+
+    def _list_spec(
+        self,
+        resource_types: Optional[List[ResourceType]],
+        resource_sub_types: Optional[List[str]],
+        folder_key: Optional[str],
+        skip: int,
+        take: int,
+    ) -> RequestSpec:
+        """Build the request specification for getting resources.
+
+        Args:
+            resource_types: Optional resource types filter
+            resource_sub_types: Optional resource subtypes filter
+            folder_key: Optional folder key to scope the results
+            skip: Number of resources to skip (for pagination)
+            take: Number of resources to take
+
+        Returns:
+            RequestSpec: The request specification for the API call
+        """
+        params: Dict[str, Any] = {
+            "skip": skip,
+            "take": take,
+        }
+
+        if resource_types:
+            params["entityTypes"] = [x.value for x in resource_types]
+
+        if resource_sub_types:
+            params["entitySubType"] = resource_sub_types
+
+        headers = {
+            **header_folder(folder_key, None),
+        }
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("resourcecatalog_/Entities"),
+            params=params,
+            headers=headers,
+        )
+
+    def _list_by_type_spec(
+        self,
+        resource_type: ResourceType,
+        name: Optional[str],
+        resource_sub_types: Optional[List[str]],
+        folder_key: Optional[str],
+        skip: int,
+        take: int,
+    ) -> RequestSpec:
+        """Build the request specification for getting resources.
+
+        Args:
+            resource_type: Resource type
+            resource_sub_types: Optional resource subtypes filter
+            folder_key: Optional folder key to scope the results
+            skip: Number of resources to skip (for pagination)
+            take: Number of resources to take
+
+        Returns:
+            RequestSpec: The request specification for the API call
+        """
+        params: Dict[str, Any] = {
+            "skip": skip,
+            "take": take,
+        }
+
+        if name:
+            params["name"] = name
+
+        if resource_sub_types:
+            params["entitySubType"] = resource_sub_types
+
+        headers = {
+            **header_folder(folder_key, None),
+        }
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"resourcecatalog_/Entities/{resource_type.value}"),
+            params=params,
+            headers=headers,
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/resource_catalog/resource_catalog.py b/packages/uipath-platform/src/uipath/platform/resource_catalog/resource_catalog.py
new file mode 100644
index 000000000..67fdf52f6
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resource_catalog/resource_catalog.py
@@ -0,0 +1,125 @@
+"""Models for Resource Catalog service."""
+
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ResourceType(str, Enum):
+    """Resource type."""
+
+    ASSET = "asset"
+    BUCKET = "bucket"
+    MACHINE = "machine"
+    TRIGGER = "trigger"
+    PROCESS = "process"
+    PACKAGE = "package"
+    LIBRARY = "library"
+    INDEX = "index"
+    APP = "app"
+    CONNECTION = "connection"
+    CONNECTOR = "connector"
+    MCP_SERVER = "mcpserver"
+    QUEUE = "queue"
+    ENTITY = "entity"
+
+    @classmethod
+    def from_string(cls, value: str) -> "ResourceType":
+        """Create a ResourceType instance from a string value.
+
+        Args:
+            value: String value to convert to ResourceType
+
+        Returns:
+            ResourceType: The matching ResourceType enum member
+
+        Raises:
+            ValueError: If the value doesn't match any ResourceType
+        """
+        lower_value = value.lower()
+        for member in cls:
+            if member.value == lower_value:
+                return member
+
+        available = ", ".join([f"'{member.value}'" for member in cls])
+        raise ValueError(
+            f"'{value}' is not a valid ResourceType. Available options: {available}"
+        )
+
+
+class Tag(BaseModel):
+    """Tag model for resources."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    key: str
+    display_name: str = Field(alias="displayName")
+    name: str
+    display_value: str = Field(alias="displayValue")
+    value: str
+    type: str
+    account_key: str = Field(alias="accountKey")
+    tenant_key: Optional[str] = Field(None, alias="tenantKey")
+    user_key: Optional[str] = Field(None, alias="userKey")
+
+
+class Folder(BaseModel):
+    """Folder model for resources."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    id: int
+    key: str
+    display_name: str = Field(alias="displayName")
+    code: str
+    fully_qualified_name: str = Field(alias="fullyQualifiedName")
+    timestamp: str
+    tenant_key: str = Field(alias="tenantKey")
+    account_key: str = Field(alias="accountKey")
+    user_key: Optional[str] = Field(None, alias="userKey")
+    type: str
+    path: str
+    permissions: Optional[List[str]] = Field(default_factory=list)
+
+
+class Resource(BaseModel):
+    """Resource model from Resource Catalog."""
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    resource_key: str = Field(alias="entityKey")
+    name: str
+    description: Optional[str] = None
+    resource_type: str = Field(alias="entityType")
+    tags: Optional[List[Tag]] = Field(default_factory=list)
+    folders: List[Folder] = Field(default_factory=list)
+    linked_folders_count: int = Field(0, alias="linkedFoldersCount")
+    source: Optional[str] = None
+    scope: str
+    search_state: str = Field(alias="searchState")
+    timestamp: str
+    folder_key: Optional[str] = Field(None, alias="folderKey")
+    folder_keys: List[str] = Field(default_factory=list, alias="folderKeys")
+    tenant_key: Optional[str] = Field(None, alias="tenantKey")
+    account_key: str = Field(alias="accountKey")
+    user_key: Optional[str] = Field(None, alias="userKey")
+    dependencies: Optional[list[str]] = Field(default_factory=list)
+    custom_data: Optional[str] = Field(None, alias="customData")
+    resource_sub_type: Optional[str] = Field(None, alias="entitySubType")
+
+
+class ResourceSearchResponse(BaseModel):
+    """Response model for resource search API."""
+
+    count: int
+    value: List[Resource]
diff --git a/packages/uipath-platform/src/uipath/platform/resume_triggers/__init__.py b/packages/uipath-platform/src/uipath/platform/resume_triggers/__init__.py
new file mode 100644
index 000000000..47c35f5b7
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resume_triggers/__init__.py
@@ -0,0 +1,17 @@
+"""Init file for resume triggers module."""
+
+from ._enums import PropertyName, TriggerMarker, is_no_content_marker
+from ._protocol import (
+    UiPathResumeTriggerCreator,
+    UiPathResumeTriggerHandler,
+    UiPathResumeTriggerReader,
+)
+
+__all__ = [
+    "UiPathResumeTriggerReader",
+    "UiPathResumeTriggerCreator",
+    "UiPathResumeTriggerHandler",
+    "PropertyName",
+    "TriggerMarker",
+    "is_no_content_marker",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/resume_triggers/_enums.py b/packages/uipath-platform/src/uipath/platform/resume_triggers/_enums.py
new file mode 100644
index 000000000..f1a228497
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resume_triggers/_enums.py
@@ -0,0 +1,55 @@
+"""UiPath resume trigger enums."""
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class PropertyName(str, Enum):
+    """UiPath trigger property names."""
+
+    INTERNAL = "__internal"
+
+
+class TriggerMarker(str, Enum):
+    """UiPath trigger markers.
+
+    These markers are used as properties of resume triggers objects for special handling at runtime.
+    """
+
+    NO_CONTENT = "NO_CONTENT"
+
+
+def is_no_content_marker(value: Any) -> bool:
+    """Check if a value is a NO_CONTENT trigger marker (dict or string form)."""
+    if isinstance(value, dict):
+        return value.get(PropertyName.INTERNAL.value) == TriggerMarker.NO_CONTENT.value
+    if isinstance(value, str):
+        return (
+            PropertyName.INTERNAL.value in value
+            and TriggerMarker.NO_CONTENT.value in value
+        )
+    return False
+
+
+class ExternalTriggerType(str, Enum):
+    """External trigger types."""
+
+    DEEP_RAG = "deepRag"
+    BATCH_RAG = "batchRag"
+    IXP_EXTRACTION = "ixpExtraction"
+    INDEX_INGESTION = "indexIngestion"
+    IXP_VS_ESCALATION = "IxpVsEscalation"
+
+
+class ExternalTrigger(BaseModel):
+    """Model representing an external trigger entity."""
+
+    type: ExternalTriggerType
+    external_id: str = Field(alias="externalId")
+
+    model_config = {
+        "validate_by_name": True,
+        "validate_by_alias": True,
+    }
diff --git a/packages/uipath-platform/src/uipath/platform/resume_triggers/_protocol.py b/packages/uipath-platform/src/uipath/platform/resume_triggers/_protocol.py
new file mode 100644
index 000000000..b2dbae787
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/resume_triggers/_protocol.py
@@ -0,0 +1,1020 @@
+"""Implementation of UiPath resume trigger protocols."""
+
+import json
+import os
+import uuid
+from typing import Any
+
+from uipath.core.errors import (
+    ErrorCategory,
+    UiPathFaultedTriggerError,
+    UiPathPendingTriggerError,
+)
+from uipath.core.serialization import serialize_object
+from uipath.core.triggers import (
+    UiPathApiTrigger,
+    UiPathIntegrationTrigger,
+    UiPathResumeTrigger,
+    UiPathResumeTriggerName,
+    UiPathResumeTriggerType,
+)
+
+from uipath.platform import UiPath
+from uipath.platform.action_center import Task
+from uipath.platform.action_center.tasks import TaskStatus
+from uipath.platform.common._config import UiPathConfig
+from uipath.platform.common.interrupt_models import (
+    CreateBatchTransform,
+    CreateDeepRag,
+    CreateDeepRagRaw,
+    CreateEphemeralIndex,
+    CreateEphemeralIndexRaw,
+    CreateEscalation,
+    CreateTask,
+    DocumentExtraction,
+    DocumentExtractionValidation,
+    InvokeProcess,
+    InvokeProcessRaw,
+    InvokeSystemAgent,
+    WaitBatchTransform,
+    WaitDeepRag,
+    WaitDeepRagRaw,
+    WaitDocumentExtraction,
+    WaitDocumentExtractionValidation,
+    WaitEphemeralIndex,
+    WaitEphemeralIndexRaw,
+    WaitEscalation,
+    WaitIntegrationEvent,
+    WaitJob,
+    WaitJobRaw,
+    WaitSystemAgent,
+    WaitTask,
+)
+from uipath.platform.connections import EventArguments
+from uipath.platform.context_grounding import DeepRagStatus, IndexStatus
+from uipath.platform.context_grounding.context_grounding_index import (
+    ContextGroundingIndex,
+)
+from uipath.platform.errors import (
+    BatchTransformFailedException,
+    BatchTransformNotCompleteException,
+    OperationNotCompleteException,
+)
+from uipath.platform.orchestrator.job import JobState
+from uipath.platform.resume_triggers._enums import (
+    ExternalTrigger,
+    ExternalTriggerType,
+    PropertyName,
+    TriggerMarker,
+)
+
+
+def _try_convert_to_json_format(value: str | None) -> Any:
+    """Attempts to parse a string as JSON and returns the parsed object or original string.
+
+    Args:
+        value: The string value to attempt JSON parsing on.
+
+    Returns:
+        The parsed JSON object if successful, otherwise the original string value.
+    """
+    try:
+        if not value:
+            return None
+        return json.loads(value)
+    except json.decoder.JSONDecodeError:
+        return value
+
+
+class UiPathResumeTriggerReader:
+    """Handles reading and retrieving Human-In-The-Loop (HITL) data from UiPath services.
+
+    Implements UiPathResumeTriggerReaderProtocol.
+    """
+
+    def _extract_field(self, field_name: str, payload: Any) -> str | None:
+        """Extracts a field from the payload and returns it if it exists."""
+        if not payload:
+            return payload
+
+        if isinstance(payload, dict):
+            return payload.get(field_name)
+
+        # 2.3.0 remove
+        try:
+            payload_dict = json.loads(payload)
+            return payload_dict.get(field_name)
+        except json.decoder.JSONDecodeError:
+            return None
+
+    async def read_trigger(self, trigger: UiPathResumeTrigger) -> Any | None:
+        """Read a resume trigger and convert it to runtime-compatible input.
+
+        This method retrieves data from UiPath services (Actions, Jobs, API)
+        based on the trigger type and returns it in a format that the
+        runtime can use to resume execution.
+
+        Args:
+            trigger: The resume trigger to read
+
+        Returns:
+            The data retrieved from UiPath services, ready to be used
+            as resume input. Format depends on trigger type:
+            - TASK: Task data (possibly with escalation processing)
+            - JOB: Job output data
+            - API: API payload
+            Returns None if no data is available.
+
+        Raises:
+            UiPathRuntimeError: If reading fails, job failed, API connection failed,
+                trigger type is unknown, or HITL feedback retrieval failed.
+        """
+        uipath = UiPath()
+
+        match trigger.trigger_type:
+            case UiPathResumeTriggerType.TASK:
+                if trigger.item_key:
+                    task: Task = await uipath.tasks.retrieve_async(
+                        trigger.item_key,
+                        app_folder_key=trigger.folder_key,
+                        app_folder_path=trigger.folder_path,
+                        app_name=self._extract_field("app_name", trigger.payload),
+                    )
+                    pending_status = TaskStatus.PENDING.value
+                    unassigned_status = TaskStatus.UNASSIGNED.value
+
+                    if (
+                        task.status in (pending_status, unassigned_status)
+                        and not task.is_deleted
+                    ):
+                        # 2.3.0 remove (task.status will already be the enum)
+                        current_status = (
+                            TaskStatus(task.status).name
+                            if isinstance(task.status, int)
+                            else "Unknown"
+                        )
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Task is not completed yet. Current status: {current_status}",
+                        )
+
+                    if trigger.trigger_name == UiPathResumeTriggerName.ESCALATION:
+                        return task
+
+                    # if task is deleted, raise error only for Task models
+                    # for escalations we return the task object to allow graceful handling down the stream
+                    if task.is_deleted:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.USER,
+                            f"The {task.title} task was deleted",
+                        )
+
+                    trigger_response = task.data
+                    if not bool(trigger_response):
+                        # 2.3.0 change to task.status.name
+                        assert isinstance(task.status, int)
+                        trigger_response = {
+                            "status": TaskStatus(task.status).name.lower(),
+                            PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+                        }
+
+                    return trigger_response
+
+            case UiPathResumeTriggerType.JOB:
+                if trigger.item_key:
+                    job = await uipath.jobs.retrieve_async(
+                        trigger.item_key,
+                        folder_key=trigger.folder_key,
+                        folder_path=trigger.folder_path,
+                        process_name=self._extract_field("name", trigger.payload),
+                    )
+
+                    job_state = (job.state or "").lower()
+                    successful_state = JobState.SUCCESSFUL.value
+                    faulted_state = JobState.FAULTED.value
+                    running_state = JobState.RUNNING.value
+                    pending_state = JobState.PENDING.value
+                    resumed_state = JobState.RESUMED.value
+                    suspended_state = JobState.SUSPENDED.value
+
+                    if job_state in (
+                        pending_state,
+                        running_state,
+                        suspended_state,
+                        resumed_state,
+                    ):
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Job is not finished yet. Current state: {job_state}",
+                        )
+
+                    if trigger.trigger_name == UiPathResumeTriggerName.JOB_RAW:
+                        return job
+
+                    if job_state != successful_state:
+                        job_error = (
+                            _try_convert_to_json_format(str(job.job_error or job.info))
+                            or "Job error unavailable."
+                            if job_state == faulted_state
+                            else f"Job {job.key} is {job_state}."
+                        )
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.USER,
+                            f"Process did not finish successfully. Error: {job_error}",
+                        )
+
+                    output_data = await uipath.jobs.extract_output_async(job)
+                    trigger_response = _try_convert_to_json_format(output_data)
+
+                    # if response is an empty dictionary, use job state as placeholder value
+                    if isinstance(trigger_response, dict) and not bool(
+                        trigger_response
+                    ):
+                        # 2.3.0 change to job_state.value
+                        trigger_response = {
+                            "state": job_state,
+                            PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+                        }
+
+                    return trigger_response
+            case UiPathResumeTriggerType.DEEP_RAG:
+                if trigger.item_key:
+                    deep_rag = await uipath.context_grounding.retrieve_deep_rag_async(
+                        trigger.item_key,
+                        index_name=self._extract_field("index_name", trigger.payload),
+                    )
+                    deep_rag_status = deep_rag.last_deep_rag_status
+
+                    if deep_rag_status in (
+                        DeepRagStatus.QUEUED,
+                        DeepRagStatus.IN_PROGRESS,
+                    ):
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"DeepRag is not finished yet. Current status: {deep_rag_status}",
+                        )
+
+                    if trigger.trigger_name == UiPathResumeTriggerName.DEEP_RAG_RAW:
+                        return deep_rag
+
+                    if deep_rag_status != DeepRagStatus.SUCCESSFUL:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.USER,
+                            f"DeepRag '{deep_rag.name}' did not finish successfully.",
+                        )
+
+                    trigger_response = deep_rag.content
+
+                    # if response is an empty dictionary, use Deep Rag state as placeholder value
+                    if not trigger_response:
+                        trigger_response = {
+                            "status": deep_rag_status,
+                            PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+                        }
+                    else:
+                        trigger_response = trigger_response.model_dump()
+                        trigger_response["deepRagId"] = trigger.item_key
+
+                    return trigger_response
+
+            case UiPathResumeTriggerType.INDEX_INGESTION:
+                if trigger.item_key:
+                    index = await uipath.context_grounding.retrieve_by_id_async(
+                        trigger.item_key
+                    )
+
+                    ephemeral_index = ContextGroundingIndex(**index)
+
+                    ephemeral_index_status = ephemeral_index.last_ingestion_status
+
+                    if ephemeral_index_status in (
+                        IndexStatus.QUEUED,
+                        IndexStatus.IN_PROGRESS,
+                    ):
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Index ingestion is not finished yet. Current status: {ephemeral_index_status}",
+                        )
+
+                    if (
+                        trigger.trigger_name
+                        == UiPathResumeTriggerName.INDEX_INGESTION_RAW
+                    ):
+                        return ephemeral_index
+
+                    if ephemeral_index_status != IndexStatus.SUCCESSFUL:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.USER,
+                            f"Index ingestion '{ephemeral_index.name}' did not finish successfully.",
+                        )
+
+                    trigger_response = ephemeral_index.model_dump()
+
+                    return trigger_response
+
+            case UiPathResumeTriggerType.BATCH_RAG:
+                if trigger.item_key:
+                    destination_path = self._extract_field(
+                        "destination_path", trigger.payload
+                    )
+                    assert destination_path is not None
+                    try:
+                        await uipath.context_grounding.download_batch_transform_result_async(
+                            trigger.item_key,
+                            destination_path,
+                            validate_status=True,
+                            index_name=self._extract_field(
+                                "index_name", trigger.payload
+                            ),
+                        )
+                    except BatchTransformFailedException as e:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"{e.message}",
+                        ) from e
+                    except BatchTransformNotCompleteException as e:
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"{e.message}",
+                        ) from e
+
+                    return f"Batch transform completed. Modified file available at {os.path.abspath(destination_path)}"
+
+            case UiPathResumeTriggerType.IXP_EXTRACTION:
+                if trigger.item_key:
+                    project_id = self._extract_field("project_id", trigger.payload)
+                    tag = self._extract_field("tag", trigger.payload)
+
+                    assert project_id is not None
+                    assert tag is not None
+
+                    try:
+                        extraction_response = (
+                            await uipath.documents.retrieve_ixp_extraction_result_async(
+                                project_id, tag, trigger.item_key
+                            )
+                        )
+                    except OperationNotCompleteException as e:
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"{e.message}",
+                        ) from e
+
+                    return extraction_response.model_dump()
+
+            case UiPathResumeTriggerType.IXP_VS_ESCALATION:
+                if trigger.item_key:
+                    project_id = self._extract_field("project_id", trigger.payload)
+                    tag = self._extract_field("tag", trigger.payload)
+
+                    assert project_id is not None
+                    assert tag is not None
+                    try:
+                        escalation_response = await uipath.documents.retrieve_ixp_extraction_validation_result_async(
+                            project_id, tag, trigger.item_key
+                        )
+                    except OperationNotCompleteException as e:
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"{e.message}",
+                        ) from e
+
+                    pending_status_name = TaskStatus.PENDING.name.lower()
+                    unassigned_status_name = TaskStatus.UNASSIGNED.name.lower()
+
+                    current_status = escalation_response.action_data["status"].lower()
+                    if current_status in (pending_status_name, unassigned_status_name):
+                        raise UiPathPendingTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Document extraction escalation task is not completed yet. Current status: {current_status}",
+                        )
+
+                    return escalation_response.model_dump()
+
+            case UiPathResumeTriggerType.API:
+                if trigger.api_resume and trigger.api_resume.inbox_id:
+                    try:
+                        return await uipath.jobs.retrieve_api_payload_async(
+                            trigger.api_resume.inbox_id
+                        )
+                    except Exception as e:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Failed to get trigger payload"
+                            f"Error fetching API trigger payload for inbox {trigger.api_resume.inbox_id}: {str(e)}",
+                        ) from e
+
+            case UiPathResumeTriggerType.INBOX:
+                if trigger.integration_resume and trigger.integration_resume.inbox_id:
+                    try:
+                        inbox_payload = await uipath.jobs.retrieve_inbox_payload_async(
+                            trigger.integration_resume.inbox_id
+                        )
+                        event_args = EventArguments.model_validate(inbox_payload)
+                        return await uipath.connections.retrieve_event_payload_async(
+                            event_args
+                        )
+                    except Exception as e:
+                        raise UiPathFaultedTriggerError(
+                            ErrorCategory.SYSTEM,
+                            f"Failed to get trigger payload"
+                            f"Error fetching Inbox trigger payload for inbox {trigger.integration_resume.inbox_id}: {str(e)}",
+                        ) from e
+
+            case _:
+                raise UiPathFaultedTriggerError(
+                    ErrorCategory.SYSTEM,
+                    f"Unexpected trigger type received"
+                    f"Trigger type :{type(trigger.trigger_type)} is invalid",
+                )
+
+        raise UiPathFaultedTriggerError(
+            ErrorCategory.SYSTEM, "Failed to receive payload from HITL action"
+        )
+
+
+class UiPathResumeTriggerCreator:
+    """Creates resume triggers from suspend values.
+
+    Implements UiPathResumeTriggerCreatorProtocol.
+    """
+
+    async def create_trigger(self, suspend_value: Any) -> UiPathResumeTrigger:
+        """Create a resume trigger from a suspend value.
+
+        This method processes the input value and creates an appropriate resume trigger
+        for HITL scenarios. It handles different input types:
+        - Tasks: Creates or references UiPath tasks with folder information
+        - Jobs: Invokes processes or references existing jobs with folder information
+        - API: Creates API triggers with generated inbox IDs
+
+        Args:
+            suspend_value: The value that caused the suspension.
+                Can be UiPath models (CreateTask, InvokeProcess, etc.),
+                strings, or any other value that needs HITL processing.
+
+        Returns:
+            UiPathResumeTrigger ready to be persisted
+
+        Raises:
+            UiPathRuntimeError: If action/job creation fails, escalation fails, or an
+                unknown model type is encountered.
+            Exception: If any underlying UiPath service calls fail.
+        """
+        try:
+            trigger_type = self._determine_trigger_type(suspend_value)
+            trigger_name = self._determine_trigger_name(suspend_value)
+
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=trigger_type,
+                trigger_name=trigger_name,
+                payload=serialize_object(suspend_value),
+            )
+
+            match trigger_type:
+                case UiPathResumeTriggerType.TASK:
+                    await self._handle_task_trigger(suspend_value, resume_trigger)
+
+                case UiPathResumeTriggerType.JOB:
+                    await self._handle_job_trigger(suspend_value, resume_trigger)
+
+                case UiPathResumeTriggerType.API:
+                    self._handle_api_trigger(suspend_value, resume_trigger)
+
+                case UiPathResumeTriggerType.INBOX:
+                    await self._handle_inbox_trigger(suspend_value, resume_trigger)
+
+                case UiPathResumeTriggerType.DEEP_RAG:
+                    await self._handle_deep_rag_job_trigger(
+                        suspend_value, resume_trigger
+                    )
+                case UiPathResumeTriggerType.INDEX_INGESTION:
+                    await self._handle_ephemeral_index_job_trigger(
+                        suspend_value, resume_trigger
+                    )
+                case UiPathResumeTriggerType.BATCH_RAG:
+                    await self._handle_batch_rag_job_trigger(
+                        suspend_value, resume_trigger
+                    )
+                case UiPathResumeTriggerType.IXP_EXTRACTION:
+                    await self._handle_ixp_extraction_trigger(
+                        suspend_value, resume_trigger
+                    )
+                case UiPathResumeTriggerType.IXP_VS_ESCALATION:
+                    await self._handle_ixp_vs_escalation_trigger(
+                        suspend_value, resume_trigger
+                    )
+                case _:
+                    raise UiPathFaultedTriggerError(
+                        ErrorCategory.SYSTEM,
+                        f"Unexpected model received"
+                        f"{type(suspend_value)} is not a valid Human-In-The-Loop model",
+                    )
+        except Exception as e:
+            raise UiPathFaultedTriggerError(
+                ErrorCategory.SYSTEM,
+                "Failed to create HITL action",
+                f"{str(e)}",
+            ) from e
+        return resume_trigger
+
+    async def _create_external_trigger(self, external_trigger: ExternalTrigger):
+        """Creates an external trigger in orchestrator."""
+        # only create external trigger entities for non-debug runs
+        if not UiPathConfig.job_key:
+            return
+
+        uipath = UiPath()
+        await uipath.api_client.request_async(
+            method="POST",
+            url="orchestrator_/api/JobTriggers/SaveExternalTrigger",
+            json=external_trigger.model_dump(by_alias=True),
+        )
+
+    def _determine_trigger_type(self, value: Any) -> UiPathResumeTriggerType:
+        """Determines the resume trigger type based on the input value.
+
+        Args:
+            value: The suspend value to analyze
+
+        Returns:
+            The appropriate UiPathResumeTriggerType based on the input value type.
+        """
+        if isinstance(value, (CreateTask, WaitTask, CreateEscalation, WaitEscalation)):
+            return UiPathResumeTriggerType.TASK
+        if isinstance(
+            value,
+            (
+                InvokeProcess,
+                InvokeProcessRaw,
+                WaitJob,
+                WaitJobRaw,
+                InvokeSystemAgent,
+                WaitSystemAgent,
+            ),
+        ):
+            return UiPathResumeTriggerType.JOB
+        if isinstance(
+            value, (CreateDeepRag, CreateDeepRagRaw, WaitDeepRag, WaitDeepRagRaw)
+        ):
+            return UiPathResumeTriggerType.DEEP_RAG
+        if isinstance(value, (CreateEphemeralIndex, WaitEphemeralIndex)):
+            return UiPathResumeTriggerType.INDEX_INGESTION
+        if isinstance(value, (CreateBatchTransform, WaitBatchTransform)):
+            return UiPathResumeTriggerType.BATCH_RAG
+        if isinstance(value, (DocumentExtraction, WaitDocumentExtraction)):
+            return UiPathResumeTriggerType.IXP_EXTRACTION
+        if isinstance(
+            value, (DocumentExtractionValidation, WaitDocumentExtractionValidation)
+        ):
+            return UiPathResumeTriggerType.IXP_VS_ESCALATION
+        if isinstance(value, WaitIntegrationEvent):
+            return UiPathResumeTriggerType.INBOX
+        # default to API trigger
+        return UiPathResumeTriggerType.API
+
+    def _determine_trigger_name(self, value: Any) -> UiPathResumeTriggerName:
+        """Determines the resume trigger name based on the input value.
+
+        Args:
+            value: The suspend value to analyze
+
+        Returns:
+            The appropriate UiPathResumeTriggerName based on the input value type.
+        """
+        if isinstance(value, (CreateEscalation, WaitEscalation)):
+            return UiPathResumeTriggerName.ESCALATION
+        if isinstance(value, (CreateTask, WaitTask)):
+            return UiPathResumeTriggerName.TASK
+        if isinstance(value, (InvokeProcessRaw, WaitJobRaw)):
+            return UiPathResumeTriggerName.JOB_RAW
+        if isinstance(
+            value, (InvokeProcess, WaitJob, InvokeSystemAgent, WaitSystemAgent)
+        ):
+            return UiPathResumeTriggerName.JOB
+        if isinstance(value, (CreateDeepRagRaw, WaitDeepRagRaw)):
+            return UiPathResumeTriggerName.DEEP_RAG_RAW
+        if isinstance(value, (CreateDeepRag, WaitDeepRag)):
+            return UiPathResumeTriggerName.DEEP_RAG
+        if isinstance(value, (CreateEphemeralIndexRaw, WaitEphemeralIndexRaw)):
+            return UiPathResumeTriggerName.INDEX_INGESTION_RAW
+        if isinstance(value, (CreateEphemeralIndex, WaitEphemeralIndex)):
+            return UiPathResumeTriggerName.INDEX_INGESTION
+        if isinstance(value, (CreateBatchTransform, WaitBatchTransform)):
+            return UiPathResumeTriggerName.BATCH_RAG
+        if isinstance(value, (DocumentExtraction, WaitDocumentExtraction)):
+            return UiPathResumeTriggerName.EXTRACTION
+        if isinstance(value, WaitIntegrationEvent):
+            return UiPathResumeTriggerName.INBOX
+        # default to API trigger
+        return UiPathResumeTriggerName.API
+
+    async def _handle_task_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle task-type resume triggers.
+
+        Args:
+            value: The suspend value (CreateTask or WaitTask)
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.folder_path = value.app_folder_path
+        resume_trigger.folder_key = value.app_folder_key
+
+        if isinstance(value, (WaitTask, WaitEscalation)):
+            resume_trigger.item_key = value.action.key
+        elif isinstance(value, (CreateTask, CreateEscalation)):
+            uipath = UiPath()
+            action = await uipath.tasks.create_async(
+                title=value.title,
+                app_name=value.app_name if value.app_name else "",
+                app_folder_path=value.app_folder_path or None,
+                app_folder_key=value.app_folder_key or None,
+                app_key=value.app_key if value.app_key else "",
+                assignee=value.assignee if value.assignee else "",
+                recipient=value.recipient if value.recipient else "",
+                data=value.data,
+                priority=value.priority,
+                labels=value.labels,
+                is_actionable_message_enabled=value.is_actionable_message_enabled,
+                actionable_message_metadata=value.actionable_message_metadata,
+                source_name=value.source_name,
+            )
+            if not action:
+                raise Exception("Failed to create action")
+            resume_trigger.item_key = action.key
+
+    async def _handle_deep_rag_job_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle Deep RAG resume triggers.
+
+        Args:
+            value: The suspend value (CreateDeepRag or WaitDeepRag)
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.folder_path = value.index_folder_path
+        resume_trigger.folder_key = value.index_folder_key
+        if isinstance(value, WaitDeepRag):
+            resume_trigger.item_key = value.deep_rag.id
+        elif isinstance(value, CreateDeepRag):
+            uipath = UiPath()
+            if value.is_ephemeral_index:
+                deep_rag = (
+                    await uipath.context_grounding.start_deep_rag_ephemeral_async(
+                        name=value.name,
+                        index_id=value.index_id,
+                        prompt=value.prompt,
+                        glob_pattern=value.glob_pattern,
+                        citation_mode=value.citation_mode,
+                    )
+                )
+
+            else:
+                deep_rag = await uipath.context_grounding.start_deep_rag_async(
+                    name=value.name,
+                    index_name=value.index_name,
+                    index_id=value.index_id,
+                    prompt=value.prompt,
+                    glob_pattern=value.glob_pattern,
+                    citation_mode=value.citation_mode,
+                    folder_path=value.index_folder_path,
+                    folder_key=value.index_folder_key,
+                )
+            if not deep_rag:
+                raise Exception("Failed to start deep rag")
+
+            resume_trigger.item_key = deep_rag.id
+
+        assert resume_trigger.item_key
+        await self._create_external_trigger(
+            ExternalTrigger(
+                type=ExternalTriggerType.DEEP_RAG, external_id=resume_trigger.item_key
+            )
+        )
+
+    async def _handle_ephemeral_index_job_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle ephemeral index.
+
+        Args:
+            value: The suspend value (CreateEphemeralIndex or WaitEphemeralIndex)
+            resume_trigger: The resume trigger to populate
+
+        """
+        if isinstance(value, WaitEphemeralIndex):
+            resume_trigger.item_key = value.index.id
+        elif isinstance(value, CreateEphemeralIndex):
+            uipath = UiPath()
+            ephemeral_index = (
+                await uipath.context_grounding.create_ephemeral_index_async(
+                    usage=value.usage,
+                    attachments=value.attachments,
+                )
+            )
+            if not ephemeral_index:
+                raise Exception("Failed to create ephemeral index")
+            resume_trigger.item_key = ephemeral_index.id
+
+        assert resume_trigger.item_key
+        await self._create_external_trigger(
+            ExternalTrigger(
+                type=ExternalTriggerType.INDEX_INGESTION,
+                external_id=resume_trigger.item_key,
+            )
+        )
+
+    async def _handle_batch_rag_job_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle batch transform resume triggers.
+
+        Args:
+            value: The suspend value (CreateBatchTransform or WaitBatchTransform)
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.folder_path = value.index_folder_path
+        resume_trigger.folder_key = value.index_folder_key
+        if isinstance(value, WaitBatchTransform):
+            resume_trigger.item_key = value.batch_transform.id
+        elif isinstance(value, CreateBatchTransform):
+            uipath = UiPath()
+            if value.is_ephemeral_index:
+                batch_transform = await uipath.context_grounding.start_batch_transform_ephemeral_async(
+                    name=value.name,
+                    index_id=value.index_id,
+                    prompt=value.prompt,
+                    output_columns=value.output_columns,
+                    storage_bucket_folder_path_prefix=value.storage_bucket_folder_path_prefix,
+                    enable_web_search_grounding=value.enable_web_search_grounding,
+                )
+            else:
+                batch_transform = await uipath.context_grounding.start_batch_transform_async(
+                    name=value.name,
+                    index_name=value.index_name,
+                    index_id=value.index_id,
+                    prompt=value.prompt,
+                    output_columns=value.output_columns,
+                    storage_bucket_folder_path_prefix=value.storage_bucket_folder_path_prefix,
+                    enable_web_search_grounding=value.enable_web_search_grounding,
+                    folder_path=value.index_folder_path,
+                    folder_key=value.index_folder_key,
+                )
+            if not batch_transform:
+                raise Exception("Failed to start batch transform")
+
+            resume_trigger.item_key = batch_transform.id
+
+        assert resume_trigger.item_key
+        await self._create_external_trigger(
+            ExternalTrigger(
+                type=ExternalTriggerType.BATCH_RAG,
+                external_id=resume_trigger.item_key,
+            )
+        )
+
+    async def _handle_ixp_extraction_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle IXP Extraction resume triggers.
+
+        Args:
+            value: The suspend value (DocumentExtraction or WaitDocumentExtraction)
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.folder_path = resume_trigger.folder_key = None
+        if isinstance(value, WaitDocumentExtraction):
+            resume_trigger.item_key = value.extraction.operation_id
+            # add project_id and tag to the payload dict (needed when reading the trigger)
+            assert isinstance(resume_trigger.payload, dict)
+            resume_trigger.payload.setdefault("project_id", value.extraction.project_id)
+            resume_trigger.payload.setdefault("tag", value.extraction.tag)
+        elif isinstance(value, DocumentExtraction):
+            uipath = UiPath()
+            document_extraction = await uipath.documents.start_ixp_extraction_async(
+                project_name=value.project_name,
+                tag=value.tag,
+                file=value.file,
+                file_path=value.file_path,
+            )
+            if not document_extraction:
+                raise Exception("Failed to start document extraction")
+
+            resume_trigger.item_key = document_extraction.operation_id
+
+            # add project_id and tag to the payload dict (needed when reading the trigger)
+            assert isinstance(resume_trigger.payload, dict)
+            resume_trigger.payload.setdefault(
+                "project_id", document_extraction.project_id
+            )
+            resume_trigger.payload.setdefault("tag", document_extraction.tag)
+
+        assert resume_trigger.item_key
+        await self._create_external_trigger(
+            ExternalTrigger(
+                type=ExternalTriggerType.IXP_EXTRACTION,
+                external_id=resume_trigger.item_key,
+            )
+        )
+
+    async def _handle_ixp_vs_escalation_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle IXP VS Escalation resume triggers.
+
+        Args:
+            value: The suspend value (DocumentExtractionValidation or WaitDocumentExtractionValidation)
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.folder_path = resume_trigger.folder_key = None
+
+        if isinstance(value, WaitDocumentExtractionValidation):
+            resume_trigger.item_key = value.extraction_validation.operation_id
+
+            # add project_id and tag to the payload dict (needed when reading the trigger)
+            assert isinstance(resume_trigger.payload, dict)
+            resume_trigger.payload.setdefault(
+                "project_id", value.extraction_validation.project_id
+            )
+            resume_trigger.payload.setdefault("tag", value.extraction_validation.tag)
+        elif isinstance(value, DocumentExtractionValidation):
+            uipath = UiPath()
+            extraction_validation = (
+                await uipath.documents.start_ixp_extraction_validation_async(
+                    extraction_response=value.extraction_response,
+                    action_title=value.action_title,
+                    action_priority=value.action_priority,
+                    action_folder=value.action_folder,
+                    storage_bucket_name=value.storage_bucket_name,
+                    storage_bucket_directory_path=value.storage_bucket_directory_path,
+                )
+            )
+            if not extraction_validation:
+                raise Exception("Failed to start extraction validation")
+
+            resume_trigger.item_key = extraction_validation.operation_id
+
+            # add project_id and tag to the payload dict (needed when reading the trigger)
+            assert isinstance(resume_trigger.payload, dict)
+            resume_trigger.payload.setdefault(
+                "project_id", extraction_validation.project_id
+            )
+            resume_trigger.payload.setdefault("tag", extraction_validation.tag)
+
+        assert resume_trigger.item_key
+        await self._create_external_trigger(
+            ExternalTrigger(
+                type=ExternalTriggerType.IXP_VS_ESCALATION,
+                external_id=resume_trigger.item_key,
+            )
+        )
+
+    async def _handle_job_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle job-type resume triggers.
+
+        Args:
+            value: The suspend value (InvokeProcess, WaitJob, InvokeSystemAgent, WaitSystemAgent)
+            resume_trigger: The resume trigger to populate
+        """
+        if isinstance(value, InvokeSystemAgent):
+            resume_trigger.folder_path = value.folder_path
+            resume_trigger.folder_key = value.folder_key
+        else:
+            resume_trigger.folder_path = value.process_folder_path
+            resume_trigger.folder_key = value.process_folder_key
+
+        if isinstance(value, WaitJob):
+            resume_trigger.item_key = value.job.key
+        elif isinstance(value, WaitSystemAgent):
+            resume_trigger.item_key = value.job_key
+        elif isinstance(value, InvokeProcess):
+            uipath = UiPath()
+            job = await uipath.processes.invoke_async(
+                name=value.name,
+                input_arguments=value.input_arguments,
+                attachments=value.attachments,
+                folder_path=value.process_folder_path,
+                folder_key=value.process_folder_key,
+            )
+            if not job:
+                raise Exception("Failed to invoke process")
+            resume_trigger.item_key = job.key
+        elif isinstance(value, InvokeSystemAgent):
+            uipath = UiPath()
+            job_key = await uipath.agenthub.invoke_system_agent_async(
+                agent_name=value.agent_name,
+                entrypoint=value.entrypoint,
+                input_arguments=value.input_arguments,
+                folder_path=value.folder_path,
+                folder_key=value.folder_key,
+            )
+            if not job_key:
+                raise Exception("Failed to invoke system agent")
+            resume_trigger.item_key = job_key
+
+    def _handle_api_trigger(
+        self, value: Any, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle API-type resume triggers.
+
+        Args:
+            value: The suspend value
+            resume_trigger: The resume trigger to populate
+        """
+        resume_trigger.api_resume = UiPathApiTrigger(
+            inbox_id=str(uuid.uuid4()), request=serialize_object(value)
+        )
+
+    async def _handle_inbox_trigger(
+        self, value: WaitIntegrationEvent, resume_trigger: UiPathResumeTrigger
+    ) -> None:
+        """Handle Inbox-type resume triggers.
+
+        Resolves `connection_name` (scoped to `connection_folder_path` when
+        provided) to a connection id via the Connections service, populates
+        `integration_resume` with the Integration Services configuration plus a
+        freshly generated `inbox_id`. The Connections-service registration is
+        performed server-side by Orchestrator's `CreateResumeTriggerTaskHandler`
+        once the job suspends.
+
+        Args:
+            value: The suspend value (WaitIntegrationEvent)
+            resume_trigger: The resume trigger to populate
+
+        Raises:
+            Exception: If no connection matches `connection_name`, or if more
+                than one exact match is found.
+        """
+        uipath = UiPath()
+        connections = await uipath.connections.list_async(
+            name=value.connection_name,
+            folder_path=value.connection_folder_path,
+            connector_key=value.connector,
+        )
+        connection = next(
+            (c for c in connections if c.name == value.connection_name), None
+        )
+        if connection is None:
+            raise Exception(
+                f"No connection named '{value.connection_name}' "
+                f"for connector '{value.connector}' found"
+                + (
+                    f" in folder '{value.connection_folder_path}'"
+                    if value.connection_folder_path
+                    else ""
+                )
+            )
+        assert connection.id is not None
+
+        resume_trigger.integration_resume = UiPathIntegrationTrigger(
+            connector=value.connector,
+            connection_id=connection.id,
+            operation=value.operation,
+            object_name=value.object_name,
+            filter_expression=value.filter_expression,
+            parameters=value.parameters,
+            inbox_id=str(uuid.uuid4()),
+        )
+
+
+class UiPathResumeTriggerHandler:
+    """Combined handler for creating and reading resume triggers.
+
+    Implements UiPathResumeTriggerProtocol by composing the creator and reader.
+    """
+
+    def __init__(self):
+        """Initialize the handler with creator and reader instances."""
+        self._creator = UiPathResumeTriggerCreator()
+        self._reader = UiPathResumeTriggerReader()
+
+    async def create_trigger(self, suspend_value: Any) -> UiPathResumeTrigger:
+        """Create a resume trigger from a suspend value.
+
+        Args:
+            suspend_value: The value that caused the suspension.
+
+        Returns:
+            UiPathResumeTrigger ready to be persisted
+
+        Raises:
+            UiPathRuntimeError: If trigger creation fails
+        """
+        return await self._creator.create_trigger(suspend_value)
+
+    async def read_trigger(self, trigger: UiPathResumeTrigger) -> Any | None:
+        """Read a resume trigger and convert it to runtime-compatible input.
+
+        Args:
+            trigger: The resume trigger to read
+
+        Returns:
+            The data retrieved from UiPath services, or None if no data is available.
+
+        Raises:
+            UiPathRuntimeError: If reading fails or job failed
+        """
+        return await self._reader.read_trigger(trigger)
diff --git a/packages/uipath-platform/src/uipath/platform/semantic_proxy/__init__.py b/packages/uipath-platform/src/uipath/platform/semantic_proxy/__init__.py
new file mode 100644
index 000000000..e17867ac7
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/semantic_proxy/__init__.py
@@ -0,0 +1,36 @@
+"""SemanticProxy service package.
+
+Provides the ``SemanticProxyService`` client, Pydantic request/response models for
+the PII detection endpoint, and utilities for rehydrating masked text with
+original PII values after LLM processing.
+"""
+
+from ._semantic_proxy_service import SemanticProxyService
+from .pii_utilities import (
+    rehydrate_from_pii_entities,
+    rehydrate_from_pii_response,
+)
+from .semantic_proxy import (
+    PiiDetectionRequest,
+    PiiDetectionResponse,
+    PiiDocument,
+    PiiDocumentResult,
+    PiiEntity,
+    PiiEntityThreshold,
+    PiiFile,
+    PiiFileResult,
+)
+
+__all__ = [
+    "PiiDetectionRequest",
+    "PiiDetectionResponse",
+    "PiiDocument",
+    "PiiDocumentResult",
+    "PiiEntity",
+    "PiiEntityThreshold",
+    "PiiFile",
+    "PiiFileResult",
+    "SemanticProxyService",
+    "rehydrate_from_pii_entities",
+    "rehydrate_from_pii_response",
+]
diff --git a/packages/uipath-platform/src/uipath/platform/semantic_proxy/_semantic_proxy_service.py b/packages/uipath-platform/src/uipath/platform/semantic_proxy/_semantic_proxy_service.py
new file mode 100644
index 000000000..a68d7c25c
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/semantic_proxy/_semantic_proxy_service.py
@@ -0,0 +1,74 @@
+"""SemanticProxy service for UiPath Platform.
+
+Provides methods for interacting with the SemanticProxy service (e.g. PII detection).
+"""
+
+from uipath.core.tracing import traced
+
+from ..common._base_service import BaseService
+from ..common._config import UiPathApiConfig
+from ..common._execution_context import UiPathExecutionContext
+from ..common._models import Endpoint, RequestSpec
+from .semantic_proxy import PiiDetectionRequest, PiiDetectionResponse
+
+_PII_DETECTION_ENDPOINT = Endpoint("semanticproxy_/api/pii-detection")
+
+
+class SemanticProxyService(BaseService):
+    """Service for interacting with UiPath SemanticProxy."""
+
+    def __init__(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="semantic_proxy_detect_pii", run_type="uipath")
+    def detect_pii(self, request: PiiDetectionRequest) -> PiiDetectionResponse:
+        """Detect PII in the provided documents and/or files.
+
+        Args:
+            request: The PII detection request payload.
+
+        Returns:
+            The PII detection response.
+        """
+        spec = self._pii_detection_spec(request)
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="tenant",
+        )
+        return PiiDetectionResponse.model_validate(response.json())
+
+    @traced(name="semantic_proxy_detect_pii", run_type="uipath")
+    async def detect_pii_async(
+        self, request: PiiDetectionRequest
+    ) -> PiiDetectionResponse:
+        """Detect PII in the provided documents and/or files (async).
+
+        Args:
+            request: The PII detection request payload.
+
+        Returns:
+            The PII detection response.
+        """
+        spec = self._pii_detection_spec(request)
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="tenant",
+        )
+        return PiiDetectionResponse.model_validate(response.json())
+
+    def _pii_detection_spec(self, request: PiiDetectionRequest) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=_PII_DETECTION_ENDPOINT,
+            json=request.model_dump(by_alias=True, exclude_none=True),
+        )
diff --git a/packages/uipath-platform/src/uipath/platform/semantic_proxy/pii_utilities.py b/packages/uipath-platform/src/uipath/platform/semantic_proxy/pii_utilities.py
new file mode 100644
index 000000000..0f031a19a
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/semantic_proxy/pii_utilities.py
@@ -0,0 +1,98 @@
+"""Utility methods for working with PII data.
+
+Python port of UiPath.SemanticProxy.Client.PiiUtilities (C#).
+"""
+
+import re
+from typing import Callable, Iterable
+
+from .semantic_proxy import PiiDetectionResponse, PiiEntity
+
+
+def rehydrate_from_pii_entities(
+    masked_text: str, pii_entities: Iterable[PiiEntity]
+) -> str:
+    """Rehydrate masked text by replacing PII placeholders with original values.
+
+    Placeholders (e.g. ``[Person-1]``) are matched case-insensitively and replaced
+    with the corresponding original PII text. The function also replaces variants
+    without the surrounding brackets (e.g. ``Person-1``) in case the LLM stripped
+    them in its output.
+
+    Args:
+        masked_text: The masked text with PII placeholders.
+        pii_entities: The PII entities containing the original values.
+
+    Returns:
+        The rehydrated text with original PII values.
+    """
+    if not masked_text:
+        return masked_text
+
+    entities = [e for e in pii_entities if e.replacement_text]
+    if not entities:
+        return masked_text
+
+    # Sort by replacement text length descending to avoid substring collisions
+    # (e.g. "[Person-10]" must be replaced before "[Person-1]").
+    entities.sort(key=lambda e: len(e.replacement_text), reverse=True)
+
+    rehydrated = masked_text
+    for entity in entities:
+        if not entity.replacement_text or not entity.pii_text:
+            continue
+        # Replace the full placeholder (with brackets) case-insensitively.
+        # ``_literal_replacer`` bypasses regex backreference interpretation in the
+        # replacement string.
+        rehydrated = re.sub(
+            re.escape(entity.replacement_text),
+            _literal_replacer(entity.pii_text),
+            rehydrated,
+            flags=re.IGNORECASE,
+        )
+        # Also replace the content without brackets (in case the LLM dropped them).
+        if entity.replacement_text.startswith("[") and entity.replacement_text.endswith(
+            "]"
+        ):
+            no_brackets = entity.replacement_text[1:-1]
+            rehydrated = re.sub(
+                re.escape(no_brackets),
+                _literal_replacer(entity.pii_text),
+                rehydrated,
+                flags=re.IGNORECASE,
+            )
+
+    return rehydrated
+
+
+def _literal_replacer(replacement: str) -> Callable[[re.Match[str]], str]:
+    """Return a replacement function that ignores regex backreference syntax."""
+
+    def replace(_match: re.Match[str]) -> str:
+        return replacement
+
+    return replace
+
+
+def rehydrate_from_pii_response(
+    masked_text: str, response: PiiDetectionResponse
+) -> str:
+    """Rehydrate masked text using all PII entities from a detection response.
+
+    Merges entities from both ``response.response`` (detected in documents/prompts)
+    and ``response.files`` (detected in files), so placeholders originating from
+    either source are rehydrated.
+
+    Args:
+        masked_text: The masked text with PII placeholders.
+        response: The PII detection response containing entities to rehydrate.
+
+    Returns:
+        The rehydrated text with original PII values.
+    """
+    entities: list[PiiEntity] = []
+    for doc in response.response:
+        entities.extend(doc.pii_entities)
+    for file in response.files:
+        entities.extend(file.pii_entities)
+    return rehydrate_from_pii_entities(masked_text, entities)
diff --git a/packages/uipath-platform/src/uipath/platform/semantic_proxy/semantic_proxy.py b/packages/uipath-platform/src/uipath/platform/semantic_proxy/semantic_proxy.py
new file mode 100644
index 000000000..2be35e975
--- /dev/null
+++ b/packages/uipath-platform/src/uipath/platform/semantic_proxy/semantic_proxy.py
@@ -0,0 +1,91 @@
+"""Public Pydantic models for the SemanticProxy service."""
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PiiDocument(BaseModel):
+    """A text document to scan for PII."""
+
+    id: str
+    role: str
+    document: str
+
+
+class PiiFile(BaseModel):
+    """A file reference to scan for PII."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    file_name: str = Field(alias="fileName")
+    file_url: str = Field(alias="fileUrl")
+    file_type: str = Field(alias="fileType")
+
+
+class PiiEntityThreshold(BaseModel):
+    """Per-entity confidence threshold override."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    category: str = Field(alias="pii-entity-category")
+    confidence_threshold: float = Field(alias="pii-entity-confidence-threshold")
+
+
+class PiiDetectionRequest(BaseModel):
+    """Request payload for the PII detection endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    documents: Optional[list[PiiDocument]] = None
+    files: Optional[list[PiiFile]] = None
+    language_code: Optional[str] = Field(default=None, alias="languageCode")
+    confidence_threshold: Optional[float] = Field(
+        default=None, alias="confidenceThreshold"
+    )
+    entity_thresholds: Optional[list[PiiEntityThreshold]] = Field(
+        default=None, alias="entityThresholds"
+    )
+
+
+class PiiEntity(BaseModel):
+    """A single detected PII entity."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    pii_text: str = Field(alias="piiText")
+    replacement_text: str = Field(alias="replacementText")
+    pii_type: str = Field(alias="piiType")
+    offset: int
+    confidence_score: float = Field(alias="confidenceScore")
+
+
+class PiiDocumentResult(BaseModel):
+    """PII detection result for a single document."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    role: str
+    masked_document: str = Field(alias="maskedDocument")
+    initial_document: str = Field(alias="initialDocument")
+    pii_entities: list[PiiEntity] = Field(default_factory=list, alias="piiEntities")
+
+
+class PiiFileResult(BaseModel):
+    """PII detection result for a single file (fileUrl is the redacted URL)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    file_name: str = Field(alias="fileName")
+    file_url: str = Field(alias="fileUrl")
+    pii_entities: list[PiiEntity] = Field(default_factory=list, alias="piiEntities")
+
+
+class PiiDetectionResponse(BaseModel):
+    """Response payload from the PII detection endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    response: list[PiiDocumentResult] = Field(default_factory=list)
+    files: list[PiiFileResult] = Field(default_factory=list)
diff --git a/packages/uipath-platform/tests/common/test_config_env_vars.py b/packages/uipath-platform/tests/common/test_config_env_vars.py
new file mode 100644
index 000000000..8ff7b636d
--- /dev/null
+++ b/packages/uipath-platform/tests/common/test_config_env_vars.py
@@ -0,0 +1,55 @@
+import pytest
+
+from uipath.platform.common._config import UiPathConfig
+
+
+@pytest.fixture(autouse=True)
+def _clear_env(monkeypatch):
+    for var in (
+        "UIPATH_PROJECT_ID",
+        "UIPATH_AGENT_ID",
+        "UIPATH_CLOUD_USER_ID",
+        "UIPATH_PROJECT_FILES_SOURCE",
+    ):
+        monkeypatch.delenv(var, raising=False)
+
+
+class TestProjectId:
+    def test_reads_env_var(self, monkeypatch):
+        monkeypatch.setenv("UIPATH_PROJECT_ID", "file-source-id")
+        assert UiPathConfig.project_id == "file-source-id"
+
+    def test_returns_none_when_unset(self):
+        assert UiPathConfig.project_id is None
+
+
+class TestAgentId:
+    def test_returns_explicit_agent_id_when_set(self, monkeypatch):
+        monkeypatch.setenv("UIPATH_PROJECT_ID", "debug-project-guid")
+        monkeypatch.setenv("UIPATH_AGENT_ID", "real-agent-id")
+        assert UiPathConfig.agent_id == "real-agent-id"
+
+    def test_falls_back_to_project_id_when_agent_id_unset(self, monkeypatch):
+        monkeypatch.setenv("UIPATH_PROJECT_ID", "cloud-project-id")
+        assert UiPathConfig.agent_id == "cloud-project-id"
+
+    def test_returns_none_when_neither_set(self):
+        assert UiPathConfig.agent_id is None
+
+
+class TestCloudUserId:
+    def test_returns_value_when_set(self, monkeypatch):
+        monkeypatch.setenv("UIPATH_CLOUD_USER_ID", "user-guid")
+        assert UiPathConfig.cloud_user_id == "user-guid"
+
+    def test_returns_none_when_unset(self):
+        assert UiPathConfig.cloud_user_id is None
+
+
+class TestProjectFilesSource:
+    def test_returns_value_when_set(self, monkeypatch):
+        monkeypatch.setenv("UIPATH_PROJECT_FILES_SOURCE", "Local")
+        assert UiPathConfig.project_files_source == "Local"
+
+    def test_returns_none_when_unset(self):
+        assert UiPathConfig.project_files_source is None
diff --git a/packages/uipath-platform/tests/common/test_job_context.py b/packages/uipath-platform/tests/common/test_job_context.py
new file mode 100644
index 000000000..6a4e1a97d
--- /dev/null
+++ b/packages/uipath-platform/tests/common/test_job_context.py
@@ -0,0 +1,22 @@
+import pytest
+
+from uipath.platform.common._job_context import header_job_key
+from uipath.platform.common.constants import ENV_JOB_KEY, HEADER_JOB_KEY
+
+
+def test_returns_header_when_env_var_set(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(ENV_JOB_KEY, "test-job-key")
+
+    assert header_job_key() == {HEADER_JOB_KEY: "test-job-key"}
+
+
+def test_returns_empty_when_env_var_unset(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv(ENV_JOB_KEY, raising=False)
+
+    assert header_job_key() == {}
+
+
+def test_returns_empty_when_env_var_blank(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(ENV_JOB_KEY, "")
+
+    assert header_job_key() == {}
diff --git a/packages/uipath-platform/tests/errors/test_enriched_exception.py b/packages/uipath-platform/tests/errors/test_enriched_exception.py
new file mode 100644
index 000000000..e41f41007
--- /dev/null
+++ b/packages/uipath-platform/tests/errors/test_enriched_exception.py
@@ -0,0 +1,292 @@
+import json
+
+import httpx
+
+from uipath.platform.errors import EnrichedException
+
+# URL patterns that route to specific extractors
+_ORCHESTRATOR_URL = "https://cloud.uipath.com/org/tenant/orchestrator_/api/v1"
+_LLM_URL = "https://cloud.uipath.com/org/tenant/orchestrator_/llm/chat"
+_AGENTHUB_URL = "https://cloud.uipath.com/org/tenant/agenthub_/api/v1"
+_APPS_URL = "https://cloud.uipath.com/org/tenant/apps_/api/v1"
+_ELEMENTS_URL = "https://cloud.uipath.com/org/tenant/elements_/api/v1"
+_LLMOPS_URL = "https://cloud.uipath.com/org/tenant/llmopstenant_/api/v1"
+_GENERIC_URL = "https://cloud.uipath.com/api/test"
+
+
+def _make_error(
+    status_code: int = 500,
+    body: str | bytes = b"",
+    content_type: str = "application/json",
+    url: str = _GENERIC_URL,
+    method: str = "POST",
+) -> httpx.HTTPStatusError:
+    if isinstance(body, str):
+        body = body.encode()
+    return httpx.HTTPStatusError(
+        message=f"Server error {status_code}",
+        request=httpx.Request(method, url),
+        response=httpx.Response(
+            status_code,
+            content=body,
+            headers={"content-type": content_type},
+        ),
+    )
+
+
+class TestBasicProperties:
+    def test_status_code(self):
+        exc = EnrichedException(_make_error(404))
+        assert exc.status_code == 404
+
+    def test_url(self):
+        exc = EnrichedException(
+            _make_error(url="https://cloud.uipath.com/org/tenant/api/v1")
+        )
+        assert exc.url == "https://cloud.uipath.com/org/tenant/api/v1"
+
+    def test_http_method(self):
+        exc = EnrichedException(_make_error(method="DELETE"))
+        assert exc.http_method == "DELETE"
+
+    def test_response_content_short(self):
+        exc = EnrichedException(_make_error(body=b'{"message":"oops"}'))
+        assert exc.response_content == '{"message":"oops"}'
+
+    def test_response_content_truncated(self):
+        long_body = "x" * 300
+        exc = EnrichedException(_make_error(body=long_body.encode()))
+        assert exc.response_content.endswith("... (truncated)")
+        assert len(exc.response_content) < 300
+
+    def test_str_contains_status_code(self):
+        exc = EnrichedException(_make_error(404))
+        assert "404" in str(exc)
+
+    def test_status_code_is_int(self):
+        exc = EnrichedException(_make_error(502))
+        assert isinstance(exc.status_code, int)
+
+
+class TestErrorInfo:
+    def test_none_for_empty_body(self):
+        exc = EnrichedException(_make_error(body=b""))
+        assert exc.error_info is None
+
+    def test_none_for_non_json(self):
+        exc = EnrichedException(_make_error(body=b"not json"))
+        assert exc.error_info is None
+
+    def test_cached(self):
+        body = json.dumps({"message": "test"})
+        exc = EnrichedException(_make_error(body=body))
+        first = exc.error_info
+        second = exc.error_info
+        assert first is second
+
+
+class TestGenericExtraction:
+    """Tests for the generic fallback extractor (no service prefix in URL)."""
+
+    def test_message_field(self):
+        body = json.dumps({"message": "some error"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "some error"
+
+    def test_error_as_string(self):
+        body = json.dumps({"error": "something went wrong"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "something went wrong"
+
+    def test_nested_error_message(self):
+        body = json.dumps({"error": {"message": "nested error"}})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "nested error"
+
+    def test_error_code_fields(self):
+        body = json.dumps({"errorCode": "ERR_001"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.error_code == "ERR_001"
+
+    def test_code_field(self):
+        body = json.dumps({"code": "ERR_002"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.error_code == "ERR_002"
+
+    def test_numeric_code_converted_to_str(self):
+        body = json.dumps({"errorCode": 1002})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.error_code == "1002"
+
+    def test_trace_id(self):
+        body = json.dumps({"traceId": "abc-123"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.trace_id == "abc-123"
+
+    def test_request_id(self):
+        body = json.dumps({"requestId": "req-456"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.trace_id == "req-456"
+
+    def test_no_known_fields_returns_none_message(self):
+        body = json.dumps({"unknown_field": "value"})
+        exc = EnrichedException(_make_error(body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.message is None
+
+
+class TestRfc7807Extraction:
+    """Tests for RFC 7807 content-type based extraction."""
+
+    def test_problem_json_content_type(self):
+        body = json.dumps(
+            {"detail": "Forbidden", "title": "Access Denied", "type": "AUTH_ERR"}
+        )
+        exc = EnrichedException(
+            _make_error(403, body=body, content_type="application/problem+json")
+        )
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Forbidden"
+        assert exc.error_info.error_code == "AUTH_ERR"
+
+    def test_structural_rfc7807_detection(self):
+        body = json.dumps(
+            {"detail": "Not found", "title": "Error", "status": 404, "type": "E1"}
+        )
+        exc = EnrichedException(_make_error(404, body=body))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Not found"
+        assert exc.error_info.error_code == "E1"
+
+
+class TestOrchestratorExtraction:
+    """Orchestrator uses generic extractor (message, errorCode, traceId)."""
+
+    def test_process_not_found(self):
+        body = json.dumps(
+            {
+                "message": "Process not found",
+                "errorCode": "1002",
+                "traceId": "abc-123",
+            }
+        )
+        exc = EnrichedException(_make_error(404, body=body, url=_ORCHESTRATOR_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Process not found"
+        assert exc.error_info.error_code == "1002"
+        assert exc.error_info.trace_id == "abc-123"
+
+
+class TestLlmGatewayExtraction:
+    """LLM Gateway has nested error objects and vendor passthrough."""
+
+    def test_nested_vendor_error(self):
+        body = json.dumps(
+            {
+                "error": {
+                    "code": "content_filter",
+                    "message": "Content was filtered by safety policy",
+                }
+            }
+        )
+        exc = EnrichedException(_make_error(400, body=body, url=_LLM_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Content was filtered by safety policy"
+        assert exc.error_info.error_code == "content_filter"
+
+    def test_top_level_with_nested(self):
+        body = json.dumps(
+            {
+                "message": "Model unavailable",
+                "errorCode": "LLM_ERR",
+                "error": {"message": "rate limit", "code": "429"},
+            }
+        )
+        exc = EnrichedException(_make_error(429, body=body, url=_LLM_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Model unavailable"
+        assert exc.error_info.error_code == "LLM_ERR"
+
+
+class TestAgentHubExtraction:
+    """AgentHub has nested problem objects."""
+
+    def test_nested_problem(self):
+        body = json.dumps({"problem": {"detail": "Agent not found", "type": "AH_404"}})
+        exc = EnrichedException(_make_error(404, body=body, url=_AGENTHUB_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Agent not found"
+        assert exc.error_info.error_code == "AH_404"
+
+
+class TestAppsExtraction:
+    """Apps prioritizes errorMessageV2 over message."""
+
+    def test_error_message_v2_priority(self):
+        body = json.dumps(
+            {"errorMessageV2": "Detailed error", "message": "Short error"}
+        )
+        exc = EnrichedException(_make_error(400, body=body, url=_APPS_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Detailed error"
+
+
+class TestElementsExtraction:
+    """Elements has vendor passthrough fields (providerMessage, providerErrorCode)."""
+
+    def test_provider_fields(self):
+        body = json.dumps(
+            {
+                "providerMessage": "Rate limit exceeded",
+                "providerErrorCode": "429",
+                "requestId": "req-123",
+            }
+        )
+        exc = EnrichedException(_make_error(429, body=body, url=_ELEMENTS_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Rate limit exceeded"
+        assert exc.error_info.error_code == "429"
+        assert exc.error_info.trace_id == "req-123"
+
+
+class TestLlmOpsExtraction:
+    """LLMOps uses errorMessage, code, requestId."""
+
+    def test_llmops_fields(self):
+        body = json.dumps(
+            {
+                "errorMessage": "Quota exceeded",
+                "code": "QUOTA_001",
+                "requestId": "req-789",
+            }
+        )
+        exc = EnrichedException(_make_error(429, body=body, url=_LLMOPS_URL))
+        assert exc.error_info is not None
+        assert exc.error_info.message == "Quota exceeded"
+        assert exc.error_info.error_code == "QUOTA_001"
+        assert exc.error_info.trace_id == "req-789"
+
+
+class TestRouterPriority:
+    """RFC 7807 content-type should override service-specific extractors."""
+
+    def test_rfc7807_content_type_beats_service_extractor(self):
+        body = json.dumps(
+            {"detail": "RFC detail", "type": "RFC_ERR", "errorMessageV2": "Apps msg"}
+        )
+        exc = EnrichedException(
+            _make_error(
+                400, body=body, url=_APPS_URL, content_type="application/problem+json"
+            )
+        )
+        assert exc.error_info is not None
+        assert exc.error_info.message == "RFC detail"
+        assert exc.error_info.error_code == "RFC_ERR"
diff --git a/packages/uipath-platform/tests/services/conftest.py b/packages/uipath-platform/tests/services/conftest.py
new file mode 100644
index 000000000..2d12e5556
--- /dev/null
+++ b/packages/uipath-platform/tests/services/conftest.py
@@ -0,0 +1,70 @@
+import importlib
+from pathlib import Path
+
+import pytest
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+
+
+@pytest.fixture
+def base_url() -> str:
+    return "https://test.uipath.com"
+
+
+@pytest.fixture
+def org() -> str:
+    return "/org"
+
+
+@pytest.fixture
+def tenant() -> str:
+    return "/tenant"
+
+
+@pytest.fixture
+def secret() -> str:
+    return "secret"
+
+
+@pytest.fixture
+def config(base_url: str, org: str, tenant: str, secret: str) -> UiPathApiConfig:
+    return UiPathApiConfig(base_url=f"{base_url}{org}{tenant}", secret=secret)
+
+
+@pytest.fixture
+def version(monkeypatch: pytest.MonkeyPatch) -> str:
+    test_version = "1.0.0"
+    monkeypatch.setattr(importlib.metadata, "version", lambda _: test_version)
+    return test_version
+
+
+@pytest.fixture
+def execution_context(monkeypatch: pytest.MonkeyPatch) -> UiPathExecutionContext:
+    monkeypatch.setenv("UIPATH_ROBOT_KEY", "test-robot-key")
+    return UiPathExecutionContext()
+
+
+@pytest.fixture
+def tests_data_path() -> Path:
+    return Path(__file__).resolve().parent / "tests_data"
+
+
+@pytest.fixture
+def jobs_service(config, execution_context):
+    from uipath.platform.orchestrator import JobsService
+
+    return JobsService(config, execution_context)
+
+
+@pytest.fixture
+def mock_env_vars(monkeypatch: pytest.MonkeyPatch) -> dict[str, str]:
+    """Fixture to provide mock environment variables and set them in os.environ."""
+    env_vars = {
+        "UIPATH_URL": "https://cloud.uipath.com/organization/tenant",
+        "UIPATH_TENANT_ID": "e150b32b-8815-4560-8243-055ffc9b7523",
+        "UIPATH_ORGANIZATION_ID": "62d19041-d1aa-454d-958d-1375329845dc",
+        "UIPATH_ACCESS_TOKEN": "mock_token",
+    }
+    for key, value in env_vars.items():
+        monkeypatch.setenv(key, value)
+    return env_vars
diff --git a/packages/uipath-platform/tests/services/test_actions_service.py b/packages/uipath-platform/tests/services/test_actions_service.py
new file mode 100644
index 000000000..ea5fe2c84
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_actions_service.py
@@ -0,0 +1,864 @@
+import json
+from typing import Any
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.action_center import Task
+from uipath.platform.action_center._tasks_service import TasksService
+from uipath.platform.action_center.tasks import TaskRecipient, TaskRecipientType
+from uipath.platform.common.constants import HEADER_USER_AGENT
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> TasksService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+
+    return TasksService(config=config, execution_context=execution_context)
+
+
+class TestTasksService:
+    def test_retrieve(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id",
+            status_code=200,
+            json={"id": 1, "title": "Test Action"},
+        )
+
+        action = service.retrieve(
+            action_key="test-id",
+            app_folder_path="test-folder",
+        )
+
+        assert isinstance(action, Task)
+        assert action.id == 1
+        assert action.title == "Test Action"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TasksService.retrieve/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id",
+            status_code=200,
+            json={"id": 1, "title": "Test Action"},
+        )
+
+        action = await service.retrieve_async(
+            action_key="test-id",
+            app_folder_path="test-folder",
+        )
+
+        assert isinstance(action, Task)
+        assert action.id == 1
+        assert action.title == "Test Action"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TasksService.retrieve_async/{version}"
+        )
+
+    def test_create_with_app_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
+            status_code=200,
+            json={"id": 1, "title": "Test Action"},
+        )
+
+        action = service.create(
+            title="Test Action",
+            app_key="test-app-key",
+            data={"test": "data"},
+        )
+
+        assert isinstance(action, Task)
+        assert action.id == 1
+        assert action.title == "Test Action"
+
+    def test_create_with_assignee(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}/apps_/default/api/v1/default/deployed-action-apps-schemas?search=test-app&filterByDeploymentTitle=true",
+            status_code=200,
+            json={
+                "deployed": [
+                    {
+                        "systemName": "test-app",
+                        "deploymentTitle": "test-app",
+                        "actionSchema": {
+                            "key": "test-key",
+                            "inputs": [],
+                            "outputs": [],
+                            "inOuts": [],
+                            "outcomes": [],
+                        },
+                        "deploymentFolder": {
+                            "fullyQualifiedName": "test-folder-path",
+                            "key": "test-folder-key",
+                        },
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
+            status_code=200,
+            json={"id": 1, "title": "Test Action"},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks",
+            status_code=200,
+            json={},
+        )
+
+        action = service.create(
+            title="Test Action",
+            app_name="test-app",
+            data={"test": "data"},
+            assignee="test@example.com",
+        )
+
+        assert isinstance(action, Task)
+        assert action.id == 1
+        assert action.title == "Test Action"
+
+
+def _mock_app_lookup_and_create(
+    httpx_mock: HTTPXMock,
+    base_url: str,
+    org: str,
+    tenant: str,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Common httpx mock setup for app lookup + task creation + assign."""
+    monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+    httpx_mock.add_response(
+        url=f"{base_url}{org}/apps_/default/api/v1/default/deployed-action-apps-schemas?search=test-app&filterByDeploymentTitle=true",
+        status_code=200,
+        json={
+            "deployed": [
+                {
+                    "systemName": "test-app",
+                    "deploymentTitle": "test-app",
+                    "actionSchema": {
+                        "key": "test-key",
+                        "inputs": [],
+                        "outputs": [],
+                        "inOuts": [],
+                        "outcomes": [],
+                    },
+                    "deploymentFolder": {
+                        "fullyQualifiedName": "test-folder-path",
+                        "key": "test-folder-key",
+                    },
+                }
+            ]
+        },
+    )
+    httpx_mock.add_response(
+        url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
+        status_code=200,
+        json={"id": 1, "title": "Test Action"},
+    )
+    httpx_mock.add_response(
+        url=f"{base_url}{org}{tenant}/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks",
+        status_code=200,
+        json={},
+    )
+
+
+def _assign_request_payload(httpx_mock: HTTPXMock) -> dict[str, Any]:
+    """Return the parsed JSON body of the last AssignTasks request captured by the mock."""
+    assign_request = next(
+        req
+        for req in reversed(httpx_mock.get_requests())
+        if "AssignTasks" in str(req.url)
+    )
+    return json.loads(assign_request.content)
+
+
+class TestAssignTaskSpec:
+    """Tests for the task-assignment payload built by `_assign_task_spec`."""
+
+    def test_assign_workload_recipient_uses_workload_criteria_with_group(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        _mock_app_lookup_and_create(httpx_mock, base_url, org, tenant, monkeypatch)
+
+        service.create(
+            title="Test Action",
+            app_name="test-app",
+            data={"x": 1},
+            recipient=TaskRecipient(
+                type=TaskRecipientType.WORKLOAD,
+                value="Support Team",
+                displayName="Support Team",
+            ),
+        )
+
+        payload = _assign_request_payload(httpx_mock)
+        assert payload == {
+            "taskAssignments": [
+                {
+                    "taskId": 1,
+                    "assignmentCriteria": "Workload",
+                    "assigneeNamesOrEmails": ["Support Team"],
+                }
+            ]
+        }
+
+    def test_assign_round_robin_recipient_uses_round_robin_criteria(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        _mock_app_lookup_and_create(httpx_mock, base_url, org, tenant, monkeypatch)
+
+        service.create(
+            title="Test Action",
+            app_name="test-app",
+            data={"x": 1},
+            recipient=TaskRecipient(
+                type=TaskRecipientType.ROUND_ROBIN,
+                value="Support Team",
+                displayName="Support Team",
+            ),
+        )
+
+        payload = _assign_request_payload(httpx_mock)
+        assert payload == {
+            "taskAssignments": [
+                {
+                    "taskId": 1,
+                    "assignmentCriteria": "RoundRobin",
+                    "assigneeNamesOrEmails": ["Support Team"],
+                }
+            ]
+        }
+
+    def test_assign_workload_with_multiple_emails_uses_values_list(
+        self,
+        httpx_mock: HTTPXMock,
+        service: TasksService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Custom-assignees path: Workload criteria with a list of emails."""
+        _mock_app_lookup_and_create(httpx_mock, base_url, org, tenant, monkeypatch)
+
+        service.create(
+            title="Test Action",
+            app_name="test-app",
+            data={"x": 1},
+            recipient=TaskRecipient(
+                type=TaskRecipientType.WORKLOAD,
+                value="alice@example.com",
+                values=["alice@example.com", "bob@example.com"],
+            ),
+        )
+
+        payload = _assign_request_payload(httpx_mock)
+        assert payload == {
+            "taskAssignments": [
+                {
+                    "taskId": 1,
+                    "assignmentCriteria": "Workload",
+                    "assigneeNamesOrEmails": [
+                        "alice@example.com",
+                        "bob@example.com",
+                    ],
+                }
+            ]
+        }
+
+
+def _make_deployed_app(
+    name: str,
+    folder_path: str,
+    folder_key: str,
+    system_name: str | None = None,
+) -> dict[str, Any]:
+    return {
+        "systemName": system_name or name,
+        "deploymentTitle": name,
+        "actionSchema": {
+            "key": f"{name}-schema-key",
+            "inputs": [],
+            "outputs": [],
+            "inOuts": [],
+            "outcomes": [],
+        },
+        "deploymentFolder": {
+            "fullyQualifiedName": folder_path,
+            "key": folder_key,
+        },
+    }
+
+
+class TestCreateFiltersByFolder:
+    """Tests for folder filtering when creating tasks via app_name lookup."""
+
+    def _make_tasks_service(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        folder_key: str | None = None,
+        folder_path: str | None = None,
+    ) -> TasksService:
+        if folder_key:
+            monkeypatch.setenv("UIPATH_FOLDER_KEY", folder_key)
+        if folder_path:
+            monkeypatch.setenv("UIPATH_FOLDER_PATH", folder_path)
+        return TasksService(config=config, execution_context=execution_context)
+
+    def _mock_app_schemas_response(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        app_name: str,
+        deployed_apps: list[dict[str, Any]],
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}/apps_/default/api/v1/default/deployed-action-apps-schemas?search={app_name}&filterByDeploymentTitle=true",
+            status_code=200,
+            json={"deployed": deployed_apps},
+        )
+
+    def _mock_create_task_response(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
+            status_code=200,
+            json={"id": 1, "title": "Test Action"},
+        )
+
+    def test_create_filters_by_app_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [
+                _make_deployed_app(
+                    "my-app", "folder-a", "key-a", system_name="my-app-a"
+                ),
+                _make_deployed_app(
+                    "my-app", "folder-b", "key-b", system_name="my-app-b"
+                ),
+            ],
+        )
+        self._mock_create_task_response(httpx_mock, base_url, org, tenant)
+
+        task = tasks_service.create(
+            title="Test",
+            app_name="my-app",
+            app_folder_key="key-b",
+            app_folder_path=None,
+        )
+
+        assert isinstance(task, Task)
+        create_request = [
+            r for r in httpx_mock.get_requests() if "CreateAppTask" in str(r.url)
+        ][0]
+        # systemName from the key-b deployment is used as appId in the request
+        assert b"my-app-b" in create_request.content
+
+    @pytest.mark.anyio
+    async def test_create_async_filters_by_app_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [
+                _make_deployed_app(
+                    "my-app", "folder-a", "key-a", system_name="my-app-a"
+                ),
+                _make_deployed_app(
+                    "my-app", "folder-b", "key-b", system_name="my-app-b"
+                ),
+            ],
+        )
+        self._mock_create_task_response(httpx_mock, base_url, org, tenant)
+
+        task = await tasks_service.create_async(
+            title="Test",
+            app_name="my-app",
+            app_folder_key="key-b",
+            app_folder_path=None,
+        )
+
+        assert isinstance(task, Task)
+        create_request = [
+            r for r in httpx_mock.get_requests() if "CreateAppTask" in str(r.url)
+        ][0]
+        # systemName from the key-b deployment is used as appId in the request
+        assert b"my-app-b" in create_request.content
+
+    def test_create_filters_by_app_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [
+                _make_deployed_app("my-app", "folder-a", "key-a"),
+                _make_deployed_app("my-app", "folder-b", "key-b"),
+            ],
+        )
+        self._mock_create_task_response(httpx_mock, base_url, org, tenant)
+
+        task = tasks_service.create(
+            title="Test",
+            app_name="my-app",
+            app_folder_path="folder-a",
+        )
+
+        assert isinstance(task, Task)
+
+    def test_create_falls_back_to_env_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(
+            config, execution_context, monkeypatch, folder_path="env-folder-path"
+        )
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [
+                _make_deployed_app("my-app", "folder-a", "key-a"),
+                _make_deployed_app(
+                    "my-app", "env-folder-path", "key-b", system_name="my-app-b"
+                ),
+            ],
+        )
+        self._mock_create_task_response(httpx_mock, base_url, org, tenant)
+
+        task = tasks_service.create(
+            title="Test",
+            app_name="my-app",
+        )
+
+        assert isinstance(task, Task)
+        create_request = [
+            r for r in httpx_mock.get_requests() if "CreateAppTask" in str(r.url)
+        ][0]
+        assert b"my-app-b" in create_request.content
+
+    def test_create_falls_back_to_env_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(
+            config, execution_context, monkeypatch, folder_key="env-key"
+        )
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [
+                _make_deployed_app("my-app", "folder-a", "key-a"),
+                _make_deployed_app("my-app", "folder-b", "env-key"),
+            ],
+        )
+        self._mock_create_task_response(httpx_mock, base_url, org, tenant)
+
+        task = tasks_service.create(
+            title="Test",
+            app_name="my-app",
+        )
+
+        assert isinstance(task, Task)
+
+    def test_create_raises_when_app_not_found_in_tenant(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(
+            config, execution_context, monkeypatch, folder_path="folder-a"
+        )
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [_make_deployed_app("other-app", "folder-a", "key-a")],
+        )
+
+        with pytest.raises(
+            Exception, match="'my-app' was not found in the current tenant"
+        ):
+            tasks_service.create(title="Test", app_name="my-app")
+
+    def test_create_raises_when_app_not_found_in_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [_make_deployed_app("my-app", "folder-a", "key-a")],
+        )
+
+        with pytest.raises(
+            Exception,
+            match="'my-app' was not found in folder with fully qualified name 'folder-b'",
+        ):
+            tasks_service.create(
+                title="Test", app_name="my-app", app_folder_path="folder-b"
+            )
+
+    def test_create_raises_when_app_not_found_in_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [_make_deployed_app("my-app", "folder-a", "key-a")],
+        )
+
+        with pytest.raises(
+            Exception,
+            match="'my-app' was not found in folder with identifier 'wrong-key'",
+        ):
+            tasks_service.create(
+                title="Test",
+                app_name="my-app",
+                app_folder_key="wrong-key",
+                app_folder_path=None,
+            )
+
+    def test_create_raises_when_no_folder_key_or_path_provided(
+        self,
+        httpx_mock: HTTPXMock,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+        monkeypatch: pytest.MonkeyPatch,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        tasks_service = self._make_tasks_service(config, execution_context, monkeypatch)
+        self._mock_app_schemas_response(
+            httpx_mock,
+            base_url,
+            org,
+            "my-app",
+            [_make_deployed_app("my-app", "folder-a", "key-a")],
+        )
+
+        with pytest.raises(
+            Exception, match="no folder key or folder path was provided"
+        ):
+            tasks_service.create(
+                title="Test",
+                app_name="my-app",
+                app_folder_path=None,
+            )
+
+
+# ---------------------------------------------------------------------------
+# QuickForm task tests
+# ---------------------------------------------------------------------------
+
+_QF_SCHEMA: dict[str, Any] = {
+    "id": "7ebef452-fee9-45df-8fc2-01f1d0248540",
+    "fields": [
+        {"id": "f1", "type": "text", "label": "F1", "direction": "input"},
+        {"id": "f2", "type": "text", "label": "F2", "direction": "output"},
+    ],
+    "outcomes": [
+        {"id": "approve", "name": "Approve", "type": "string", "isPrimary": True},
+    ],
+}
+_QF_DEFAULTS = {
+    "title": "QF task",
+    "task_schema_key": _QF_SCHEMA["id"],
+    "schema": _QF_SCHEMA,
+}
+_QF_CREATE_RESPONSE = {"id": 42, "title": _QF_DEFAULTS["title"]}
+
+
+@pytest.fixture
+def qf_create_url(base_url: str, org: str, tenant: str) -> str:
+    return f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/CreateTask"
+
+
+@pytest.fixture
+def qf_assign_url(base_url: str, org: str, tenant: str) -> str:
+    return (
+        f"{base_url}{org}{tenant}"
+        "/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks"
+    )
+
+
+def _posted_body(httpx_mock: HTTPXMock, url: str) -> dict[str, Any]:
+    for req in httpx_mock.get_requests():
+        if str(req.url) == url:
+            return json.loads(req.content)
+    raise AssertionError(f"no request was POSTed to {url}")
+
+
+@pytest.fixture
+def qf_runner(httpx_mock: HTTPXMock, service: TasksService, qf_create_url: str) -> Any:
+    """Factory: stub the QF endpoint, call create_quickform with overrides,
+    return (task, posted_body). One call per test eliminates setup duplication.
+    """
+    httpx_mock.add_response(
+        url=qf_create_url, status_code=200, json=_QF_CREATE_RESPONSE
+    )
+
+    def _run(**overrides: Any) -> tuple[Task, dict[str, Any]]:
+        task = service.create_quickform(**{**_QF_DEFAULTS, **overrides})
+        return task, _posted_body(httpx_mock, qf_create_url)
+
+    return _run
+
+
+@pytest.fixture
+def qf_runner_async(
+    httpx_mock: HTTPXMock, service: TasksService, qf_create_url: str
+) -> Any:
+    """Async variant of qf_runner."""
+    httpx_mock.add_response(
+        url=qf_create_url, status_code=200, json=_QF_CREATE_RESPONSE
+    )
+
+    async def _run(**overrides: Any) -> tuple[Task, dict[str, Any]]:
+        task = await service.create_quickform_async(**{**_QF_DEFAULTS, **overrides})
+        return task, _posted_body(httpx_mock, qf_create_url)
+
+    return _run
+
+
+def test_create_quickform_baseline_payload(qf_runner: Any) -> None:
+    task, body = qf_runner()
+    assert body == {
+        "type": 6,
+        "taskSchemaKey": _QF_DEFAULTS["task_schema_key"],
+        "schema": _QF_SCHEMA,
+        "title": _QF_DEFAULTS["title"],
+        "data": {},
+    }
+    assert isinstance(task, Task)
+    assert task.id == 42
+
+
+def test_create_quickform_data_passthrough(qf_runner: Any) -> None:
+    _, body = qf_runner(data={"x": 1})
+    assert body["data"] == {"x": 1}
+
+
+def test_create_quickform_includes_optional_fields_when_set(qf_runner: Any) -> None:
+    _, body = qf_runner(
+        priority="High",
+        labels=["a", "b"],
+        is_actionable_message_enabled=True,
+        actionable_message_metadata={"fieldSet": {}, "actionSet": {}},
+        creator_job_key="3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    )
+    assert body["priority"] == "High"
+    assert {tag["name"] for tag in body["tags"]} == {"a", "b"}
+    assert body["isActionableMessageEnabled"] is True
+    assert body["actionableMessageMetaData"] == {"fieldSet": {}, "actionSet": {}}
+    assert body["creatorJobKey"] == "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+
+
+def test_create_quickform_omits_optional_fields_when_unset(qf_runner: Any) -> None:
+    _, body = qf_runner()
+    for omitted in (
+        "creatorJobKey",
+        "priority",
+        "tags",
+        "isActionableMessageEnabled",
+        "actionableMessageMetaData",
+    ):
+        assert omitted not in body
+
+
+async def test_create_quickform_async_baseline_payload(qf_runner_async: Any) -> None:
+    task, body = await qf_runner_async()
+    assert body["type"] == 6
+    assert body["taskSchemaKey"] == _QF_DEFAULTS["task_schema_key"]
+    assert task.id == 42
+
+
+def test_create_quickform_with_assignee_triggers_assign_call(
+    httpx_mock: HTTPXMock, qf_runner: Any, qf_assign_url: str
+) -> None:
+    httpx_mock.add_response(url=qf_assign_url, status_code=200, json={})
+    qf_runner(assignee="user@example.com")
+    body = _posted_body(httpx_mock, qf_assign_url)
+    assert body["taskAssignments"][0]["UserNameOrEmail"] == "user@example.com"
+
+
+async def test_create_quickform_async_with_assignee_triggers_assign_call(
+    httpx_mock: HTTPXMock, qf_runner_async: Any, qf_assign_url: str
+) -> None:
+    httpx_mock.add_response(url=qf_assign_url, status_code=200, json={})
+    await qf_runner_async(assignee="user@example.com")
+    body = _posted_body(httpx_mock, qf_assign_url)
+    assert body["taskAssignments"][0]["UserNameOrEmail"] == "user@example.com"
diff --git a/tests/sdk/services/test_api_client.py b/packages/uipath-platform/tests/services/test_api_client.py
similarity index 89%
rename from tests/sdk/services/test_api_client.py
rename to packages/uipath-platform/tests/services/test_api_client.py
index 4107ea065..eac74fa3c 100644
--- a/tests/sdk/services/test_api_client.py
+++ b/packages/uipath-platform/tests/services/test_api_client.py
@@ -1,14 +1,15 @@
 import pytest
 from pytest_httpx import HTTPXMock
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.api_client import ApiClient
-from uipath._utils.constants import HEADER_USER_AGENT
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common._api_client import ApiClient
+from uipath.platform.common.constants import HEADER_USER_AGENT
 
 
 @pytest.fixture
-def service(config: Config, execution_context: ExecutionContext) -> ApiClient:
+def service(
+    config: UiPathApiConfig, execution_context: UiPathExecutionContext
+) -> ApiClient:
     return ApiClient(config=config, execution_context=execution_context)
 
 
diff --git a/packages/uipath-platform/tests/services/test_assets_service.py b/packages/uipath-platform/tests/services/test_assets_service.py
new file mode 100644
index 000000000..4b01ed210
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_assets_service.py
@@ -0,0 +1,939 @@
+from unittest.mock import Mock, patch
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_USER_AGENT
+from uipath.platform.common.paging import PagedResult
+from uipath.platform.orchestrator import Asset, UserAsset
+from uipath.platform.orchestrator._assets_service import AssetsService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> AssetsService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    return AssetsService(config=config, execution_context=execution_context)
+
+
+class TestAssetsService:
+    class TestRetrieveAsset:
+        def test_retrieve_robot_asset(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AssetsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            import json
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+                status_code=200,
+                json={"id": 1, "name": "Test Asset", "value": "test-value"},
+            )
+
+            asset = service.retrieve(name="Test Asset")
+
+            assert isinstance(asset, UserAsset)
+            assert asset.id == 1
+            assert asset.name == "Test Asset"
+            assert asset.value == "test-value"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "POST"
+            assert (
+                sent_request.url
+                == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+            )
+
+            # Verify default behavior includes supportsCredentialsProxyDisconnected=True
+            request_body = json.loads(sent_request.content)
+            assert request_body["assetName"] == "Test Asset"
+            assert request_body["supportsCredentialsProxyDisconnected"] is True
+            assert "robotKey" in request_body
+
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve/{version}"
+            )
+
+        def test_retrieve_robot_asset_with_connection_data(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AssetsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test retrieving a robot asset with external credential store connection data.
+
+            This tests that the CredentialsConnectionData model correctly parses
+            API responses with uppercase field names (Url, Body, BearerToken).
+            """
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+                status_code=200,
+                json={
+                    "Id": 1,
+                    "Name": "Test Credential",
+                    "ValueType": "Credential",
+                    "ConnectionData": {
+                        "Url": "https://credentialstore.example.com/api/credentials",
+                        "Body": '{"credentialId": "12345"}',
+                        "BearerToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+                    },
+                },
+            )
+
+            asset = service.retrieve(name="Test Credential")
+
+            assert isinstance(asset, UserAsset)
+            assert asset.id == 1
+            assert asset.name == "Test Credential"
+            assert asset.value_type == "Credential"
+
+            # Verify connection data is correctly parsed with uppercase aliases
+            assert asset.connection_data is not None
+            assert (
+                asset.connection_data.url
+                == "https://credentialstore.example.com/api/credentials"
+            )
+            assert asset.connection_data.body == '{"credentialId": "12345"}'
+            assert (
+                asset.connection_data.bearer_token
+                == "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+            )
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "POST"
+            assert HEADER_USER_AGENT in sent_request.headers
+
+        def test_retrieve_asset(
+            self,
+            httpx_mock: HTTPXMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+            config: UiPathApiConfig,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service = AssetsService(
+                config=config,
+                execution_context=UiPathExecutionContext(),
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Asset'&$top=1",
+                status_code=200,
+                json={
+                    "value": [
+                        {
+                            "key": "asset-key",
+                            "name": "Test Asset",
+                            "value": "test-value",
+                        }
+                    ]
+                },
+            )
+
+            asset = service.retrieve(name="Test Asset")
+
+            assert isinstance(asset, Asset)
+            assert asset.key == "asset-key"
+            assert asset.name == "Test Asset"
+            assert asset.value == "test-value"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert (
+                sent_request.url
+                == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?%24filter=Name+eq+%27Test+Asset%27&%24top=1"
+            )
+
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve/{version}"
+            )
+
+    class TestListAssets:
+        def test_list_assets(
+            self,
+            httpx_mock: HTTPXMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+            config: UiPathApiConfig,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service = AssetsService(
+                config=config,
+                execution_context=UiPathExecutionContext(),
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$skip=0&$top=100",
+                status_code=200,
+                json={
+                    "value": [
+                        {
+                            "Key": "asset-key-1",
+                            "Name": "Asset 1",
+                            "Value": "value-1",
+                            "ValueType": "Text",
+                        },
+                        {
+                            "Key": "asset-key-2",
+                            "Name": "Asset 2",
+                            "Value": "value-2",
+                            "ValueType": "Text",
+                        },
+                    ]
+                },
+            )
+
+            result = service.list()
+
+            assert isinstance(result, PagedResult)
+            assert len(result.items) == 2
+            assert all(isinstance(asset, Asset) for asset in result.items)
+            assert result.items[0].key == "asset-key-1"
+            assert result.items[0].name == "Asset 1"
+            assert result.items[1].key == "asset-key-2"
+            assert result.items[1].name == "Asset 2"
+            assert result.skip == 0
+            assert result.top == 100
+            assert result.has_more is False  # 2 items < 100 top
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.list/{version}"
+            )
+
+        def test_list_assets_with_filter_and_orderby(
+            self,
+            httpx_mock: HTTPXMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            config: UiPathApiConfig,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service = AssetsService(
+                config=config,
+                execution_context=UiPathExecutionContext(),
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$skip=0&$top=100&$filter=ValueType eq 'Text'&$orderby=Name asc",
+                status_code=200,
+                json={
+                    "value": [
+                        {
+                            "Key": "asset-key-1",
+                            "Name": "Text Asset",
+                            "ValueType": "Text",
+                        },
+                    ]
+                },
+            )
+
+            result = service.list(filter="ValueType eq 'Text'", orderby="Name asc")
+
+            assert len(result.items) == 1
+            assert result.items[0].name == "Text Asset"
+
+        @pytest.mark.anyio
+        async def test_list_assets_async(
+            self,
+            httpx_mock: HTTPXMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+            config: UiPathApiConfig,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service = AssetsService(
+                config=config,
+                execution_context=UiPathExecutionContext(),
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$skip=0&$top=100",
+                status_code=200,
+                json={
+                    "value": [
+                        {
+                            "Key": "asset-key-1",
+                            "Name": "Asset 1",
+                            "Value": "value-1",
+                        },
+                    ]
+                },
+            )
+
+            result = await service.list_async()
+
+            assert isinstance(result, PagedResult)
+            assert len(result.items) == 1
+            assert result.items[0].key == "asset-key-1"
+            assert result.items[0].name == "Asset 1"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.list_async/{version}"
+            )
+
+    def test_retrieve_credential(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "id": 1,
+                "name": "Test Credential",
+                "credential_username": "test-user",
+                "credential_password": "test-password",
+            },
+        )
+
+        credential = service.retrieve_credential(name="Test Credential")
+
+        assert credential == "test-password"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve_credential/{version}"
+        )
+
+    def test_retrieve_credential_no_robot_key_direct_access_disabled(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        config: UiPathApiConfig,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+        service = AssetsService(
+            config=config,
+            execution_context=UiPathExecutionContext(),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Credential'&$top=1",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "asset-key",
+                        "Name": "Test Credential",
+                        "ValueType": "Credential",
+                        "AllowDirectApiAccess": False,
+                    }
+                ]
+            },
+        )
+
+        with pytest.raises(ValueError):
+            service.retrieve_credential(name="Test Credential")
+
+    def test_retrieve_credential_no_robot_key_direct_access_enabled(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        config: UiPathApiConfig,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import json
+
+        monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+        service = AssetsService(
+            config=config,
+            execution_context=UiPathExecutionContext(),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Credential'&$top=1",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "asset-key",
+                        "Name": "Test Credential",
+                        "ValueType": "Credential",
+                        "AllowDirectApiAccess": True,
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "id": 1,
+                "name": "Test Credential",
+                "credential_username": "test-user",
+                "credential_password": "test-password",
+            },
+        )
+
+        credential = service.retrieve_credential(name="Test Credential")
+
+        assert credential == "test-password"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 2
+        credential_request = sent_requests[1]
+        assert credential_request.method == "POST"
+        request_body = json.loads(credential_request.content)
+        assert request_body["assetName"] == "Test Credential"
+        assert request_body["supportsCredentialsProxyDisconnected"] is True
+        assert "robotKey" not in request_body
+
+    async def test_retrieve_credential_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test asynchronously retrieving a credential asset."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "id": 1,
+                "name": "Test Credential",
+                "credential_username": "test-user",
+                "credential_password": "test-password",
+            },
+        )
+
+        credential = await service.retrieve_credential_async(name="Test Credential")
+
+        assert credential == "test-password"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve_credential_async/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_credential_async_no_robot_key_direct_access_disabled(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        config: UiPathApiConfig,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+        service = AssetsService(
+            config=config,
+            execution_context=UiPathExecutionContext(),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Credential'&$top=1",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "asset-key",
+                        "Name": "Test Credential",
+                        "ValueType": "Credential",
+                        "AllowDirectApiAccess": False,
+                    }
+                ]
+            },
+        )
+
+        with pytest.raises(ValueError):
+            await service.retrieve_credential_async(name="Test Credential")
+
+    @pytest.mark.anyio
+    async def test_retrieve_credential_async_no_robot_key_direct_access_enabled(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        config: UiPathApiConfig,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import json
+
+        monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+        service = AssetsService(
+            config=config,
+            execution_context=UiPathExecutionContext(),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Credential'&$top=1",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "asset-key",
+                        "Name": "Test Credential",
+                        "ValueType": "Credential",
+                        "AllowDirectApiAccess": True,
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "id": 1,
+                "name": "Test Credential",
+                "credential_username": "test-user",
+                "credential_password": "test-password",
+            },
+        )
+
+        credential = await service.retrieve_credential_async(name="Test Credential")
+
+        assert credential == "test-password"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 2
+        credential_request = sent_requests[1]
+        assert credential_request.method == "POST"
+        request_body = json.loads(credential_request.content)
+        assert request_body["assetName"] == "Test Credential"
+        assert request_body["supportsCredentialsProxyDisconnected"] is True
+        assert "robotKey" not in request_body
+
+    def test_retrieve_secret(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """retrieve_secret returns SecretValue for Secret-type assets."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "Test Secret",
+                "ValueType": "Secret",
+                "SecretValue": "super-secret-value",
+            },
+        )
+
+        secret = service.retrieve_secret(name="Test Secret")
+
+        assert secret == "super-secret-value"
+
+    async def test_retrieve_secret_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """retrieve_secret_async returns SecretValue for Secret-type assets."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "Test Secret",
+                "ValueType": "Secret",
+                "SecretValue": "super-secret-value",
+            },
+        )
+
+        secret = await service.retrieve_secret_async(name="Test Secret")
+
+        assert secret == "super-secret-value"
+
+    def test_retrieve_robot_asset_exposes_secret_value(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """`retrieve` must expose SecretValue on UserAsset for Secret-type assets."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "Test Secret",
+                "ValueType": "Secret",
+                "SecretValue": "super-secret-value",
+            },
+        )
+
+        asset = service.retrieve(name="Test Secret")
+
+        assert isinstance(asset, UserAsset)
+        assert asset.value_type == "Secret"
+        assert asset.secret_value == "super-secret-value"
+
+    async def test_retrieve_async_robot_asset_exposes_secret_value(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """`retrieve_async` must expose SecretValue on UserAsset for Secret-type assets."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "Test Secret",
+                "ValueType": "Secret",
+                "SecretValue": "super-secret-value",
+            },
+        )
+
+        asset = await service.retrieve_async(name="Test Secret")
+
+        assert isinstance(asset, UserAsset)
+        assert asset.value_type == "Secret"
+        assert asset.secret_value == "super-secret-value"
+
+    def test_update(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey",
+            status_code=200,
+            json={"id": 1, "name": "Test Asset", "value": "updated-value"},
+        )
+
+        asset = UserAsset(name="Test Asset", value="updated-value")
+        response = service.update(robot_asset=asset)
+
+        assert response == {"id": 1, "name": "Test Asset", "value": "updated-value"}
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.update/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_update_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AssetsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey",
+            status_code=200,
+            json={"id": 1, "name": "Test Asset", "value": "updated-value"},
+        )
+
+        asset = UserAsset(name="Test Asset", value="updated-value")
+        response = await service.update_async(robot_asset=asset)
+
+        assert response == {"id": 1, "name": "Test Asset", "value": "updated-value"}
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.update_async/{version}"
+        )
+
+    class TestRequestKwargs:
+        """Test that all methods pass the correct kwargs to request/request_async."""
+
+        def test_retrieve_passes_all_kwargs(
+            self, service: AssetsService, monkeypatch: pytest.MonkeyPatch
+        ) -> None:
+            """Test that retrieve passes all kwargs to request."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "value": [{"key": "test-key", "name": "Test", "value": "test-value"}]
+            }
+
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service._execution_context = UiPathExecutionContext()
+
+            with patch.object(
+                service, "request", return_value=mock_response
+            ) as mock_request:
+                service.retrieve(name="Test")
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "GET"
+
+        @pytest.mark.anyio
+        async def test_retrieve_async_passes_all_kwargs(
+            self, service: AssetsService, monkeypatch: pytest.MonkeyPatch
+        ) -> None:
+            """Test that retrieve_async passes all kwargs to request_async."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "value": [{"key": "test-key", "name": "Test", "value": "test-value"}]
+            }
+
+            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
+            service._execution_context = UiPathExecutionContext()
+
+            with patch.object(
+                service, "request_async", return_value=mock_response
+            ) as mock_request:
+                await service.retrieve_async(name="Test")
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "GET"
+
+        def test_retrieve_credential_passes_all_kwargs(
+            self, service: AssetsService
+        ) -> None:
+            """Test that retrieve_credential passes all kwargs to request."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": 1,
+                "name": "Test",
+                "credential_password": "secret",
+            }
+
+            with patch.object(
+                service, "request", return_value=mock_response
+            ) as mock_request:
+                service.retrieve_credential(name="Test")
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "POST"
+
+        @pytest.mark.anyio
+        async def test_retrieve_credential_async_passes_all_kwargs(
+            self, service: AssetsService
+        ) -> None:
+            """Test that retrieve_credential_async passes all kwargs to request_async."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": 1,
+                "name": "Test",
+                "credential_password": "secret",
+            }
+
+            with patch.object(
+                service, "request_async", return_value=mock_response
+            ) as mock_request:
+                await service.retrieve_credential_async(name="Test")
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "POST"
+
+        def test_update_passes_all_kwargs(self, service: AssetsService) -> None:
+            """Test that update passes all kwargs to request."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": 1,
+                "name": "Test",
+                "value": "updated",
+            }
+
+            asset = UserAsset(name="Test", value="updated")
+
+            with patch.object(
+                service, "request", return_value=mock_response
+            ) as mock_request:
+                service.update(robot_asset=asset)
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "POST"
+
+        @pytest.mark.anyio
+        async def test_update_async_passes_all_kwargs(
+            self, service: AssetsService
+        ) -> None:
+            """Test that update_async passes all kwargs to request_async."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": 1,
+                "name": "Test",
+                "value": "updated",
+            }
+
+            asset = UserAsset(name="Test", value="updated")
+
+            with patch.object(
+                service, "request_async", return_value=mock_response
+            ) as mock_request:
+                await service.update_async(robot_asset=asset)
+
+                mock_request.assert_called_once()
+                call_kwargs = mock_request.call_args
+
+                # Verify all expected kwargs are present
+                assert "url" in call_kwargs.kwargs
+                assert "params" in call_kwargs.kwargs
+                assert "json" in call_kwargs.kwargs
+                assert "content" in call_kwargs.kwargs
+                assert "headers" in call_kwargs.kwargs
+
+                # Verify positional arg (method)
+                assert call_kwargs.args[0] == "POST"
diff --git a/tests/sdk/services/test_attachments_service.py b/packages/uipath-platform/tests/services/test_attachments_service.py
similarity index 72%
rename from tests/sdk/services/test_attachments_service.py
rename to packages/uipath-platform/tests/services/test_attachments_service.py
index df7590058..dfde1a304 100644
--- a/tests/sdk/services/test_attachments_service.py
+++ b/packages/uipath-platform/tests/services/test_attachments_service.py
@@ -2,15 +2,16 @@
 import os
 import shutil
 import uuid
-from typing import TYPE_CHECKING, Any, Dict, Generator, Tuple
+from typing import TYPE_CHECKING, Any, Generator, Tuple
 
 import pytest
 from pytest_httpx import HTTPXMock
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.attachments_service import AttachmentsService
-from uipath._utils.constants import HEADER_USER_AGENT, TEMP_ATTACHMENTS_FOLDER
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.attachments import Attachment
+from uipath.platform.attachments.attachments import AttachmentMode
+from uipath.platform.common.constants import HEADER_USER_AGENT, TEMP_ATTACHMENTS_FOLDER
+from uipath.platform.orchestrator._attachments_service import AttachmentsService
 
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch
@@ -18,15 +19,15 @@
 
 @pytest.fixture
 def service(
-    config: Config,
-    execution_context: ExecutionContext,
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
     monkeypatch: "MonkeyPatch",
 ) -> AttachmentsService:
     """Fixture that provides a configured AttachmentsService instance for testing.
 
     Args:
         config: The Config fixture with test configuration settings.
-        execution_context: The ExecutionContext fixture with test execution context.
+        execution_context: The UiPathExecutionContext fixture with test execution context.
         monkeypatch: PyTest MonkeyPatch fixture for environment modification.
 
     Returns:
@@ -107,7 +108,7 @@ def local_attachment_file(
 
 
 @pytest.fixture
-def blob_uri_response() -> Dict[str, Any]:
+def blob_uri_response() -> dict[str, Any]:
     """Provides a mock response for blob access requests.
 
     Returns:
@@ -139,7 +140,7 @@ def test_upload_with_file_path(
         tenant: str,
         version: str,
         temp_file: Tuple[str, str, str],
-        blob_uri_response: Dict[str, Any],
+        blob_uri_response: dict[str, Any],
     ) -> None:
         """Test uploading an attachment from a file path.
 
@@ -215,7 +216,7 @@ def test_upload_with_content(
         org: str,
         tenant: str,
         version: str,
-        blob_uri_response: Dict[str, Any],
+        blob_uri_response: dict[str, Any],
     ) -> None:
         """Test uploading an attachment with in-memory content.
 
@@ -310,7 +311,7 @@ async def test_upload_async_with_content(
         base_url: str,
         org: str,
         tenant: str,
-        blob_uri_response: Dict[str, Any],
+        blob_uri_response: dict[str, Any],
     ) -> None:
         """Test asynchronously uploading an attachment with in-memory content.
 
@@ -376,7 +377,7 @@ def test_download(
         tenant: str,
         version: str,
         tmp_path: Any,
-        blob_uri_response: Dict[str, Any],
+        blob_uri_response: dict[str, Any],
     ) -> None:
         """Test downloading an attachment.
 
@@ -456,7 +457,7 @@ async def test_download_async(
         tenant: str,
         version: str,
         tmp_path: Any,
-        blob_uri_response: Dict[str, Any],
+        blob_uri_response: dict[str, Any],
     ) -> None:
         """Test asynchronously downloading an attachment.
 
@@ -889,3 +890,306 @@ async def test_delete_async_not_found_throws_exception(
             match=f"Attachment with key {attachment_id} not found in UiPath or local storage",
         ):
             await service.delete_async(key=attachment_id)
+
+    def test_open_read_mode(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AttachmentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        blob_uri_response: dict[str, Any],
+    ) -> None:
+        """Test opening an attachment in READ mode.
+
+        Args:
+            httpx_mock: HTTPXMock fixture for mocking HTTP requests.
+            service: AttachmentsService fixture.
+            base_url: Base URL fixture for the API endpoint.
+            org: Organization fixture for the API path.
+            tenant: Tenant fixture for the API path.
+            version: Version fixture for the user agent header.
+            blob_uri_response: Mock response fixture for blob operations.
+        """
+        # Arrange
+        attachment_key = uuid.UUID("12345678-1234-1234-1234-123456789012")
+        file_content = b"Test file content for reading"
+        attachment = Attachment(  # type: ignore[call-arg]
+            ID=attachment_key,
+            FullName="test_file.txt",
+            MimeType="text/plain",
+        )
+
+        # Mock the get attachment endpoint
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_key})",
+            method="GET",
+            status_code=200,
+            json=blob_uri_response,
+        )
+
+        # Mock the blob download
+        httpx_mock.add_response(
+            url=blob_uri_response["BlobFileAccess"]["Uri"],
+            method="GET",
+            status_code=200,
+            content=file_content,
+        )
+
+        # Act & Assert
+        with service.open(attachment=attachment, mode=AttachmentMode.READ) as (
+            resource,
+            response,
+        ):
+            assert resource.id == uuid.UUID(blob_uri_response["Id"])
+            assert response.status_code == 200
+            content = response.read()
+            assert content == file_content
+
+        # Verify the requests
+        requests = httpx_mock.get_requests()
+        assert requests is not None
+        assert len(requests) == 2
+
+        # Check the first request to get the attachment metadata
+        get_request = requests[0]
+        assert get_request is not None
+        assert get_request.method == "GET"
+        assert (
+            get_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_key})"
+        )
+        assert HEADER_USER_AGENT in get_request.headers
+
+        # Check the second request to stream the content
+        stream_request = requests[1]
+        assert stream_request is not None
+        assert stream_request.method == "GET"
+        assert stream_request.url == blob_uri_response["BlobFileAccess"]["Uri"]
+
+    def test_open_write_mode(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AttachmentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        blob_uri_response: dict[str, Any],
+    ) -> None:
+        """Test opening an attachment in WRITE mode.
+
+        Args:
+            httpx_mock: HTTPXMock fixture for mocking HTTP requests.
+            service: AttachmentsService fixture.
+            base_url: Base URL fixture for the API endpoint.
+            org: Organization fixture for the API path.
+            tenant: Tenant fixture for the API path.
+            version: Version fixture for the user agent header.
+            blob_uri_response: Mock response fixture for blob operations.
+        """
+        # Arrange
+        file_name = "test_write_file.txt"
+        file_content = b"Content to write"
+        attachment = Attachment(  # type: ignore[call-arg]
+            ID=uuid.uuid4(),
+            FullName=file_name,
+            MimeType="text/plain",
+        )
+
+        # Mock the create attachment endpoint
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments",
+            method="POST",
+            status_code=200,
+            json=blob_uri_response,
+        )
+
+        # Mock the blob upload
+        httpx_mock.add_response(
+            url=blob_uri_response["BlobFileAccess"]["Uri"],
+            method="PUT",
+            status_code=201,
+        )
+
+        # Act & Assert
+        with service.open(
+            attachment=attachment, mode=AttachmentMode.WRITE, content=file_content
+        ) as (resource, response):
+            assert resource.id == uuid.UUID(blob_uri_response["Id"])
+            assert response.status_code == 201
+
+        # Verify the requests
+        requests = httpx_mock.get_requests()
+        assert requests is not None
+        assert len(requests) == 2
+
+        # Check the first request to create the attachment
+        create_request = requests[0]
+        assert create_request is not None
+        assert create_request.method == "POST"
+        assert (
+            create_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments"
+        )
+        assert json.loads(create_request.content) == {"Name": file_name}
+        assert HEADER_USER_AGENT in create_request.headers
+
+        # Check the second request to upload the content
+        upload_request = requests[1]
+        assert upload_request is not None
+        assert upload_request.method == "PUT"
+        assert upload_request.url == blob_uri_response["BlobFileAccess"]["Uri"]
+
+    @pytest.mark.asyncio
+    async def test_open_async_read_mode(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AttachmentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        blob_uri_response: dict[str, Any],
+    ) -> None:
+        """Test asynchronously opening an attachment in READ mode.
+
+        Args:
+            httpx_mock: HTTPXMock fixture for mocking HTTP requests.
+            service: AttachmentsService fixture.
+            base_url: Base URL fixture for the API endpoint.
+            org: Organization fixture for the API path.
+            tenant: Tenant fixture for the API path.
+            version: Version fixture for the user agent header.
+            blob_uri_response: Mock response fixture for blob operations.
+        """
+        # Arrange
+        attachment_key = uuid.UUID("12345678-1234-1234-1234-123456789012")
+        file_content = b"Test file content for async reading"
+        attachment = Attachment(  # type: ignore[call-arg]
+            ID=attachment_key,
+            FullName="test_file_async.txt",
+            MimeType="text/plain",
+        )
+
+        # Mock the get attachment endpoint
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_key})",
+            method="GET",
+            status_code=200,
+            json=blob_uri_response,
+        )
+
+        # Mock the blob download
+        httpx_mock.add_response(
+            url=blob_uri_response["BlobFileAccess"]["Uri"],
+            method="GET",
+            status_code=200,
+            content=file_content,
+        )
+
+        # Act & Assert
+        async with service.open_async(
+            attachment=attachment, mode=AttachmentMode.READ
+        ) as (resource, response):
+            assert resource.id == uuid.UUID(blob_uri_response["Id"])
+            assert response.status_code == 200
+            content = await response.aread()
+            assert content == file_content
+
+        # Verify the requests
+        requests = httpx_mock.get_requests()
+        assert requests is not None
+        assert len(requests) == 2
+
+        # Check the first request to get the attachment metadata
+        get_request = requests[0]
+        assert get_request is not None
+        assert get_request.method == "GET"
+        assert (
+            get_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_key})"
+        )
+        assert HEADER_USER_AGENT in get_request.headers
+
+        # Check the second request to stream the content
+        stream_request = requests[1]
+        assert stream_request is not None
+        assert stream_request.method == "GET"
+        assert stream_request.url == blob_uri_response["BlobFileAccess"]["Uri"]
+
+    @pytest.mark.asyncio
+    async def test_open_async_write_mode(
+        self,
+        httpx_mock: HTTPXMock,
+        service: AttachmentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        blob_uri_response: dict[str, Any],
+    ) -> None:
+        """Test asynchronously opening an attachment in WRITE mode.
+
+        Args:
+            httpx_mock: HTTPXMock fixture for mocking HTTP requests.
+            service: AttachmentsService fixture.
+            base_url: Base URL fixture for the API endpoint.
+            org: Organization fixture for the API path.
+            tenant: Tenant fixture for the API path.
+            version: Version fixture for the user agent header.
+            blob_uri_response: Mock response fixture for blob operations.
+        """
+        # Arrange
+        file_name = "test_write_file_async.txt"
+        file_content = b"Content to write async"
+        attachment = Attachment(  # type: ignore[call-arg]
+            ID=uuid.uuid4(),
+            FullName=file_name,
+            MimeType="text/plain",
+        )
+
+        # Mock the create attachment endpoint
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments",
+            method="POST",
+            status_code=200,
+            json=blob_uri_response,
+        )
+
+        # Mock the blob upload
+        httpx_mock.add_response(
+            url=blob_uri_response["BlobFileAccess"]["Uri"],
+            method="PUT",
+            status_code=201,
+        )
+
+        # Act & Assert
+        async with service.open_async(
+            attachment=attachment, mode=AttachmentMode.WRITE, content=file_content
+        ) as (resource, response):
+            assert resource.id == uuid.UUID(blob_uri_response["Id"])
+            assert response.status_code == 201
+
+        # Verify the requests
+        requests = httpx_mock.get_requests()
+        assert requests is not None
+        assert len(requests) == 2
+
+        # Check the first request to create the attachment
+        create_request = requests[0]
+        assert create_request is not None
+        assert create_request.method == "POST"
+        assert (
+            create_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments"
+        )
+        assert json.loads(create_request.content) == {"Name": file_name}
+        assert HEADER_USER_AGENT in create_request.headers
+
+        # Check the second request to upload the content
+        upload_request = requests[1]
+        assert upload_request is not None
+        assert upload_request.method == "PUT"
+        assert upload_request.url == blob_uri_response["BlobFileAccess"]["Uri"]
diff --git a/packages/uipath-platform/tests/services/test_automation_ops_service.py b/packages/uipath-platform/tests/services/test_automation_ops_service.py
new file mode 100644
index 000000000..e19a02a5a
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_automation_ops_service.py
@@ -0,0 +1,195 @@
+"""Tests for AutomationOpsService."""
+
+import json
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.automation_ops import AutomationOpsService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+) -> AutomationOpsService:
+    return AutomationOpsService(config=config, execution_context=execution_context)
+
+
+class TestAutomationOpsService:
+    """Test AutomationOpsService functionality."""
+
+    class TestGetDeployedPolicy:
+        """Test get_deployed_policy (sync)."""
+
+        def test_returns_policy_dict(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            expected_policy = {
+                "policy-name": "AITL Policy",
+                "data": {
+                    "container": {"pii-in-flight-agents": True},
+                    "pii-entity-table": [],
+                },
+            }
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                status_code=200,
+                json=expected_policy,
+            )
+
+            result = service.get_deployed_policy()
+
+            assert result == expected_policy
+
+        def test_returns_empty_dict_when_no_policy_deployed(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                status_code=200,
+                content=b"",
+            )
+
+            result = service.get_deployed_policy()
+
+            assert result == {}
+
+        def test_uses_post_method(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json={})
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                callback=capture,
+            )
+
+            service.get_deployed_policy()
+
+            assert captured_request is not None
+            assert captured_request.method == "POST"
+
+    class TestGetDeployedPolicyAsync:
+        """Test get_deployed_policy_async."""
+
+        async def test_returns_policy_dict(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            expected_policy = {
+                "policy-name": "AITL Policy",
+                "data": {
+                    "container": {"pii-in-flight-agents": False},
+                },
+            }
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                status_code=200,
+                json=expected_policy,
+            )
+
+            result = await service.get_deployed_policy_async()
+
+            assert result == expected_policy
+
+        async def test_returns_empty_dict_when_no_policy_deployed(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                status_code=200,
+                content=b"",
+            )
+
+            result = await service.get_deployed_policy_async()
+
+            assert result == {}
+
+        async def test_url_is_tenant_scoped(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json={})
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                callback=capture,
+            )
+
+            await service.get_deployed_policy_async()
+
+            assert captured_request is not None
+            # Tenant-scoped: both org and tenant segments appear in the path
+            assert org.strip("/") in captured_request.url.path
+            assert tenant.strip("/") in captured_request.url.path
+
+        async def test_request_has_no_body(
+            self,
+            httpx_mock: HTTPXMock,
+            service: AutomationOpsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json={})
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/agenthub_/api/policies/deployed-policy",
+                callback=capture,
+            )
+
+            await service.get_deployed_policy_async()
+
+            assert captured_request is not None
+            # POST with no body — body should be empty (or an empty JSON object)
+            body = captured_request.content
+            assert body in (b"", b"null") or json.loads(body) in ({}, None)
diff --git a/packages/uipath-platform/tests/services/test_azure_guardrail_validators.py b/packages/uipath-platform/tests/services/test_azure_guardrail_validators.py
new file mode 100644
index 000000000..fd6a3f39e
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_azure_guardrail_validators.py
@@ -0,0 +1,146 @@
+"""Tests for the Azure-provided guardrail validators.
+
+Covers HarmfulContentValidator, IntellectualPropertyValidator, and
+UserPromptAttacksValidator — verifying guardrail construction, parameter
+serialization, stage enforcement, and input validation.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from uipath.platform.guardrails.decorators import (
+    GuardrailExecutionStage,
+    HarmfulContentEntity,
+    HarmfulContentEntityType,
+    HarmfulContentValidator,
+    IntellectualPropertyEntityType,
+    IntellectualPropertyValidator,
+    UserPromptAttacksValidator,
+)
+
+# ---------------------------------------------------------------------------
+# HarmfulContentValidator
+# ---------------------------------------------------------------------------
+
+
+class TestHarmfulContentValidator:
+    """Tests for HarmfulContentValidator."""
+
+    def test_builds_guardrail(self):
+        """Verify get_built_in_guardrail returns correct structure."""
+        validator = HarmfulContentValidator(
+            entities=[
+                HarmfulContentEntity(HarmfulContentEntityType.VIOLENCE, threshold=3),
+                HarmfulContentEntity(HarmfulContentEntityType.HATE, threshold=4),
+            ]
+        )
+        guardrail = validator.get_built_in_guardrail(
+            name="Test HC",
+            description="test",
+            enabled_for_evals=True,
+        )
+        assert guardrail.validator_type == "harmful_content"
+        assert len(guardrail.validator_parameters) == 2
+
+        enum_param = guardrail.validator_parameters[0]
+        assert enum_param.id == "harmfulContentEntities"
+        assert enum_param.value == ["Violence", "Hate"]
+
+        map_param = guardrail.validator_parameters[1]
+        assert map_param.id == "harmfulContentEntityThresholds"
+        assert map_param.value == {"Violence": 3, "Hate": 4}
+
+    def test_empty_entities_raises(self):
+        """Empty entities should raise ValueError."""
+        with pytest.raises(ValueError, match="non-empty"):
+            HarmfulContentValidator(entities=[])
+
+    def test_threshold_validation(self):
+        """Threshold outside 0-6 should raise ValueError."""
+        with pytest.raises(ValueError, match="between 0 and 6"):
+            HarmfulContentEntity(HarmfulContentEntityType.VIOLENCE, threshold=7)
+        with pytest.raises(ValueError, match="between 0 and 6"):
+            HarmfulContentEntity(HarmfulContentEntityType.VIOLENCE, threshold=-1)
+
+    def test_all_stages_supported(self):
+        """supported_stages should be empty (all stages allowed)."""
+        validator = HarmfulContentValidator(
+            entities=[HarmfulContentEntity(HarmfulContentEntityType.VIOLENCE)]
+        )
+        assert validator.supported_stages == []
+        # Should not raise for any stage
+        validator.validate_stage(GuardrailExecutionStage.PRE)
+        validator.validate_stage(GuardrailExecutionStage.POST)
+
+
+# ---------------------------------------------------------------------------
+# IntellectualPropertyValidator
+# ---------------------------------------------------------------------------
+
+
+class TestIntellectualPropertyValidator:
+    """Tests for IntellectualPropertyValidator."""
+
+    def test_builds_guardrail(self):
+        """Verify get_built_in_guardrail returns correct structure."""
+        validator = IntellectualPropertyValidator(
+            entities=[
+                IntellectualPropertyEntityType.TEXT,
+                IntellectualPropertyEntityType.CODE,
+            ]
+        )
+        guardrail = validator.get_built_in_guardrail(
+            name="Test IP",
+            description=None,
+            enabled_for_evals=False,
+        )
+        assert guardrail.validator_type == "intellectual_property"
+        assert len(guardrail.validator_parameters) == 1
+
+        param = guardrail.validator_parameters[0]
+        assert param.id == "ipEntities"
+        assert param.value == ["Text", "Code"]
+
+    def test_empty_entities_raises(self):
+        """Empty entities should raise ValueError."""
+        with pytest.raises(ValueError, match="non-empty"):
+            IntellectualPropertyValidator(entities=[])
+
+    def test_post_only(self):
+        """Should only support POST stage."""
+        validator = IntellectualPropertyValidator(
+            entities=[IntellectualPropertyEntityType.TEXT]
+        )
+        assert validator.supported_stages == [GuardrailExecutionStage.POST]
+        validator.validate_stage(GuardrailExecutionStage.POST)
+        with pytest.raises(ValueError, match="does not support stage"):
+            validator.validate_stage(GuardrailExecutionStage.PRE)
+
+
+# ---------------------------------------------------------------------------
+# UserPromptAttacksValidator
+# ---------------------------------------------------------------------------
+
+
+class TestUserPromptAttacksValidator:
+    """Tests for UserPromptAttacksValidator."""
+
+    def test_builds_guardrail(self):
+        """Verify get_built_in_guardrail returns correct structure."""
+        validator = UserPromptAttacksValidator()
+        guardrail = validator.get_built_in_guardrail(
+            name="Test UPA",
+            description=None,
+            enabled_for_evals=True,
+        )
+        assert guardrail.validator_type == "user_prompt_attacks"
+        assert guardrail.validator_parameters == []
+
+    def test_pre_only(self):
+        """Should only support PRE stage."""
+        validator = UserPromptAttacksValidator()
+        assert validator.supported_stages == [GuardrailExecutionStage.PRE]
+        validator.validate_stage(GuardrailExecutionStage.PRE)
+        with pytest.raises(ValueError, match="does not support stage"):
+            validator.validate_stage(GuardrailExecutionStage.POST)
diff --git a/packages/uipath-platform/tests/services/test_base_service.py b/packages/uipath-platform/tests/services/test_base_service.py
new file mode 100644
index 000000000..bfe78fd18
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_base_service.py
@@ -0,0 +1,383 @@
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common._base_service import BaseService
+from uipath.platform.common.constants import HEADER_USER_AGENT
+from uipath.platform.errors import EnrichedException
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig, execution_context: UiPathExecutionContext
+) -> BaseService:
+    return BaseService(config=config, execution_context=execution_context)
+
+
+class TestBaseService:
+    def test_init_base_service(self, service: BaseService):
+        assert service is not None
+
+    def test_base_service_default_headers(self, service: BaseService, secret: str):
+        assert service.default_headers == {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {secret}",
+        }
+
+    class TestRequest:
+        def test_simple_request(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BaseService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+            secret: str,
+        ):
+            endpoint = "/endpoint"
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}{endpoint}",
+                status_code=200,
+                json={"test": "test"},
+            )
+
+            response = service.request("GET", endpoint)
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert sent_request.url == f"{base_url}{org}{tenant}{endpoint}"
+
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TestRequest.test_simple_request/{version}"
+            )
+            assert sent_request.headers["Authorization"] == f"Bearer {secret}"
+
+            assert response is not None
+            assert response.status_code == 200
+            assert response.json() == {"test": "test"}
+
+    class TestRequestAsync:
+        @pytest.mark.anyio
+        async def test_simple_request_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BaseService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+            secret: str,
+        ):
+            endpoint = "/endpoint"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}{endpoint}",
+                status_code=200,
+                json={"test": "test"},
+            )
+
+            response = await service.request_async("GET", endpoint)
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert sent_request.url == f"{base_url}{org}{tenant}{endpoint}"
+
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TestRequestAsync.test_simple_request_async/{version}"
+            )
+            assert sent_request.headers["Authorization"] == f"Bearer {secret}"
+
+            assert response is not None
+            assert response.status_code == 200
+            assert response.json() == {"test": "test"}
+
+
+class TestRetryBehavior:
+    """Integration tests for retry behavior in BaseService."""
+
+    def _url(self, base_url: str, org: str, tenant: str) -> str:
+        return f"{base_url}{org}{tenant}/endpoint"
+
+    def test_429_with_retry_after_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=429, headers={"retry-after": "0"})
+        httpx_mock.add_response(url=url, status_code=200, json={"ok": True})
+
+        response = service.request("GET", "/endpoint")
+        assert response.status_code == 200
+        assert len(httpx_mock.get_requests()) == 2
+
+    def test_503_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=503)
+        httpx_mock.add_response(url=url, status_code=200, json={"ok": True})
+
+        response = service.request("GET", "/endpoint")
+        assert response.status_code == 200
+        assert len(httpx_mock.get_requests()) == 2
+
+    def test_400_not_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=400)
+
+        with pytest.raises(EnrichedException) as exc_info:
+            service.request("GET", "/endpoint")
+        assert exc_info.value.status_code == 400
+        assert len(httpx_mock.get_requests()) == 1
+
+    def test_404_not_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=404)
+
+        with pytest.raises(EnrichedException) as exc_info:
+            service.request("GET", "/endpoint")
+        assert exc_info.value.status_code == 404
+        assert len(httpx_mock.get_requests()) == 1
+
+    def test_500_not_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=500)
+
+        with pytest.raises(EnrichedException) as exc_info:
+            service.request("GET", "/endpoint")
+        assert exc_info.value.status_code == 500
+        assert len(httpx_mock.get_requests()) == 1
+
+    def test_max_retries_exhausted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        for _ in range(5):
+            httpx_mock.add_response(
+                url=url, status_code=429, headers={"retry-after": "0"}
+            )
+
+        with pytest.raises(EnrichedException) as exc_info:
+            service.request("GET", "/endpoint")
+        assert exc_info.value.status_code == 429
+        assert len(httpx_mock.get_requests()) == 5
+
+    def test_502_retried(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=502)
+        httpx_mock.add_response(url=url, status_code=200, json={"ok": True})
+
+        response = service.request("GET", "/endpoint")
+        assert response.status_code == 200
+        assert len(httpx_mock.get_requests()) == 2
+
+    @pytest.mark.anyio
+    async def test_429_retried_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=429, headers={"retry-after": "0"})
+        httpx_mock.add_response(url=url, status_code=200, json={"ok": True})
+
+        response = await service.request_async("GET", "/endpoint")
+        assert response.status_code == 200
+        assert len(httpx_mock.get_requests()) == 2
+
+    @pytest.mark.anyio
+    async def test_503_retried_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=503)
+        httpx_mock.add_response(url=url, status_code=200, json={"ok": True})
+
+        response = await service.request_async("GET", "/endpoint")
+        assert response.status_code == 200
+        assert len(httpx_mock.get_requests()) == 2
+
+    @pytest.mark.anyio
+    async def test_400_not_retried_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        httpx_mock.add_response(url=url, status_code=400)
+
+        with pytest.raises(EnrichedException) as exc_info:
+            await service.request_async("GET", "/endpoint")
+        assert exc_info.value.status_code == 400
+        assert len(httpx_mock.get_requests()) == 1
+
+    @pytest.mark.anyio
+    async def test_max_retries_exhausted_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        url = self._url(base_url, org, tenant)
+        for _ in range(5):
+            httpx_mock.add_response(
+                url=url, status_code=429, headers={"retry-after": "0"}
+            )
+
+        with pytest.raises(EnrichedException) as exc_info:
+            await service.request_async("GET", "/endpoint")
+        assert exc_info.value.status_code == 429
+        assert len(httpx_mock.get_requests()) == 5
+
+
+class TestServiceUrlOverride:
+    def test_request_uses_override_url(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        monkeypatch: pytest.MonkeyPatch,
+        version: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "tenant-123")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "org-456")
+
+        httpx_mock.add_response(
+            url="http://localhost:5200/llm/api/chat/completions",
+            status_code=200,
+            json={"result": "ok"},
+        )
+
+        response = service.request("POST", "/agenthub_/llm/api/chat/completions")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert str(sent_request.url) == "http://localhost:5200/llm/api/chat/completions"
+        assert sent_request.headers["X-UiPath-Internal-TenantId"] == "tenant-123"
+        assert sent_request.headers["X-UiPath-Internal-AccountId"] == "org-456"
+        assert response.status_code == 200
+
+    def test_request_no_override_uses_normal_scoping(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.delenv("UIPATH_SERVICE_URL_ORCHESTRATOR", raising=False)
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=200,
+            json={"value": []},
+        )
+
+        response = service.request("GET", "/orchestrator_/odata/Buckets")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert (
+            str(sent_request.url)
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets"
+        )
+        assert response.status_code == 200
+
+
+class TestServiceUrlOverrideAsync:
+    @pytest.mark.anyio
+    async def test_request_async_uses_override_url(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BaseService,
+        monkeypatch: pytest.MonkeyPatch,
+        version: str,
+    ) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "tenant-123")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "org-456")
+
+        httpx_mock.add_response(
+            url="http://localhost:5200/llm/api/chat/completions",
+            status_code=200,
+            json={"result": "ok"},
+        )
+
+        response = await service.request_async(
+            "POST", "/agenthub_/llm/api/chat/completions"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert str(sent_request.url) == "http://localhost:5200/llm/api/chat/completions"
+        assert sent_request.headers["X-UiPath-Internal-TenantId"] == "tenant-123"
+        assert sent_request.headers["X-UiPath-Internal-AccountId"] == "org-456"
+        assert response.status_code == 200
diff --git a/packages/uipath-platform/tests/services/test_buckets_service.py b/packages/uipath-platform/tests/services/test_buckets_service.py
new file mode 100644
index 000000000..8cbb9f50c
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_buckets_service.py
@@ -0,0 +1,2023 @@
+import os
+from pathlib import Path
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.orchestrator._buckets_service import BucketsService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> BucketsService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    return BucketsService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def temp_file(tmp_path):
+    """Create a temporary file for testing."""
+    file_path = tmp_path / "test.txt"
+    file_path.write_text("test content")
+    return str(file_path)
+
+
+class TestBucketsService:
+    class TestRetrieve:
+        def test_retrieve_by_key(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ):
+            bucket_key = "bucket-key"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{bucket_key}')",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            bucket = service.retrieve(key=bucket_key)
+            assert bucket.id == 123
+            assert bucket.name == "test-bucket"
+            assert bucket.identifier == "bucket-key"
+
+        def test_retrieve_by_name(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ):
+            bucket_name = "test-bucket"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq '{bucket_name}'&$top=1",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            bucket = service.retrieve(name=bucket_name)
+            assert bucket.id == 123
+            assert bucket.name == "test-bucket"
+            assert bucket.identifier == "bucket-key"
+
+        @pytest.mark.asyncio
+        async def test_retrieve_by_key_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ):
+            bucket_key = "bucket-key"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{bucket_key}')",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            bucket = await service.retrieve_async(key=bucket_key)
+            assert bucket.id == 123
+            assert bucket.name == "test-bucket"
+            assert bucket.identifier == "bucket-key"
+
+        @pytest.mark.asyncio
+        async def test_retrieve_by_name_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ):
+            bucket_name = "test-bucket"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq '{bucket_name}'&$top=1",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            bucket = await service.retrieve_async(name=bucket_name)
+            assert bucket.id == 123
+            assert bucket.name == "test-bucket"
+            assert bucket.identifier == "bucket-key"
+
+    class TestDownload:
+        def test_download(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            tmp_path: Path,
+        ):
+            bucket_key = "bucket-key"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{bucket_key}')",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetReadUri?path=test-file.txt",
+                status_code=200,
+                json={
+                    "Uri": "https://test-storage.com/test-file.txt",
+                    "Headers": {"Keys": [], "Values": []},
+                    "RequiresAuth": False,
+                },
+            )
+
+            httpx_mock.add_response(
+                url="https://test-storage.com/test-file.txt",
+                status_code=200,
+                content=b"test content",
+            )
+
+            destination_path = str(tmp_path / "downloaded.txt")
+            service.download(
+                key=bucket_key,
+                blob_file_path="test-file.txt",
+                destination_path=destination_path,
+            )
+
+            assert os.path.exists(destination_path)
+            with open(destination_path, "rb") as f:
+                assert f.read() == b"test content"
+
+    class TestUpload:
+        def test_upload_from_path(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            temp_file: str,
+        ):
+            bucket_key = "bucket-key"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{bucket_key}')",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetWriteUri?path=test-file.txt&contentType=text/plain",
+                status_code=200,
+                json={
+                    "Uri": "https://test-storage.com/test-file.txt",
+                    "Headers": {"Keys": [], "Values": []},
+                    "RequiresAuth": False,
+                },
+            )
+
+            httpx_mock.add_response(
+                url="https://test-storage.com/test-file.txt",
+                status_code=200,
+                content=b"test content",
+            )
+
+            service.upload(
+                key=bucket_key,
+                blob_file_path="test-file.txt",
+                content_type="text/plain",
+                source_path=temp_file,
+            )
+
+            sent_requests = httpx_mock.get_requests()
+            assert len(sent_requests) == 3
+
+            assert sent_requests[2].method == "PUT"
+            assert sent_requests[2].url == "https://test-storage.com/test-file.txt"
+
+            assert b"test content" in sent_requests[2].content
+
+        def test_upload_from_memory(
+            self,
+            httpx_mock: HTTPXMock,
+            service: BucketsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ):
+            bucket_key = "bucket-key"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='{bucket_key}')",
+                status_code=200,
+                json={
+                    "value": [
+                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
+                    ]
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetWriteUri?path=test-file.txt&contentType=text/plain",
+                status_code=200,
+                json={
+                    "Uri": "https://test-storage.com/test-file.txt",
+                    "Headers": {"Keys": [], "Values": []},
+                    "RequiresAuth": False,
+                },
+            )
+
+            httpx_mock.add_response(
+                url="https://test-storage.com/test-file.txt",
+                status_code=200,
+                content=b"test content",
+            )
+
+            service.upload(
+                key=bucket_key,
+                blob_file_path="test-file.txt",
+                content_type="text/plain",
+                content="test content",
+            )
+
+            sent_requests = httpx_mock.get_requests()
+            assert len(sent_requests) == 3
+
+            assert sent_requests[2].method == "PUT"
+            assert sent_requests[2].url == "https://test-storage.com/test-file.txt"
+            assert sent_requests[2].content == b"test content"
+
+
+class TestList:
+    """Tests for list() method with auto-pagination."""
+
+    def test_list_all_buckets(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test listing buckets returns single page."""
+        # Mock single page (100 items)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={
+                "value": [
+                    {"Id": i, "Name": f"bucket-{i}", "Identifier": f"id-{i}"}
+                    for i in range(100)
+                ]
+            },
+        )
+
+        # Single page - no auto-pagination
+        buckets = list(service.list())
+        assert len(buckets) == 100
+        assert buckets[0].id == 0
+        assert buckets[99].id == 99
+
+    def test_list_with_name_filter(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test filtering by bucket name."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100&$filter=contains%28tolower%28Name%29%2C+tolower%28%27test%27%29%29",
+            status_code=200,
+            json={
+                "value": [
+                    {"Id": 1, "Name": "test-bucket", "Identifier": "id-1"},
+                    {"Id": 2, "Name": "another-test", "Identifier": "id-2"},
+                ]
+            },
+        )
+
+        buckets = list(service.list(name="test"))
+        assert len(buckets) == 2
+        assert buckets[0].name == "test-bucket"
+
+    def test_list_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test listing with folder context."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={"value": [{"Id": 1, "Name": "bucket-1", "Identifier": "id-1"}]},
+            match_headers={"x-uipath-folderpath": "Production"},
+        )
+
+        buckets = list(service.list(folder_path="Production"))
+        assert len(buckets) == 1
+
+    def test_list_empty_results(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test list() with no buckets."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={"value": []},
+        )
+
+        buckets = list(service.list())
+        assert len(buckets) == 0
+
+    def test_list_pagination_stops_on_partial_page(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test pagination stops when fewer items than page size."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={
+                "value": [
+                    {"Id": i, "Name": f"bucket-{i}", "Identifier": f"id-{i}"}
+                    for i in range(30)
+                ]
+            },
+        )
+
+        buckets = list(service.list())
+        assert len(buckets) == 30
+        # Verify only one request was made (no pagination)
+        assert len(httpx_mock.get_requests()) == 1
+
+    @pytest.mark.asyncio
+    async def test_list_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of list()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={
+                "value": [
+                    {"Id": i, "Name": f"bucket-{i}", "Identifier": f"id-{i}"}
+                    for i in range(10)
+                ]
+            },
+        )
+
+        buckets = []
+        for bucket in (await service.list_async()).items:
+            buckets.append(bucket)
+
+        assert len(buckets) == 10
+
+
+class TestExists:
+    """Tests for exists() method."""
+
+    def test_exists_bucket_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists() returns True when bucket found."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 1, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        assert service.exists("test-bucket") is True
+
+    def test_exists_bucket_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists() returns False for LookupError."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'nonexistent'&$top=1",
+            status_code=200,
+            json={"value": []},
+        )
+
+        assert service.exists("nonexistent") is False
+
+    def test_exists_propagates_network_errors(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists() propagates non-LookupError exceptions."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'error-bucket'&$top=1",
+            status_code=500,
+        )
+
+        # Should raise exception (not return False)
+        from uipath.platform.errors import EnrichedException
+
+        with pytest.raises(EnrichedException):
+            service.exists("error-bucket")
+
+    @pytest.mark.asyncio
+    async def test_exists_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of exists()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'async-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 1, "Name": "async-bucket", "Identifier": "id-1"}]},
+        )
+
+        result = await service.exists_async("async-bucket")
+        assert result is True
+
+
+class TestCreate:
+    """Tests for create() method."""
+
+    def test_create_with_auto_uuid(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test create() auto-generates UUID if not provided."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={"Id": 1, "Name": "new-bucket", "Identifier": "auto-uuid-123"},
+            match_content=None,  # We'll check the request separately
+        )
+
+        bucket = service.create("new-bucket")
+        assert bucket.id == 1
+        assert bucket.name == "new-bucket"
+
+        # Verify UUID was in request
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 1
+        import json
+
+        body = json.loads(requests[0].content)
+        assert "Identifier" in body
+        assert len(body["Identifier"]) > 0  # UUID generated
+
+    def test_create_with_explicit_uuid(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test create() uses provided UUID."""
+        custom_uuid = "custom-uuid-456"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={
+                "Id": 1,
+                "Name": "new-bucket",
+                "Identifier": custom_uuid,
+            },
+        )
+
+        bucket = service.create("new-bucket", identifier=custom_uuid)
+        assert bucket.identifier == custom_uuid
+
+        # Verify exact UUID in request
+        requests = httpx_mock.get_requests()
+        import json
+
+        body = json.loads(requests[0].content)
+        assert body["Identifier"] == custom_uuid
+
+    def test_create_with_description(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test create() includes description."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={
+                "Id": 1,
+                "Name": "new-bucket",
+                "Identifier": "id-1",
+                "Description": "Test description",
+            },
+        )
+
+        service.create("new-bucket", description="Test description")
+
+        # Verify Description field in request body
+        requests = httpx_mock.get_requests()
+        import json
+
+        body = json.loads(requests[0].content)
+        assert body["Description"] == "Test description"
+
+    def test_create_with_folder_context(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test create() with folder_path."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={"Id": 1, "Name": "new-bucket", "Identifier": "id-1"},
+            match_headers={"x-uipath-folderpath": "Production"},
+        )
+
+        bucket = service.create("new-bucket", folder_path="Production")
+        assert bucket.id == 1
+
+    def test_create_name_escaping(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test bucket names with special chars don't break creation."""
+        bucket_name = "Test's Bucket"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={"Id": 1, "Name": bucket_name, "Identifier": "id-1"},
+        )
+
+        bucket = service.create(bucket_name)
+        assert bucket.name == bucket_name
+
+    @pytest.mark.asyncio
+    async def test_create_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of create()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets",
+            status_code=201,
+            json={"Id": 1, "Name": "async-bucket", "Identifier": "id-1"},
+        )
+
+        bucket = await service.create_async("async-bucket")
+        assert bucket.id == 1
+
+
+class TestDelete:
+    """Tests for delete() / delete_async().
+
+    Regression coverage for UV-14977: delete() must build the folder header
+    from the folder_path/folder_key arguments (via header_folder), not solely
+    from the UIPATH_FOLDER_PATH / UIPATH_FOLDER_KEY env vars.
+    """
+
+    def test_delete_by_name_uses_folder_path_arg(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """delete(name=..., folder_path=...) sends the arg folder header on DELETE."""
+        # retrieve() locates the bucket in the target folder
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'old-storage'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 203380, "Name": "old-storage", "Identifier": "id"}]},
+            match_headers={"x-uipath-folderpath": "Playground"},
+        )
+        # the DELETE must carry the arg folder header (not the env-var fallback)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(203380)",
+            method="DELETE",
+            status_code=204,
+            match_headers={"x-uipath-folderpath": "Playground"},
+        )
+
+        service.delete(name="old-storage", folder_path="Playground")
+
+    def test_delete_by_key_uses_folder_key_arg(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """delete(key=..., folder_key=...) sends the arg folder-key header on DELETE."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='bucket-key')",
+            status_code=200,
+            json={"value": [{"Id": 55, "Name": "kbucket", "Identifier": "bucket-key"}]},
+            match_headers={"x-uipath-folderkey": "folder-123"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(55)",
+            method="DELETE",
+            status_code=204,
+            match_headers={"x-uipath-folderkey": "folder-123"},
+        )
+
+        service.delete(key="bucket-key", folder_key="folder-123")
+
+    @pytest.mark.asyncio
+    async def test_delete_async_uses_folder_path_arg(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Async version honors the folder_path argument on DELETE."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'old-storage'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 99, "Name": "old-storage", "Identifier": "id"}]},
+            match_headers={"x-uipath-folderpath": "Playground"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(99)",
+            method="DELETE",
+            status_code=204,
+            match_headers={"x-uipath-folderpath": "Playground"},
+        )
+
+        await service.delete_async(name="old-storage", folder_path="Playground")
+
+
+class TestEdgeCases:
+    """Tests for edge cases and error handling."""
+
+    def test_retrieve_with_quotes_in_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test bucket name with single quotes (OData escaping)."""
+        bucket_name = "Test's Bucket"
+        escaped_name = "Test''s Bucket"  # OData escaping
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq '{escaped_name}'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 1, "Name": bucket_name, "Identifier": "id-1"}]},
+        )
+
+        bucket = service.retrieve(name=bucket_name)
+        assert bucket.name == bucket_name
+
+    def test_retrieve_key_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test retrieve by key raises LookupError."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier='nonexistent')",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(LookupError, match="key 'nonexistent' not found"):
+            service.retrieve(key="nonexistent")
+
+    def test_retrieve_name_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test retrieve by name raises LookupError."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'nonexistent'&$top=1",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(LookupError, match="name 'nonexistent' not found"):
+            service.retrieve(name="nonexistent")
+
+    def test_list_handles_odata_collection_wrapper(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test list() handles OData 'value' array correctly."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=100",
+            status_code=200,
+            json={
+                "value": [{"Id": 1, "Name": "bucket-1", "Identifier": "id-1"}],
+                "@odata.context": "https://example.com/$metadata#Buckets",
+            },
+        )
+
+        buckets = list(service.list())
+        assert len(buckets) == 1
+        assert buckets[0].id == 1
+
+
+class TestListFiles:
+    """Tests for list_files() method (REST ListFiles API)."""
+
+    def test_list_files_basic(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test basic file listing with list_files()."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # Mock ListFiles response
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?takeHint=500",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/data/file1.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    },
+                    {
+                        "fullPath": "/data/file2.txt",
+                        "contentType": "text/plain",
+                        "size": 200,
+                        "lastModified": "2024-01-02T00:00:00Z",
+                    },
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = service.list_files(name="test-bucket")
+
+        files = result.items
+        token = result.continuation_token
+        assert token is None  # No more pages
+        assert len(files) == 2
+        assert files[0].path == "/data/file1.txt"
+        assert files[0].size == 100
+        assert files[1].path == "/data/file2.txt"
+        assert files[1].size == 200
+
+    def test_list_files_with_prefix(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test list_files() with prefix filter."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=data&takeHint=500",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/data/file1.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = service.list_files(name="test-bucket", prefix="data")
+
+        files = result.items
+        token = result.continuation_token
+        assert token is None
+        assert len(files) == 1
+        assert files[0].path == "/data/file1.txt"
+
+    def test_list_files_pagination(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test list_files() handles pagination with continuationToken."""
+        # Mock bucket retrieval (called twice - once for each page)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # First page
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?takeHint=500",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": f"/file{i}.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                    for i in range(500)
+                ],
+                "continuationToken": "page2token",
+            },
+        )
+
+        # Second page
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?continuationToken=page2token&takeHint=500",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": f"/file{i}.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                    for i in range(500, 550)
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        # Manual pagination
+        all_files = []
+        token = None
+
+        # First page
+        result = service.list_files(name="test-bucket", continuation_token=token)
+
+        files = result.items
+        token = result.continuation_token
+        assert len(files) == 500
+        assert token == "page2token"
+        all_files.extend(files)
+
+        # Second page
+        result = service.list_files(name="test-bucket", continuation_token=token)
+
+        files = result.items
+        token = result.continuation_token
+        assert len(files) == 50
+        assert token is None  # No more pages
+        all_files.extend(files)
+
+        assert len(all_files) == 550
+
+    def test_list_files_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test list_files() with empty bucket."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'empty-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 456, "Name": "empty-bucket", "Identifier": "id-2"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/456/ListFiles?takeHint=500",
+            status_code=200,
+            json={"items": [], "continuationToken": None},
+        )
+
+        result = service.list_files(name="empty-bucket")
+
+        files = result.items
+        token = result.continuation_token
+        assert token is None  # No more pages
+        assert len(files) == 0
+
+    @pytest.mark.asyncio
+    async def test_list_files_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of list_files()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?takeHint=500",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/async-file.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = await service.list_files_async(name="test-bucket")
+        files = result.items
+        token = result.continuation_token
+        assert token is None  # No more pages
+        assert len(files) == 1
+        assert files[0].path == "/async-file.txt"
+
+
+class TestGetFiles:
+    """Tests for get_files() method (OData GetFiles API)."""
+
+    def test_get_files_basic(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test basic file listing with get_files()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "file1.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    },
+                    {
+                        "FullPath": "file2.txt",
+                        "ContentType": "text/plain",
+                        "Size": 200,
+                        "IsDirectory": False,
+                    },
+                ]
+            },
+        )
+
+        files = list(service.get_files(name="test-bucket"))
+        assert len(files) == 2
+        assert files[0].path == "file1.txt"
+        assert files[0].size == 100
+        assert files[1].path == "file2.txt"
+        assert files[1].size == 200
+
+    def test_get_files_with_glob(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() with glob pattern."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&fileNameGlob=%2A.txt&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "file1.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    }
+                ]
+            },
+        )
+
+        files = list(service.get_files(name="test-bucket", file_name_glob="*.txt"))
+        assert len(files) == 1
+        assert files[0].path == "file1.txt"
+
+    def test_get_files_with_recursive(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() with recursive flag."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=docs&recursive=true&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "docs/file1.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    },
+                    {
+                        "FullPath": "docs/subdir/file2.txt",
+                        "ContentType": "text/plain",
+                        "Size": 200,
+                        "IsDirectory": False,
+                    },
+                ]
+            },
+        )
+
+        files = list(
+            service.get_files(name="test-bucket", prefix="docs", recursive=True)
+        )
+        assert len(files) == 2
+        assert files[1].path == "docs/subdir/file2.txt"
+
+    def test_get_files_filters_directories(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() filters out directories."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "file1.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    },
+                    {
+                        "FullPath": "folder1",
+                        "ContentType": None,
+                        "Size": 0,
+                        "IsDirectory": True,
+                    },
+                    {
+                        "FullPath": "file2.txt",
+                        "ContentType": "text/plain",
+                        "Size": 200,
+                        "IsDirectory": False,
+                    },
+                ]
+            },
+        )
+
+        files = list(service.get_files(name="test-bucket"))
+        # Should only get 2 files, directory should be filtered out
+        assert len(files) == 2
+        assert all(not f.is_directory for f in files)
+
+    def test_get_files_pagination(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() handles pagination with $skip and $top."""
+        # Mock bucket retrieval (called twice - once for each page)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # First page (full page of 500)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": f"file{i}.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    }
+                    for i in range(500)
+                ]
+            },
+        )
+
+        # Second page (partial page of 50)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24skip=500&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": f"file{i}.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    }
+                    for i in range(500, 550)
+                ]
+            },
+        )
+
+        # Manual pagination to get all files across both pages
+        all_files = []
+        skip = 0
+        while True:
+            result = service.get_files(name="test-bucket", skip=skip)
+            all_files.extend(result.items)
+            if not result.has_more:
+                break
+            skip += result.top
+
+        assert len(all_files) == 550
+
+    def test_get_files_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() with empty bucket."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'empty-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 456, "Name": "empty-bucket", "Identifier": "id-2"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(456)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={"value": []},
+        )
+
+        files = list(service.get_files(name="empty-bucket"))
+        assert len(files) == 0
+
+    def test_get_files_without_last_modified(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test get_files() handles missing lastModified field."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "file1.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                        # Note: No LastModified field (GetFiles doesn't provide it)
+                    }
+                ]
+            },
+        )
+
+        files = list(service.get_files(name="test-bucket"))
+        assert len(files) == 1
+        assert files[0].last_modified is None  # Should be None, not error
+
+    @pytest.mark.asyncio
+    async def test_get_files_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of get_files()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=500",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "FullPath": "async-file.txt",
+                        "ContentType": "text/plain",
+                        "Size": 100,
+                        "IsDirectory": False,
+                    }
+                ]
+            },
+        )
+
+        result = await service.get_files_async(name="test-bucket")
+        files = result.items
+        assert len(files) == 1
+        assert files[0].path == "async-file.txt"
+
+
+class TestExistsFile:
+    """Tests for exists_file() method."""
+
+    def test_exists_file_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() returns True when file is found."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # Mock ListFiles response with matching file (take_hint=1 for performance)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Fdata%2Ffile.txt&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/data/file.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = service.exists_file(name="test-bucket", blob_file_path="data/file.txt")
+        assert result is True
+
+    def test_exists_file_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() returns False when file is not found."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # Mock ListFiles response with no matching files
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Fnonexistent.txt&takeHint=1",
+            status_code=200,
+            json={"items": [], "continuationToken": None},
+        )
+
+        result = service.exists_file(
+            name="test-bucket", blob_file_path="nonexistent.txt"
+        )
+        assert result is False
+
+    def test_exists_file_bucket_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() raises LookupError when bucket doesn't exist."""
+        # Mock bucket retrieve returning empty (bucket not found)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'nonexistent-bucket'&$top=1",
+            status_code=200,
+            json={"value": []},
+        )
+
+        # Should raise LookupError, not return False
+        with pytest.raises(LookupError, match="Bucket.*not found"):
+            service.exists_file(
+                name="nonexistent-bucket", blob_file_path="some-file.txt"
+            )
+
+    def test_exists_file_short_circuit_on_match(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() stops iteration on first match (short-circuit)."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # Mock first page with matching file
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Ftarget.txt&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/target.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": "next-page-token",  # Has more pages
+            },
+        )
+
+        # Should not request second page since file was found on first page
+        result = service.exists_file(name="test-bucket", blob_file_path="target.txt")
+        assert result is True
+
+        # Verify only 2 requests were made (retrieve + first page)
+        # NOT 3 requests (which would include second page)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+    def test_exists_file_searches_across_pages(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() searches across multiple pages if needed."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # First page - no match
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Ftarget.txt&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/other-file.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": "page2",
+            },
+        )
+
+        # Second page - found
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Ftarget.txt&continuationToken=page2&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/target.txt",
+                        "contentType": "text/plain",
+                        "size": 200,
+                        "lastModified": "2024-01-02T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = service.exists_file(name="test-bucket", blob_file_path="target.txt")
+        assert result is True
+
+        # Should have made 3 requests (retrieve + page1 + page2)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 3
+
+    def test_exists_file_with_folder_context(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test exists_file() with folder_path parameter."""
+        # Mock bucket retrieve with folder path
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Ffile.txt&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/file.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = service.exists_file(
+            name="test-bucket", blob_file_path="file.txt", folder_path="Production"
+        )
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_exists_file_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version of exists_file()."""
+        # Mock bucket retrieve
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        # Mock ListFiles response
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Fasync-file.txt&takeHint=1",
+            status_code=200,
+            json={
+                "items": [
+                    {
+                        "fullPath": "/async-file.txt",
+                        "contentType": "text/plain",
+                        "size": 100,
+                        "lastModified": "2024-01-01T00:00:00Z",
+                    }
+                ],
+                "continuationToken": None,
+            },
+        )
+
+        result = await service.exists_file_async(
+            name="test-bucket", blob_file_path="async-file.txt"
+        )
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_exists_file_async_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BucketsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test async version returns False when file not found."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            status_code=200,
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/api/Buckets/123/ListFiles?prefix=%2Fmissing.txt&takeHint=1",
+            status_code=200,
+            json={"items": [], "continuationToken": None},
+        )
+
+        result = await service.exists_file_async(
+            name="test-bucket", blob_file_path="missing.txt"
+        )
+        assert result is False
+
+    def test_exists_file_empty_path_raises_error(self, service: BucketsService):
+        """Test exists_file() raises ValueError for empty blob_file_path."""
+        with pytest.raises(ValueError, match="blob_file_path cannot be empty"):
+            service.exists_file(name="test-bucket", blob_file_path="")
+
+    def test_exists_file_whitespace_path_raises_error(self, service: BucketsService):
+        """Test exists_file() raises ValueError for whitespace-only blob_file_path."""
+        with pytest.raises(ValueError, match="blob_file_path cannot be empty"):
+            service.exists_file(name="test-bucket", blob_file_path="   ")
+
+    @pytest.mark.asyncio
+    async def test_exists_file_async_empty_path_raises_error(
+        self, service: BucketsService
+    ):
+        """Test async version raises ValueError for empty blob_file_path."""
+        with pytest.raises(ValueError, match="blob_file_path cannot be empty"):
+            await service.exists_file_async(name="test-bucket", blob_file_path="")
+
+    @pytest.mark.asyncio
+    async def test_exists_file_async_whitespace_path_raises_error(
+        self, service: BucketsService
+    ):
+        """Test async version raises ValueError for whitespace-only blob_file_path."""
+        with pytest.raises(ValueError, match="blob_file_path cannot be empty"):
+            await service.exists_file_async(name="test-bucket", blob_file_path="  ")
+
+
+class TestTopParameterValidation:
+    """Test top parameter validation for methods using 'top' parameter."""
+
+    # -------------------- list() tests --------------------
+
+    def test_list_top_exceeds_maximum(self, service: BucketsService):
+        """Test that top > 1000 raises ValueError for list()."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000.*requested: 1001"):
+            service.list(top=1001)
+
+    def test_list_top_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 1000 is allowed for list()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=1000",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = service.list(top=1000)
+        assert result is not None
+        assert len(result.items) == 0
+
+    def test_list_top_below_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 999 is allowed for list()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=999",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = service.list(top=999)
+        assert result is not None
+
+    # -------------------- list_async() tests --------------------
+
+    @pytest.mark.asyncio
+    async def test_list_async_top_exceeds_maximum(self, service: BucketsService):
+        """Test that top > 1000 raises ValueError for list_async()."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000.*requested: 2000"):
+            await service.list_async(top=2000)
+
+    @pytest.mark.asyncio
+    async def test_list_async_top_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 1000 is allowed for list_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=1000",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = await service.list_async(top=1000)
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_list_async_top_below_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 999 is allowed for list_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=0&$top=999",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = await service.list_async(top=999)
+        assert result is not None
+
+    # -------------------- get_files() tests --------------------
+
+    def test_get_files_top_exceeds_maximum(self, service: BucketsService):
+        """Test that top > 1000 raises ValueError for get_files()."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000"):
+            service.get_files(name="test-bucket", top=1001)
+
+    def test_get_files_top_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 1000 is allowed for get_files()."""
+        # Mock bucket retrieval
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        # Mock file retrieval with GetFiles endpoint
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=1000",
+            json={"value": []},
+        )
+        result = service.get_files(name="test-bucket", top=1000)
+        assert result is not None
+
+    def test_get_files_top_below_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 999 is allowed for get_files()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=999",
+            json={"value": []},
+        )
+        result = service.get_files(name="test-bucket", top=999)
+        assert result is not None
+
+    # -------------------- get_files_async() tests --------------------
+
+    @pytest.mark.asyncio
+    async def test_get_files_async_top_exceeds_maximum(self, service: BucketsService):
+        """Test that top > 1000 raises ValueError for get_files_async()."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000"):
+            await service.get_files_async(name="test-bucket", top=1001)
+
+    @pytest.mark.asyncio
+    async def test_get_files_async_top_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 1000 is allowed for get_files_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=1000",
+            json={"value": []},
+        )
+        result = await service.get_files_async(name="test-bucket", top=1000)
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_get_files_async_top_below_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that top = 999 is allowed for get_files_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24top=999",
+            json={"value": []},
+        )
+        result = await service.get_files_async(name="test-bucket", top=999)
+        assert result is not None
+
+    # -------------------- skip parameter validation tests --------------------
+
+    def test_list_skip_exceeds_maximum(self, service: BucketsService):
+        """Test that skip > 10000 raises ValueError for list()."""
+        with pytest.raises(
+            ValueError, match=r"skip must be <= 10000.*requested: 10001"
+        ):
+            service.list(skip=10001)
+
+    def test_list_skip_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip = 10000 is allowed for list()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=10000&$top=100",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = service.list(skip=10000)
+        assert result is not None
+
+    def test_list_skip_below_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip = 9999 is allowed for list()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=9999&$top=100",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = service.list(skip=9999)
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_list_async_skip_exceeds_maximum(self, service: BucketsService):
+        """Test that skip > 10000 raises ValueError for list_async()."""
+        with pytest.raises(
+            ValueError, match=r"skip must be <= 10000.*requested: 20000"
+        ):
+            await service.list_async(skip=20000)
+
+    @pytest.mark.asyncio
+    async def test_list_async_skip_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip = 10000 is allowed for list_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=10000&$top=100",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = await service.list_async(skip=10000)
+        assert result is not None
+
+    def test_get_files_skip_exceeds_maximum(self, service: BucketsService):
+        """Test that skip > 10000 raises ValueError for get_files()."""
+        with pytest.raises(ValueError, match=r"skip must be <= 10000"):
+            service.get_files(name="test-bucket", skip=10001)
+
+    def test_get_files_skip_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip = 10000 is allowed for get_files()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24skip=10000&%24top=500",
+            json={"value": []},
+        )
+        result = service.get_files(name="test-bucket", skip=10000)
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_get_files_async_skip_exceeds_maximum(self, service: BucketsService):
+        """Test that skip > 10000 raises ValueError for get_files_async()."""
+        with pytest.raises(ValueError, match=r"skip must be <= 10000"):
+            await service.get_files_async(name="test-bucket", skip=10001)
+
+    @pytest.mark.asyncio
+    async def test_get_files_async_skip_at_maximum(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip = 10000 is allowed for get_files_async()."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq 'test-bucket'&$top=1",
+            json={"value": [{"Id": 123, "Name": "test-bucket", "Identifier": "id-1"}]},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetFiles?directory=%2F&%24skip=10000&%24top=500",
+            json={"value": []},
+        )
+        result = await service.get_files_async(name="test-bucket", skip=10000)
+        assert result is not None
+
+    def test_combined_max_skip_and_top(
+        self,
+        service: BucketsService,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ):
+        """Test that skip=10000 and top=1000 work together (combined boundary)."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$skip=10000&$top=1000",
+            json={"value": [], "@odata.count": 0},
+        )
+        result = service.list(skip=10000, top=1000)
+        assert result is not None
diff --git a/packages/uipath-platform/tests/services/test_connections_service.py b/packages/uipath-platform/tests/services/test_connections_service.py
new file mode 100644
index 000000000..27dec7310
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_connections_service.py
@@ -0,0 +1,2345 @@
+import json
+from unittest.mock import AsyncMock, MagicMock
+from urllib.parse import unquote_plus
+
+import pytest
+from pydantic import ValidationError
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common import jsonschema_to_pydantic
+from uipath.platform.common.constants import HEADER_FOLDER_KEY, HEADER_USER_AGENT
+from uipath.platform.connections import (
+    ActivityMetadata,
+    ActivityParameterLocationInfo,
+    Connection,
+    ConnectionMetadata,
+    ConnectionToken,
+    EventArguments,
+)
+from uipath.platform.connections._connections_service import (
+    HEADER_ACTIVITY_JOB_ID,
+    ConnectionsService,
+)
+from uipath.platform.orchestrator._folder_service import FolderService
+
+
+@pytest.fixture
+def mock_folders_service() -> MagicMock:
+    """Mock FolderService for testing."""
+    service = MagicMock(spec=FolderService)
+    service.retrieve_folder_key.return_value = "test-folder-key"
+    service.retrieve_folder_key_async = AsyncMock(return_value="test-folder-key")
+    return service
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    mock_folders_service: MagicMock,
+    monkeypatch: pytest.MonkeyPatch,
+) -> ConnectionsService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    return ConnectionsService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=mock_folders_service,
+    )
+
+
+class TestConnectionsService:
+    def test_retrieve(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        connection_key = "test-connection"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}",
+            status_code=200,
+            json={
+                "id": "test-id",
+                "name": "Test Connection",
+                "state": "active",
+                "elementInstanceId": 123,
+            },
+        )
+
+        connection = service.retrieve(key=connection_key)
+
+        assert isinstance(connection, Connection)
+        assert connection.id == "test-id"
+        assert connection.name == "Test Connection"
+        assert connection.state == "active"
+        assert connection.element_instance_id == 123
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve/{version}"
+        )
+
+    def test_metadata(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        element_instance_id = 123
+        connector_key = "test-connector"
+        tool_path = "test-tool"
+        valid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": "foo", "role": "user"},
+        }
+        invalid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": 123, "role": "user"},
+        }
+        valid_object = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        invalid_object_1 = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": "string",
+        }
+        invalid_object_2 = {
+            "choices": [invalid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        json_schema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "choices": {
+                    "title": "Choices",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/choices"},
+                },
+                "usage": {"title": "Usage", "$ref": "#/definitions/usage"},
+                "created": {
+                    "title": "Creation timestamp",
+                    "type": "integer",
+                    "format": "int64",
+                },
+            },
+            "definitions": {
+                "message": {
+                    "type": "object",
+                    "title": "Message",
+                    "properties": {
+                        "content": {
+                            "title": "Translated message content",
+                            "type": "string",
+                        },
+                        "role": {
+                            "title": "Role of the message sender",
+                            "type": "string",
+                        },
+                    },
+                },
+                "choices": {
+                    "type": "object",
+                    "title": "Choices",
+                    "properties": {
+                        "index": {
+                            "title": "Choice index",
+                            "type": "integer",
+                            "format": "int64",
+                        },
+                        "finish_reason": {
+                            "title": "Completion reason",
+                            "type": "string",
+                        },
+                        "message": {
+                            "title": "Message",
+                            "$ref": "#/definitions/message",
+                        },
+                    },
+                },
+                "usage": {
+                    "type": "object",
+                    "title": "Usage",
+                    "properties": {
+                        "total_tokens": {
+                            "title": "Total tokens used",
+                            "type": "integer",
+                            "format": "int64",
+                        }
+                    },
+                },
+            },
+        }
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            status_code=200,
+            json={
+                "fields": json_schema,
+            },
+        )
+
+        metadata = service.metadata(element_instance_id, connector_key, tool_path)
+
+        assert isinstance(metadata, ConnectionMetadata)
+        dynamic_type = jsonschema_to_pydantic(metadata.fields)
+
+        dynamic_type.model_validate(valid_object)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_1)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_2)
+        dynamic_type.model_json_schema()
+
+    @pytest.mark.anyio
+    async def test_retrieve_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        connection_key = "test-connection"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}",
+            status_code=200,
+            json={
+                "id": "test-id",
+                "name": "Test Connection",
+                "state": "active",
+                "elementInstanceId": 123,
+            },
+        )
+
+        connection = await service.retrieve_async(key=connection_key)
+
+        assert isinstance(connection, Connection)
+        assert connection.id == "test-id"
+        assert connection.name == "Test Connection"
+        assert connection.state == "active"
+        assert connection.element_instance_id == 123
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_async/{version}"
+        )
+
+    async def test_metadata_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        element_instance_id = 123
+        connector_key = "test-connector"
+        tool_path = "test-tool"
+        valid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": "foo", "role": "user"},
+        }
+        invalid_choice = {
+            "index": 0,
+            "finishReason": "done",
+            "message": {"content": 123, "role": "user"},
+        }
+        valid_object = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        invalid_object_1 = {
+            "choices": [valid_choice],
+            "usage": {"totalTokens": 100},
+            "created": "string",
+        }
+        invalid_object_2 = {
+            "choices": [invalid_choice],
+            "usage": {"totalTokens": 100},
+            "created": 1000,
+        }
+        json_schema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "choices": {
+                    "title": "Choices",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/choices"},
+                },
+                "usage": {"title": "Usage", "$ref": "#/definitions/usage"},
+                "created": {
+                    "title": "Creation timestamp",
+                    "type": "integer",
+                    "format": "int64",
+                },
+            },
+            "definitions": {
+                "message": {
+                    "type": "object",
+                    "title": "Message",
+                    "properties": {
+                        "content": {
+                            "title": "Translated message content",
+                            "type": "string",
+                        },
+                        "role": {
+                            "title": "Role of the message sender",
+                            "type": "string",
+                        },
+                    },
+                },
+                "choices": {
+                    "type": "object",
+                    "title": "Choices",
+                    "properties": {
+                        "index": {
+                            "title": "Choice index",
+                            "type": "integer",
+                            "format": "int64",
+                        },
+                        "finish_reason": {
+                            "title": "Completion reason",
+                            "type": "string",
+                        },
+                        "message": {
+                            "title": "Message",
+                            "$ref": "#/definitions/message",
+                        },
+                    },
+                },
+                "usage": {
+                    "type": "object",
+                    "title": "Usage",
+                    "properties": {
+                        "total_tokens": {
+                            "title": "Total tokens used",
+                            "type": "integer",
+                            "format": "int64",
+                        }
+                    },
+                },
+            },
+        }
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            status_code=200,
+            json={
+                "fields": json_schema,
+            },
+        )
+
+        metadata = await service.metadata_async(
+            element_instance_id, connector_key, tool_path
+        )
+
+        assert isinstance(metadata, ConnectionMetadata)
+        dynamic_type = jsonschema_to_pydantic(metadata.fields)
+
+        dynamic_type.model_validate(valid_object)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_1)
+        with pytest.raises(ValidationError):
+            assert dynamic_type.model_validate(invalid_object_2)
+        dynamic_type.model_json_schema()
+
+    def test_retrieve_token(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        connection_key = "test-connection"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?tokenType=direct",
+            status_code=200,
+            json={
+                "accessToken": "test-token",
+                "tokenType": "Bearer",
+                "expiresIn": 3600,
+            },
+        )
+
+        token = service.retrieve_token(key=connection_key)
+
+        assert isinstance(token, ConnectionToken)
+        assert token.access_token == "test-token"
+        assert token.token_type == "Bearer"
+        assert token.expires_in == 3600
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?tokenType=direct"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_token/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_token_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        connection_key = "test-connection"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?tokenType=direct",
+            status_code=200,
+            json={
+                "accessToken": "test-token",
+                "tokenType": "Bearer",
+                "expiresIn": 3600,
+            },
+        )
+
+        token = await service.retrieve_token_async(key=connection_key)
+
+        assert isinstance(token, ConnectionToken)
+        assert token.access_token == "test-token"
+        assert token.token_type == "Bearer"
+        assert token.expires_in == 3600
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?tokenType=direct"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_token_async/{version}"
+        )
+
+    def test_list_no_filters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method without any filters."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24expand=connector%2Cfolder",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "conn-1",
+                        "name": "Slack Connection",
+                        "state": "active",
+                        "elementInstanceId": 101,
+                    },
+                    {
+                        "id": "conn-2",
+                        "name": "Salesforce Connection",
+                        "state": "active",
+                        "elementInstanceId": 102,
+                    },
+                ]
+            },
+        )
+
+        connections = service.list()
+
+        assert isinstance(connections, list)
+        assert len(connections) == 2
+        assert connections[0].id == "conn-1"
+        assert connections[0].name == "Slack Connection"
+        assert connections[1].id == "conn-2"
+        assert connections[1].name == "Salesforce Connection"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        # Check for URL-encoded version
+        assert "%24expand=connector%2Cfolder" in str(sent_request.url)
+
+    def test_list_with_name_filter(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method with name filtering."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24filter=contains%28Name%2C%20%27Salesforce%27%29&%24expand=connector%2Cfolder",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "conn-2",
+                        "name": "Salesforce Connection",
+                        "state": "active",
+                        "elementInstanceId": 102,
+                    }
+                ]
+            },
+        )
+
+        connections = service.list(name="Salesforce")
+
+        assert len(connections) == 1
+        assert connections[0].name == "Salesforce Connection"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Decode URL-encoded characters (including + as space)
+        url_str = unquote_plus(str(sent_request.url))
+        assert "contains(Name, 'Salesforce')" in url_str
+
+    def test_list_with_folder_path_resolution(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        mock_folders_service: MagicMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method with folder path resolution."""
+        mock_folders_service.retrieve_folder_key.return_value = "folder-123"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24expand=connector%2Cfolder",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.list(folder_path="Finance/Production")
+
+        # Verify folder service was called
+        mock_folders_service.retrieve_folder_key.assert_called_once_with(
+            "Finance/Production"
+        )
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Verify the resolved key was used in headers
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "folder-123"
+
+    def test_list_with_connector_filter(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method with connector key filtering."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24filter=connector%2Fkey%20eq%20%27uipath-slack%27&%24expand=connector%2Cfolder",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "conn-1",
+                        "name": "Slack Connection",
+                        "state": "active",
+                        "elementInstanceId": 101,
+                    }
+                ]
+            },
+        )
+
+        connections = service.list(connector_key="uipath-slack")
+
+        assert len(connections) == 1
+        assert connections[0].name == "Slack Connection"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Decode URL-encoded characters (including + as space)
+        url_str = unquote_plus(str(sent_request.url))
+        assert "connector/key eq 'uipath-slack'" in url_str
+
+    def test_list_with_pagination(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method with pagination parameters."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24skip=10&%24top=5&%24expand=connector%2Cfolder",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.list(skip=10, top=5)
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert "%24skip=10" in str(sent_request.url)
+        assert "%24top=5" in str(sent_request.url)
+
+    def test_list_with_combined_filters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        mock_folders_service: MagicMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test list method with multiple filters combined."""
+        mock_folders_service.retrieve_folder_key.return_value = "folder-456"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24filter=contains%28Name%2C%20%27Slack%27%29%20and%20connector%2Fkey%20eq%20%27uipath-slack%27&%24expand=connector%2Cfolder",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.list(name="Slack", folder_path="Finance", connector_key="uipath-slack")
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Decode URL-encoded characters (including + as space)
+        url_str = unquote_plus(str(sent_request.url))
+        assert "contains(Name, 'Slack')" in url_str
+        assert "connector/key eq 'uipath-slack'" in url_str
+        assert " and " in url_str
+
+    @pytest.mark.anyio
+    async def test_list_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Test async version of list method."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24expand=connector%2Cfolder",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "conn-1",
+                        "name": "Test Connection",
+                        "state": "active",
+                        "elementInstanceId": 101,
+                    }
+                ]
+            },
+        )
+
+        connections = await service.list_async()
+
+        assert len(connections) == 1
+        assert connections[0].name == "Test Connection"
+
+    def test_retrieve_event_payload(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        event_id = "test-event-id"
+        additional_event_data = '{"processedEventId": "test-event-id"}'
+
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}",
+            status_code=200,
+            json={
+                "eventId": event_id,
+                "eventType": "test-event",
+                "data": {"key": "value"},
+                "timestamp": "2025-08-12T10:00:00Z",
+            },
+        )
+
+        payload = service.retrieve_event_payload(event_args=event_args)
+
+        assert payload["eventId"] == event_id
+        assert payload["eventType"] == "test-event"
+        assert payload["data"]["key"] == "value"
+        assert payload["timestamp"] == "2025-08-12T10:00:00Z"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_event_payload/{version}"
+        )
+
+    def test_retrieve_event_payload_with_raw_event_id(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        event_id = "test-raw-event-id"
+        additional_event_data = '{"rawEventId": "test-raw-event-id"}'
+
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}",
+            status_code=200,
+            json={
+                "eventId": event_id,
+                "eventType": "test-raw-event",
+                "data": {"rawKey": "rawValue"},
+            },
+        )
+
+        payload = service.retrieve_event_payload(event_args=event_args)
+
+        assert payload["eventId"] == event_id
+        assert payload["eventType"] == "test-raw-event"
+        assert payload["data"]["rawKey"] == "rawValue"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}"
+        )
+
+    def test_retrieve_event_payload_missing_additional_event_data(
+        self,
+        service: ConnectionsService,
+    ) -> None:
+        event_args = EventArguments(additional_event_data=None)
+
+        with pytest.raises(ValueError, match="additional_event_data is required"):
+            service.retrieve_event_payload(event_args=event_args)
+
+    def test_retrieve_event_payload_missing_event_id(
+        self,
+        service: ConnectionsService,
+    ) -> None:
+        additional_event_data = '{"someOtherField": "value"}'
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        with pytest.raises(
+            ValueError, match="Event Id not found in additional event data"
+        ):
+            service.retrieve_event_payload(event_args=event_args)
+
+    @pytest.mark.anyio
+    async def test_retrieve_event_payload_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        event_id = "test-event-id-async"
+        additional_event_data = '{"processedEventId": "test-event-id-async"}'
+
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}",
+            status_code=200,
+            json={
+                "eventId": event_id,
+                "eventType": "test-async-event",
+                "data": {"asyncKey": "asyncValue"},
+                "timestamp": "2025-08-12T11:00:00Z",
+            },
+        )
+
+        payload = await service.retrieve_event_payload_async(event_args=event_args)
+
+        assert payload["eventId"] == event_id
+        assert payload["eventType"] == "test-async-event"
+        assert payload["data"]["asyncKey"] == "asyncValue"
+        assert payload["timestamp"] == "2025-08-12T11:00:00Z"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}"
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_event_payload_async/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_event_payload_async_with_raw_event_id(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        event_id = "test-raw-event-id-async"
+        additional_event_data = '{"rawEventId": "test-raw-event-id-async"}'
+
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}",
+            status_code=200,
+            json={
+                "eventId": event_id,
+                "eventType": "test-async-raw-event",
+                "data": {"asyncRawKey": "asyncRawValue"},
+            },
+        )
+
+        payload = await service.retrieve_event_payload_async(event_args=event_args)
+
+        assert payload["eventId"] == event_id
+        assert payload["eventType"] == "test-async-raw-event"
+        assert payload["data"]["asyncRawKey"] == "asyncRawValue"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/elements_/v1/events/{event_id}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_event_payload_async_missing_additional_event_data(
+        self,
+        service: ConnectionsService,
+    ) -> None:
+        event_args = EventArguments(additional_event_data=None)
+
+        with pytest.raises(ValueError, match="additional_event_data is required"):
+            await service.retrieve_event_payload_async(event_args=event_args)
+
+    @pytest.mark.anyio
+    async def test_retrieve_event_payload_async_missing_event_id(
+        self,
+        service: ConnectionsService,
+    ) -> None:
+        additional_event_data = '{"someOtherField": "value"}'
+        event_args = EventArguments(additional_event_data=additional_event_data)
+
+        with pytest.raises(
+            ValueError, match="Event Id not found in additional event data"
+        ):
+            await service.retrieve_event_payload_async(event_args=event_args)
+
+    def test_list_with_name_containing_quote(
+        self, httpx_mock: HTTPXMock, service: ConnectionsService
+    ) -> None:
+        """Test that names with quotes are properly escaped."""
+        httpx_mock.add_response(json={"value": []})
+
+        service.list(name="O'Malley")
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Verify the single quote was doubled (escaped) in the OData filter
+        # The URL should contain O''Malley (with doubled single quote)
+        url_str = str(sent_request.url)
+        # Check that the filter contains the escaped quote
+        assert "O%27%27Malley" in url_str or "O''Malley" in url_str.replace(
+            "%27%27", "''"
+        )
+
+    def test_list_with_raw_list_response(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test that list method handles raw list responses (not wrapped in 'value')."""
+        # Some API endpoints return a raw list instead of OData format
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections?%24expand=connector%2Cfolder",
+            status_code=200,
+            json=[
+                {
+                    "id": "conn-1",
+                    "name": "Direct List Connection",
+                    "state": "active",
+                    "elementInstanceId": 101,
+                }
+            ],
+        )
+
+        connections = service.list()
+
+        assert isinstance(connections, list)
+        assert len(connections) == 1
+        assert connections[0].id == "conn-1"
+        assert connections[0].name == "Direct List Connection"
+
+    def test_get_jit_action_url_with_api_action(
+        self, service: ConnectionsService
+    ) -> None:
+        """Test _get_jit_action_url extracts URL from first API action."""
+        metadata = ConnectionMetadata(
+            fields={},
+            metadata={
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "reset",
+                                    "name": "Reset Form",
+                                },
+                                {
+                                    "actionType": "api",
+                                    "name": "Load Issue Types",
+                                    "apiConfiguration": {
+                                        "method": "GET",
+                                        "url": "elements/jira/projects/{project.id}/issuetypes",
+                                    },
+                                },
+                            ]
+                        }
+                    }
+                }
+            },
+        )
+
+        url = service._get_jit_action_url(metadata)
+
+        assert url == "elements/jira/projects/{project.id}/issuetypes"
+
+    def test_metadata_with_jit_parameters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() triggers JIT fetch when parameters are provided."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"project.id": "PROJ-123"}
+
+        # Mock initial metadata response
+        initial_response = {
+            "fields": {
+                "project.id": {"type": "string", "displayName": "Project ID"},
+                "summary": {"type": "string", "displayName": "Summary"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/issuetypes"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        # Mock JIT metadata response
+        jit_response = {
+            "fields": {
+                "CustomIssueType": {
+                    "type": "string",
+                    "displayName": "Custom Issue Type",
+                },
+            },
+        }
+
+        # Add mock responses
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=initial_response,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/projects/PROJ-123/issuetypes",
+            json=jit_response,
+        )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters
+        )
+
+        # Should return JIT metadata
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "CustomIssueType" in metadata.fields
+
+        # Verify both requests were made
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+    @pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+    async def test_metadata_with_max_jit_depth(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() stops at max JIT depth to prevent infinite loops."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"param": "value"}
+        max_jit_depth = 5
+
+        # Create a response that always has another action (infinite chain)
+        def create_response_with_action(level: int):
+            return {
+                "fields": {
+                    f"field_level_{level}": {
+                        "type": "string",
+                        "displayName": f"Field Level {level}",
+                    },
+                },
+                "metadata": {
+                    "method": {
+                        "POST": {
+                            "design": {
+                                "actions": [
+                                    {
+                                        "actionType": "api",
+                                        "apiConfiguration": {
+                                            "url": f"elements/jira/level{level + 1}"
+                                        },
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                },
+            }
+
+        # Add initial response
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=create_response_with_action(0),
+        )
+
+        # Add 10 more levels (more than max JIT depth) to test limit
+        for level in range(1, 11):
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/level{level}",
+                json=create_response_with_action(level),
+            )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters, max_jit_depth
+        )
+
+        # Should return metadata from level 5 (stopped at max JIT depth)
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "field_level_5" in metadata.fields
+
+        # Verify exactly 6 requests were made (initial + 5 JIT levels)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 6
+
+    def test_metadata_stops_on_repeated_url(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test metadata() stops early when action URL repeats."""
+        element_instance_id = 123
+        connector_key = "uipath-jira"
+        tool_path = "Issue"
+        parameters = {"project.id": "PROJ-123"}
+
+        # First response with action URL
+        level1_response = {
+            "fields": {
+                "field1": {"type": "string", "displayName": "Field 1"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/metadata"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        # Second response with the same action URL
+        level2_response = {
+            "fields": {
+                "field2": {"type": "string", "displayName": "Field 2"},
+            },
+            "metadata": {
+                "method": {
+                    "POST": {
+                        "design": {
+                            "actions": [
+                                {
+                                    "actionType": "api",
+                                    "apiConfiguration": {
+                                        "url": "elements/jira/projects/{project.id}/metadata"
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/{connector_key}/objects/{tool_path}/metadata",
+            json=level1_response,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/elements_/v3/element/instances/{element_instance_id}/elements/jira/projects/PROJ-123/metadata",
+            json=level2_response,
+        )
+
+        metadata = service.metadata(
+            element_instance_id, connector_key, tool_path, parameters
+        )
+
+        # Should return metadata from level 2 (stopped because next URL is same)
+        assert isinstance(metadata, ConnectionMetadata)
+        assert "field2" in metadata.fields
+
+        # Verify exactly 2 requests were made (initial + 1 JIT level, then stopped)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+
+@pytest.fixture
+def simple_activity_metadata() -> ActivityMetadata:
+    """Simple activity metadata for non-path tests."""
+    return ActivityMetadata(
+        object_path="/elements/test-connector/test-activity",
+        method_name="POST",
+        content_type="application/json",
+        parameter_location_info=ActivityParameterLocationInfo(
+            query_params=["query_param", "query_param2"],
+            header_params=["custom_header", "custom_header2"],
+            path_params=[],
+            multipart_params=[],
+            body_fields=["body_field1", "body_field2", "body_field3"],
+        ),
+    )
+
+
+@pytest.fixture
+def path_activity_metadata() -> ActivityMetadata:
+    """Sample activity metadata for testing with all parameter types."""
+    return ActivityMetadata(
+        object_path="/elements/test-connector/users/{userId}/posts/{postId}",
+        method_name="POST",
+        content_type="application/json",
+        parameter_location_info=ActivityParameterLocationInfo(
+            query_params=[],
+            header_params=[],
+            path_params=["userId", "postId"],
+            multipart_params=[],
+            body_fields=[],
+        ),
+    )
+
+
+@pytest.fixture
+def multipart_activity_metadata() -> ActivityMetadata:
+    """Sample multipart activity metadata for testing."""
+    return ActivityMetadata(
+        object_path="/elements/test-connector/upload",
+        method_name="POST",
+        content_type="multipart/form-data",
+        parameter_location_info=ActivityParameterLocationInfo(
+            query_params=[],
+            header_params=[],
+            path_params=[],
+            multipart_params=["file_param"],
+            body_fields=["description"],
+        ),
+        json_body_section="body",
+    )
+
+
+@pytest.fixture
+def multipart_custom_section_metadata() -> ActivityMetadata:
+    """Sample multipart activity metadata with custom json_body_section."""
+    return ActivityMetadata(
+        object_path="/elements/test-connector/rag",
+        method_name="POST",
+        content_type="multipart/form-data",
+        parameter_location_info=ActivityParameterLocationInfo(
+            query_params=[],
+            header_params=[],
+            path_params=[],
+            multipart_params=["file_param"],
+            body_fields=["prompt", "model"],
+        ),
+        json_body_section="RagRequest",
+    )
+
+
+class TestConnectorActivityInvocation:
+    def test_invoke_activity_with_query_params(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking with query parameters only."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "query_param": "test search query",
+            "query_param2": "additional query",
+        }
+        expected_response = {"results": [], "total": 0}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # Check query parameters
+        assert sent_request.url.params["query_param"] == "test search query"
+        assert sent_request.url.params["query_param2"] == "additional query"
+
+    def test_invoke_activity_with_header_params(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking with header parameters only."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "custom_header": "secret-api-key",
+            "custom_header2": "client-123",
+        }
+        expected_response = {"authenticated": True}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # Check custom headers
+        assert sent_request.headers["custom_header"] == "secret-api-key"
+        assert sent_request.headers["custom_header2"] == "client-123"
+
+    def test_invoke_activity_sets_standard_headers(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking sets standard headers correctly."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "body_field1": "Test Item",
+        }
+        expected_response = {"status": "success"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # Check standard headers
+        assert sent_request.headers["x-uipath-originator"] == "uipath-python"
+        assert sent_request.headers["x-uipath-source"] == "uipath-python"
+
+    def test_invoke_activity_propagates_job_id_header(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Activity invocations carry x-uipath-job-id so GenAI calls can be stitched for licensing."""
+        monkeypatch.setenv("UIPATH_JOB_KEY", "job-key-abc")
+        connection_id = "test-connection-123"
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={})
+
+        service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input={"body_field1": "x"},
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        assert sent_request.headers[HEADER_ACTIVITY_JOB_ID] == "job-key-abc"
+
+    def test_invoke_activity_omits_job_id_header_when_unset(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """No job-id header is sent when UIPATH_JOB_KEY is not set."""
+        monkeypatch.delenv("UIPATH_JOB_KEY", raising=False)
+        connection_id = "test-connection-123"
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={})
+
+        service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input={"body_field1": "x"},
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        assert HEADER_ACTIVITY_JOB_ID not in sent_request.headers
+
+    def test_invoke_activity_with_body_fields(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking with JSON body fields only."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "body_field1": "Test Item",
+            "body_field2": "This is a test item",
+            "body_field3": "high",
+        }
+        expected_response = {"id": 456, "status": "created"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # Check JSON body
+        request_json = json.loads(sent_request.content.decode())
+        assert request_json == {
+            "body_field1": "Test Item",
+            "body_field2": "This is a test item",
+            "body_field3": "high",
+        }
+
+    def test_invoke_activity_with_path_parameters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        path_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking with path parameters only."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "userId": "user456",
+            "postId": "post789",
+        }
+        expected_response = {"user": "user456", "post": "post789"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=path_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # Verify URL path substitution worked correctly
+        assert sent_request.url.path.endswith(
+            "/elements_/v3/element/instances/test-connection-123/elements/test-connector/users/user456/posts/post789"
+        )
+
+    def test_invoke_activity_multipart_request(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test invoking an Integration Service activity with multipart content."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": b"test file content",
+            "description": "Test file upload",
+        }
+        expected_response = {"upload_id": "upload123", "status": "success"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=multipart_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        assert "multipart/form-data" in sent_request.headers.get("content-type", "")
+
+    @pytest.mark.asyncio
+    async def test_invoke_activity_async_json_request(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test async invocation of an Integration Service activity."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "query_param": "test_query",
+            "body_field1": "async_value1",
+            "body_field2": "async_value2",
+        }
+        expected_response = {"result": "async_success", "data": {"id": 456}}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        response = await service.invoke_activity_async(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        assert response == expected_response
+
+    def test_invoke_activity_with_none_values_filtered(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that None values are filtered out from the request."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "query_param": "test_query",
+            "custom_header": None,  # This should be filtered out
+            "body_field1": "value1",
+            "body_field2": None,  # This should be filtered out
+        }
+        expected_response = {"result": "success"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        # custom_header should not be present since it was None
+        assert "custom_header" not in sent_request.headers
+
+        # Only non-None body fields should be present
+        request_json = json.loads(sent_request.content.decode())
+        assert request_json == {"body_field1": "value1"}
+
+    def test_invoke_activity_unknown_parameter_is_ignored(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that unknown parameters are ignored."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "unknown_param": "value",  # This parameter doesn't exist in metadata
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json={},
+        )
+
+        service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+        assert "unknown_param" not in sent_request.url.params
+        assert "unknown_param" not in str(sent_request.url.path)
+        assert "unknown_param" not in sent_request.headers
+        request_json = json.loads(sent_request.content.decode())
+        assert "unknown_param" not in request_json
+
+    def test_invoke_activity_unknown_parameter_is_ignored_multipart(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that unknown parameters are ignored in multipart requests."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "unknown_param": "value",  # This parameter doesn't exist in metadata
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json={},
+        )
+
+        service.invoke_activity(
+            activity_metadata=multipart_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        assert "unknown_param" not in sent_request.url.params
+        assert "unknown_param" not in str(sent_request.url.path)
+        assert "unknown_param" not in sent_request.headers
+        body = sent_request.content.decode("utf-8", errors="replace")
+        assert "unknown_param" not in body
+
+    def test_invoke_activity_unsupported_content_type_raises_error(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+    ) -> None:
+        """Test that unsupported content types raise a ValueError."""
+        unsupported_metadata = ActivityMetadata(
+            object_path="/elements/test-connector/test-activity",
+            method_name="POST",
+            content_type="application/xml",  # Unsupported content type
+            parameter_location_info=ActivityParameterLocationInfo(
+                query_params=[],
+                header_params=[],
+                path_params=[],
+                multipart_params=[],
+                body_fields=["xml_data"],
+            ),
+        )
+
+        connection_id = "test-connection-123"
+        activity_input = {"xml_data": "<test>data</test>"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+
+        with pytest.raises(
+            ValueError, match="Unsupported content type: application/xml"
+        ):
+            service.invoke_activity(
+                activity_metadata=unsupported_metadata,
+                connection_id=connection_id,
+                activity_input=activity_input,
+            )
+
+    def test_invoke_activity_empty_input(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test invoking with empty input."""
+        activity_metadata = ActivityMetadata(
+            object_path="/elements/test-connector/ping",
+            method_name="GET",
+            content_type="application/json",
+            parameter_location_info=ActivityParameterLocationInfo(
+                query_params=[],
+                header_params=[],
+                path_params=[],
+                multipart_params=[],
+                body_fields=[],
+            ),
+        )
+
+        connection_id = "test-connection-123"
+        expected_response = {"status": "pong"}
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_id}",
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json=expected_response,
+        )
+
+        result = service.invoke_activity(
+            activity_metadata=activity_metadata,
+            connection_id=connection_id,
+            activity_input={},
+        )
+
+        assert result == expected_response
+
+    def test_invoke_activity_multipart_custom_json_body_section(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_custom_section_metadata: ActivityMetadata,
+    ) -> None:
+        """Test multipart request uses custom json_body_section name instead of 'body'."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": b"test file content",
+            "prompt": "Summarize this document",
+            "model": "gpt-4",
+        }
+        expected_response = {"result": "summary text"}
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=multipart_custom_section_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        assert "multipart/form-data" in sent_request.headers.get("content-type", "")
+
+        # Parse the multipart body to verify part names
+        content_type = sent_request.headers["content-type"]
+        boundary = content_type.split("boundary=")[1]
+        body = sent_request.content.decode("utf-8", errors="replace")
+        parts = body.split(f"--{boundary}")
+
+        # Find the part names in the multipart body
+        part_names = []
+        for part in parts:
+            if 'name="' in part:
+                name = part.split('name="')[1].split('"')[0]
+                part_names.append(name)
+
+        # The JSON body should be in "RagRequest" part, not "body"
+        assert "RagRequest" in part_names
+        assert "body" not in part_names
+        assert "file_param" in part_names
+
+    def test_invoke_activity_multipart_default_json_body_section(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+    ) -> None:
+        """Test multipart request defaults to 'body' when json_body_section is None."""
+        metadata = ActivityMetadata(
+            object_path="/elements/test-connector/upload",
+            method_name="POST",
+            content_type="multipart/form-data",
+            parameter_location_info=ActivityParameterLocationInfo(
+                query_params=[],
+                header_params=[],
+                path_params=[],
+                multipart_params=["file_param"],
+                body_fields=["description"],
+            ),
+            # json_body_section is None (default)
+        )
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": b"file data",
+            "description": "A file",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={"ok": True})
+
+        _ = service.invoke_activity(
+            activity_metadata=metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        requests = httpx_mock.get_requests()
+        sent_request = requests[1]
+
+        content_type = sent_request.headers["content-type"]
+        boundary = content_type.split("boundary=")[1]
+        body = sent_request.content.decode("utf-8", errors="replace")
+        parts = body.split(f"--{boundary}")
+
+        part_names = []
+        for part in parts:
+            if 'name="' in part:
+                name = part.split('name="')[1].split('"')[0]
+                part_names.append(name)
+
+        # Should default to "body" when json_body_section is None
+        assert "body" in part_names
+        assert "file_param" in part_names
+
+    def test_invoke_activity_retrieves_connection_and_sends_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that invoke_activity retrieves the connection and sends its folder key."""
+        connection_id = "test-connection-123"
+        folder_key = "d6f5c54a-e2b2-4083-be93-623aa670ed40"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_id}",
+            method="GET",
+            status_code=200,
+            json={
+                "id": connection_id,
+                "name": "Test Connection",
+                "elementInstanceId": 123,
+                "folder": {"key": folder_key},
+            },
+        )
+
+        expected_response = {"status": "success"}
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        result = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input={"body_field1": "test value"},
+        )
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+        retrieve_request = requests[0]
+        assert retrieve_request.method == "GET"
+        assert f"/Connections/{connection_id}" in str(retrieve_request.url)
+
+        activity_request = requests[1]
+        assert activity_request.headers[HEADER_FOLDER_KEY] == folder_key
+        assert result == expected_response
+
+    @pytest.mark.asyncio
+    async def test_invoke_activity_async_retrieves_connection_and_sends_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that invoke_activity_async retrieves the connection and sends its folder key."""
+        connection_id = "test-connection-123"
+        folder_key = "d6f5c54a-e2b2-4083-be93-623aa670ed40"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_id}",
+            method="GET",
+            status_code=200,
+            json={
+                "id": connection_id,
+                "name": "Test Connection",
+                "elementInstanceId": 123,
+                "folder": {"key": folder_key},
+            },
+        )
+
+        expected_response = {"result": "async_success"}
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json=expected_response,
+        )
+
+        result = await service.invoke_activity_async(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input={"body_field1": "async_value"},
+        )
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+        retrieve_request = requests[0]
+        assert retrieve_request.method == "GET"
+        assert f"/Connections/{connection_id}" in str(retrieve_request.url)
+
+        activity_request = requests[1]
+        assert activity_request.headers[HEADER_FOLDER_KEY] == folder_key
+        assert result == expected_response
+
+    def test_invoke_activity_omits_folder_header_when_no_folder(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that folder key header is omitted when connection has no folder."""
+        connection_id = "test-connection-123"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_id}",
+            method="GET",
+            status_code=200,
+            json={
+                "id": connection_id,
+                "name": "Test Connection",
+                "elementInstanceId": 123,
+                "folder": None,
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=connection_id,
+            activity_input={"body_field1": "test value"},
+        )
+
+        requests = httpx_mock.get_requests()
+        activity_request = requests[1]
+        assert HEADER_FOLDER_KEY not in activity_request.headers
+
+    def test_invoke_activity_uses_connection_id_from_retrieve_response(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that the activity URL uses connection.id from the retrieve response."""
+        original_connection_id = "original-key-abc"
+        resolved_connection_id = "resolved-id-456"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{original_connection_id}",
+            method="GET",
+            status_code=200,
+            json={
+                "id": resolved_connection_id,
+                "name": "Test Connection",
+                "elementInstanceId": 789,
+                "folder": None,
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        _ = service.invoke_activity(
+            activity_metadata=simple_activity_metadata,
+            connection_id=original_connection_id,
+            activity_input={"body_field1": "test value"},
+        )
+
+        requests = httpx_mock.get_requests()
+        activity_request = requests[1]
+        assert f"/element/instances/{resolved_connection_id}/" in str(
+            activity_request.url
+        )
+        assert f"/element/instances/{original_connection_id}/" not in str(
+            activity_request.url
+        )
+
+    @pytest.mark.asyncio
+    async def test_invoke_activity_async_uses_connection_id_from_retrieve_response(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        simple_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Test that the async activity URL uses connection.id from the retrieve response."""
+        original_connection_id = "original-key-abc"
+        resolved_connection_id = "resolved-id-456"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{original_connection_id}",
+            method="GET",
+            status_code=200,
+            json={
+                "id": resolved_connection_id,
+                "name": "Test Connection",
+                "elementInstanceId": 789,
+                "folder": None,
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        _ = await service.invoke_activity_async(
+            activity_metadata=simple_activity_metadata,
+            connection_id=original_connection_id,
+            activity_input={"body_field1": "test value"},
+        )
+
+        requests = httpx_mock.get_requests()
+        activity_request = requests[1]
+        assert f"/element/instances/{resolved_connection_id}/" in str(
+            activity_request.url
+        )
+        assert f"/element/instances/{original_connection_id}/" not in str(
+            activity_request.url
+        )
+
+
+def _multipart_part(body: bytes, boundary: str, name: str) -> str:
+    """Return the raw text of the multipart part with the given form-field name."""
+    text = body.decode("utf-8", errors="replace")
+    for part in text.split(f"--{boundary}"):
+        if f'name="{name}"' in part:
+            return part
+    raise AssertionError(f"part {name!r} not found in multipart body")
+
+
+class TestMultipartFileUpload:
+    """Regression tests for the multipart serializer that handles file uploads.
+
+    Before this fix, ``_build_activity_request_spec`` always built
+    ``files[key] = (key, val, None)``, using the form-field name as the
+    multipart filename and dropping the content type. Downstream services
+    (e.g. Coupa's ``add_attachment`` endpoint) ended up storing every
+    attachment with the literal name ``attachment[file]`` and no extension.
+
+    The serializer now branches on the value type:
+
+    * tuple  → passed through (caller controls filename + content type)
+    * bytes  → legacy fallback, key as filename, octet-stream content type
+    * scalar → plain multipart form field (no filename in Content-Disposition)
+    """
+
+    def test_invoke_activity_multipart_tuple_3_preserves_filename(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """3-tuple input is forwarded verbatim, so the real filename + content type land on the wire."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": ("invoice.pdf", b"%PDF-1.4 fake", "application/pdf"),
+            "description": "Test file upload",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={"ok": True})
+
+        _ = service.invoke_activity(
+            activity_metadata=multipart_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        boundary = sent_request.headers["content-type"].split("boundary=")[1]
+        part = _multipart_part(sent_request.content, boundary, "file_param")
+
+        assert 'filename="invoice.pdf"' in part
+        assert "Content-Type: application/pdf" in part
+        assert b"%PDF-1.4 fake" in sent_request.content
+
+    def test_invoke_activity_multipart_tuple_2_preserves_filename(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """2-tuple (filename, content) shorthand: filename preserved, httpx infers the content type."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": ("invoice.pdf", b"%PDF-1.4 fake"),
+            "description": "Test file upload",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={"ok": True})
+
+        _ = service.invoke_activity(
+            activity_metadata=multipart_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        boundary = sent_request.headers["content-type"].split("boundary=")[1]
+        part = _multipart_part(sent_request.content, boundary, "file_param")
+
+        assert 'filename="invoice.pdf"' in part
+        assert b"%PDF-1.4 fake" in sent_request.content
+
+    def test_invoke_activity_multipart_bytes_backwards_compatible(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+        multipart_activity_metadata: ActivityMetadata,
+    ) -> None:
+        """Existing callers passing raw bytes keep working — filename = form-field name (legacy)."""
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": b"raw bytes",
+            "description": "Test",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={"ok": True})
+
+        _ = service.invoke_activity(
+            activity_metadata=multipart_activity_metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        boundary = sent_request.headers["content-type"].split("boundary=")[1]
+        part = _multipart_part(sent_request.content, boundary, "file_param")
+
+        # Legacy fallback: form-field name used as filename, octet-stream content type.
+        assert 'filename="file_param"' in part
+        assert "Content-Type: application/octet-stream" in part
+        assert b"raw bytes" in sent_request.content
+
+    def test_invoke_activity_multipart_scalar_is_plain_form_field(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ConnectionsService,
+    ) -> None:
+        """Scalar multipart_params get sent as plain form fields (no bogus filename)."""
+        metadata = ActivityMetadata(
+            object_path="/elements/test-connector/upload",
+            method_name="POST",
+            content_type="multipart/form-data",
+            parameter_location_info=ActivityParameterLocationInfo(
+                multipart_params=["file_param", "payload"],
+                body_fields=[],
+            ),
+        )
+        connection_id = "test-connection-123"
+        activity_input = {
+            "file_param": ("doc.pdf", b"data", "application/pdf"),
+            "payload": "{}",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            status_code=200,
+            json={"id": connection_id, "name": "Test", "elementInstanceId": 1},
+        )
+        httpx_mock.add_response(method="POST", status_code=200, json={"ok": True})
+
+        _ = service.invoke_activity(
+            activity_metadata=metadata,
+            connection_id=connection_id,
+            activity_input=activity_input,
+        )
+
+        sent_request = httpx_mock.get_requests()[1]
+        boundary = sent_request.headers["content-type"].split("boundary=")[1]
+        payload_part = _multipart_part(sent_request.content, boundary, "payload")
+
+        # Scalar payload must NOT carry a filename in Content-Disposition.
+        assert "filename=" not in payload_part
+        assert "{}" in payload_part
diff --git a/packages/uipath-platform/tests/services/test_context_grounding_service.py b/packages/uipath-platform/tests/services/test_context_grounding_service.py
new file mode 100644
index 000000000..70c529ec6
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_context_grounding_service.py
@@ -0,0 +1,3920 @@
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pydantic import ValidationError
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import (
+    ENV_JOB_KEY,
+    HEADER_JOB_KEY,
+    HEADER_USER_AGENT,
+)
+from uipath.platform.context_grounding import (
+    BatchTransformCreationResponse,
+    BatchTransformOutputColumn,
+    BatchTransformResponse,
+    BatchTransformStatus,
+    BucketSourceConfig,
+    Citation,
+    CitationMode,
+    ConfluenceSourceConfig,
+    ContextGroundingIndex,
+    ContextGroundingQueryResponse,
+    DeepRagCreationResponse,
+    DeepRagResponse,
+    DropboxSourceConfig,
+    GoogleDriveSourceConfig,
+    Indexer,
+    OneDriveSourceConfig,
+    SearchMode,
+    UnifiedQueryResult,
+    UnifiedSearchScope,
+)
+from uipath.platform.context_grounding._context_grounding_service import (
+    ContextGroundingService,
+)
+from uipath.platform.errors import ContextGroundingIndexNotFoundError
+from uipath.platform.orchestrator._buckets_service import BucketsService
+from uipath.platform.orchestrator._folder_service import FolderService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> ContextGroundingService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    folders_service = FolderService(config=config, execution_context=execution_context)
+    buckets_service = BucketsService(config=config, execution_context=execution_context)
+    return ContextGroundingService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folders_service,
+        buckets_service=buckets_service,
+    )
+
+
+@pytest.fixture
+def service_no_folder(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> ContextGroundingService:
+    monkeypatch.delenv("UIPATH_FOLDER_PATH", raising=False)
+    monkeypatch.delenv("UIPATH_FOLDER_KEY", raising=False)
+    folders_service = FolderService(config=config, execution_context=execution_context)
+    buckets_service = BucketsService(config=config, execution_context=execution_context)
+    return ContextGroundingService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folders_service,
+        buckets_service=buckets_service,
+    )
+
+
+class TestContextGroundingService:
+    def test_search(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1/search",
+            status_code=200,
+            json=[
+                {
+                    "source": "test-source",
+                    "page_number": "1",
+                    "content": "Test content",
+                    "metadata": {
+                        "operation_id": "test-op",
+                        "strategy": "test-strategy",
+                    },
+                    "score": 0.95,
+                }
+            ],
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        response = service.search(
+            name="test-index", query="test query", number_of_results=1
+        )
+
+        assert isinstance(response, list)
+        assert len(response) == 1
+        assert isinstance(response[0], ContextGroundingQueryResponse)
+        assert response[0].source == "test-source"
+        assert response[0].page_number == "1"
+        assert response[0].content == "Test content"
+        assert response[0].metadata.operation_id == "test-op"
+        assert response[0].metadata.strategy == "test-strategy"
+        assert response[0].score == 0.95
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert sent_requests[3].url == f"{base_url}{org}{tenant}/ecs_/v1/search"
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.search/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_search_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1/search",
+            status_code=200,
+            json=[
+                {
+                    "source": "test-source",
+                    "page_number": "1",
+                    "content": "Test content",
+                    "metadata": {
+                        "operation_id": "test-op",
+                        "strategy": "test-strategy",
+                    },
+                    "score": 0.95,
+                }
+            ],
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        response = await service.search_async(
+            name="test-index", query="test query", number_of_results=1
+        )
+
+        assert isinstance(response, list)
+        assert len(response) == 1
+        assert isinstance(response[0], ContextGroundingQueryResponse)
+        assert response[0].source == "test-source"
+        assert response[0].page_number == "1"
+        assert response[0].content == "Test content"
+        assert response[0].metadata.operation_id == "test-op"
+        assert response[0].metadata.strategy == "test-strategy"
+        assert response[0].score == 0.95
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert sent_requests[3].url == f"{base_url}{org}{tenant}/ecs_/v1/search"
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.search_async/{version}"
+        )
+
+    def test_retrieve(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        index = service.retrieve(name="test-index")
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "test-index-id"
+        assert index.name == "test-index"
+        assert index.last_ingestion_status == "Completed"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24filter=Name+eq+%27test-index%27&%24expand=dataSource"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        index = await service.retrieve_async(name="test-index")
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "test-index-id"
+        assert index.name == "test-index"
+        assert index.last_ingestion_status == "Completed"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24filter=Name+eq+%27test-index%27&%24expand=dataSource"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_async/{version}"
+        )
+
+    def test_list(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "index-id-1",
+                        "name": "index-one",
+                        "lastIngestionStatus": "Completed",
+                    },
+                    {
+                        "id": "index-id-2",
+                        "name": "index-two",
+                        "lastIngestionStatus": "Queued",
+                    },
+                ]
+            },
+        )
+
+        indexes = service.list()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 2
+        assert all(isinstance(i, ContextGroundingIndex) for i in indexes)
+        assert indexes[0].id == "index-id-1"
+        assert indexes[0].name == "index-one"
+        assert indexes[1].id == "index-id-2"
+        assert indexes[1].name == "index-two"
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24expand=dataSource"
+        )
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.list/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_list_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "index-id-1",
+                        "name": "index-one",
+                        "lastIngestionStatus": "Completed",
+                    },
+                ]
+            },
+        )
+
+        indexes = await service.list_async()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 1
+        assert isinstance(indexes[0], ContextGroundingIndex)
+        assert indexes[0].id == "index-id-1"
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24expand=dataSource"
+        )
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.list_async/{version}"
+        )
+
+    def test_list_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$expand=dataSource",
+            status_code=200,
+            json={"value": []},
+        )
+
+        indexes = service.list()
+
+        assert indexes == []
+
+    def test_retrieve_across_folders(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "index-1",
+                        "name": "index-folder-a",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "folder-key-a",
+                    },
+                    {
+                        "id": "index-2",
+                        "name": "index-folder-b",
+                        "lastIngestionStatus": "Queued",
+                        "folderKey": "folder-key-b",
+                    },
+                ]
+            },
+        )
+
+        indexes = service.retrieve_across_folders()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 2
+        assert isinstance(indexes[0], ContextGroundingIndex)
+        assert indexes[0].id == "index-1"
+        assert indexes[0].name == "index-folder-a"
+        assert indexes[1].id == "index-2"
+        assert indexes[1].name == "index-folder-b"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+        # Verify no folder key header is sent
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_across_folders/{version}"
+        )
+
+    def test_retrieve_across_folders_with_name_filter(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'my-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "index-1",
+                        "name": "my-index",
+                        "lastIngestionStatus": "Completed",
+                    },
+                ]
+            },
+        )
+
+        indexes = service.retrieve_across_folders(name="my-index")
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 1
+        assert indexes[0].name == "my-index"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert "allacrossfolders" in str(sent_requests[0].url)
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+    @pytest.mark.anyio
+    async def test_retrieve_across_folders_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "index-1",
+                        "name": "index-folder-a",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "folder-key-a",
+                    },
+                    {
+                        "id": "index-2",
+                        "name": "index-folder-b",
+                        "lastIngestionStatus": "Queued",
+                        "folderKey": "folder-key-b",
+                    },
+                ]
+            },
+        )
+
+        indexes = await service.retrieve_across_folders_async()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 2
+        assert isinstance(indexes[0], ContextGroundingIndex)
+        assert indexes[0].id == "index-1"
+        assert indexes[0].name == "index-folder-a"
+        assert indexes[1].id == "index-2"
+        assert indexes[1].name == "index-folder-b"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+        # Verify no folder key header is sent
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_across_folders_async/{version}"
+        )
+
+    def test_retrieve_across_folders_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource",
+            status_code=200,
+            json={"value": []},
+        )
+
+        indexes = service.retrieve_across_folders()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 0
+
+    def test_retrieve_falls_back_to_across_folders_when_no_folder_context(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """When no folder_key/folder_path is configured, retrieve should fall back to retrieve_across_folders."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'test-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "resolved-folder-key",
+                    }
+                ]
+            },
+        )
+
+        index = service_no_folder.retrieve(name="test-index")
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "test-index-id"
+        assert index.name == "test-index"
+        assert index.folder_key == "resolved-folder-key"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 1
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+    @pytest.mark.anyio
+    async def test_retrieve_async_falls_back_to_across_folders_when_no_folder_context(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """When no folder_key/folder_path is configured, retrieve_async should fall back to retrieve_across_folders_async."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'test-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "resolved-folder-key",
+                    }
+                ]
+            },
+        )
+
+        index = await service_no_folder.retrieve_async(name="test-index")
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "test-index-id"
+        assert index.folder_key == "resolved-folder-key"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 1
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+
+    def test_retrieve_system_indexes(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-index-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    },
+                    {
+                        "id": "sys-index-2",
+                        "name": "system-other-index",
+                        "lastIngestionStatus": "Completed",
+                    },
+                ]
+            },
+        )
+
+        indexes = service._retrieve_system_indexes()
+
+        assert isinstance(indexes, list)
+        assert len(indexes) == 2
+        assert isinstance(indexes[0], ContextGroundingIndex)
+        assert indexes[0].id == "sys-index-1"
+        assert indexes[0].name == "system-template-index"
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests[0].method == "GET"
+        assert "/ecs_/v2/indexes/allsystemindexes" in str(sent_requests[0].url)
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService._retrieve_system_indexes/{version}"
+        )
+
+    def test_retrieve_system_indexes_with_name_filter(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-index-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    },
+                ]
+            },
+        )
+
+        indexes = service._retrieve_system_indexes(name="system-template-index")
+
+        assert len(indexes) == 1
+        assert indexes[0].name == "system-template-index"
+
+        sent_requests = httpx_mock.get_requests()
+        assert "allsystemindexes" in str(sent_requests[0].url)
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+    @pytest.mark.anyio
+    async def test_retrieve_system_indexes_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-index-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        indexes = await service._retrieve_system_indexes_async()
+
+        assert len(indexes) == 1
+        assert indexes[0].id == "sys-index-1"
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests[0].method == "GET"
+        assert "/ecs_/v2/indexes/allsystemindexes" in str(sent_requests[0].url)
+        assert "x-uipath-folderkey" not in sent_requests[0].headers
+
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService._retrieve_system_indexes_async/{version}"
+        )
+
+    def test_retrieve_system_indexes_escapes_single_quote_in_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'O''Brien'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "O'Brien",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        indexes = service._retrieve_system_indexes(name="O'Brien")
+
+        assert len(indexes) == 1
+        assert indexes[0].name == "O'Brien"
+
+    def test_retrieve_across_folders_escapes_single_quote_in_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'O''Brien'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "idx-1",
+                        "name": "O'Brien",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        indexes = service.retrieve_across_folders(name="O'Brien")
+
+        assert len(indexes) == 1
+        assert indexes[0].name == "O'Brien"
+
+    def test_retrieve_system_indexes_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource",
+            status_code=200,
+            json={"value": []},
+        )
+
+        indexes = service._retrieve_system_indexes()
+
+        assert indexes == []
+
+    def test_retrieve_raises_typed_not_found_when_across_folders_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'missing-index'",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(ContextGroundingIndexNotFoundError) as exc_info:
+            service_no_folder.retrieve(name="missing-index")
+
+        assert exc_info.value.index_name == "missing-index"
+
+    @pytest.mark.anyio
+    async def test_retrieve_async_raises_typed_not_found_when_across_folders_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'missing-index'",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(ContextGroundingIndexNotFoundError):
+            await service_no_folder.retrieve_async(name="missing-index")
+
+    def test_retrieve_falls_back_to_system_indexes_when_flag_true(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        index = service_no_folder.retrieve(
+            name="system-template-index", include_system_indexes=True
+        )
+
+        assert index.id == "sys-1"
+        assert index.name == "system-template-index"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 2
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+        assert "/ecs_/v2/indexes/allsystemindexes" in str(sent_requests[1].url)
+
+    def test_retrieve_does_not_fall_back_to_system_indexes_when_flag_false(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'missing-index'",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(ContextGroundingIndexNotFoundError):
+            service_no_folder.retrieve(name="missing-index")
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 1
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+
+    def test_retrieve_skips_system_indexes_when_across_folders_resolves(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'tenant-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "tenant-1",
+                        "name": "tenant-index",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "folder-x",
+                    }
+                ]
+            },
+        )
+
+        index = service_no_folder.retrieve(
+            name="tenant-index", include_system_indexes=True
+        )
+
+        assert index.id == "tenant-1"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 1
+        assert "/ecs_/v2/indexes/allacrossfolders" in str(sent_requests[0].url)
+
+    def test_retrieve_falls_back_to_system_indexes_after_folder_lookup_misses(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'system-template-index'&$expand=dataSource",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        index = service.retrieve(
+            name="system-template-index",
+            folder_path="test-folder-path",
+            include_system_indexes=True,
+        )
+
+        assert index.id == "sys-1"
+
+    @pytest.mark.anyio
+    async def test_retrieve_async_falls_back_to_system_indexes_when_flag_true(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        index = await service_no_folder.retrieve_async(
+            name="system-template-index", include_system_indexes=True
+        )
+
+        assert index.id == "sys-1"
+
+    def test_retrieve_with_flag_raises_when_system_indexes_also_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'missing-index'",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'missing-index'",
+            status_code=200,
+            json={"value": []},
+        )
+
+        with pytest.raises(ContextGroundingIndexNotFoundError):
+            service_no_folder.retrieve(
+                name="missing-index", include_system_indexes=True
+            )
+
+    def test_unified_search_forwards_include_system_indexes(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1.2/search/sys-1",
+            status_code=200,
+            json={
+                "semanticResults": {
+                    "values": [],
+                    "metadata": {"operation_id": "op-1", "strategy": "semantic"},
+                }
+            },
+        )
+
+        result = service_no_folder.unified_search(
+            name="system-template-index",
+            query="hello",
+            include_system_indexes=True,
+        )
+
+        assert isinstance(result, UnifiedQueryResult)
+
+        sent_requests = httpx_mock.get_requests()
+        assert any("allsystemindexes" in str(r.url) for r in sent_requests)
+        assert any("search/sys-1" in str(r.url) for r in sent_requests)
+
+    @pytest.mark.anyio
+    async def test_unified_search_async_forwards_include_system_indexes(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={"value": []},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allsystemindexes?$expand=dataSource&$filter=Name eq 'system-template-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "sys-1",
+                        "name": "system-template-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1.2/search/sys-1",
+            status_code=200,
+            json={
+                "semanticResults": {
+                    "values": [],
+                    "metadata": {"operation_id": "op-1", "strategy": "semantic"},
+                }
+            },
+        )
+
+        result = await service_no_folder.unified_search_async(
+            name="system-template-index",
+            query="hello",
+            include_system_indexes=True,
+        )
+
+        assert isinstance(result, UnifiedQueryResult)
+
+        sent_requests = httpx_mock.get_requests()
+        assert any("allsystemindexes" in str(r.url) for r in sent_requests)
+        assert any("search/sys-1" in str(r.url) for r in sent_requests)
+
+    def test_search_uses_index_folder_key_when_no_folder_context(
+        self,
+        httpx_mock: HTTPXMock,
+        service_no_folder: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """When no folder context is configured, search should use the index's folder_key for the search request."""
+        # retrieve falls back to across_folders
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/allacrossfolders?$expand=dataSource&$filter=Name eq 'test-index'",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                        "folderKey": "resolved-folder-key",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1/search",
+            status_code=200,
+            json=[
+                {
+                    "source": "test-source",
+                    "page_number": "1",
+                    "content": "Test content",
+                    "metadata": {
+                        "operation_id": "test-op",
+                        "strategy": "test-strategy",
+                    },
+                    "score": 0.95,
+                }
+            ],
+        )
+
+        response = service_no_folder.search(
+            name="test-index", query="test query", number_of_results=1
+        )
+
+        assert len(response) == 1
+        assert response[0].content == "Test content"
+
+        sent_requests = httpx_mock.get_requests()
+        # First request: across_folders retrieve, second: search
+        search_request = sent_requests[1]
+        assert search_request.method == "POST"
+        assert "x-uipath-folderkey" in search_request.headers
+        assert search_request.headers["x-uipath-folderkey"] == "resolved-folder-key"
+
+    def test_create_index_bucket(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "new-index-id",
+                "name": "test-bucket-index",
+                "description": "Test bucket index",
+                "lastIngestionStatus": "Queued",
+                "dataSource": {"bucketName": "test-bucket", "folder": "/test/folder"},
+            },
+        )
+
+        source = BucketSourceConfig(
+            bucket_name="test-bucket",
+            folder_path="/test/folder",
+            directory_path="/",
+            file_type="pdf",
+        )
+
+        index = service.create_index(
+            name="test-bucket-index",
+            description="Test bucket index",
+            source=source,
+            extraction_strategy="LLMV4",
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "new-index-id"
+        assert index.name == "test-bucket-index"
+        assert index.description == "Test bucket index"
+        assert index.last_ingestion_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        assert len(sent_requests) == 2
+
+        create_request = sent_requests[1]
+        assert create_request.method == "POST"
+        assert create_request.url == f"{base_url}{org}{tenant}/ecs_/v2/indexes/create"
+        assert HEADER_USER_AGENT in create_request.headers
+        assert (
+            create_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.create_index/{version}"
+        )
+
+        request_data = json.loads(create_request.content)
+        assert request_data["name"] == "test-bucket-index"
+        assert request_data["description"] == "Test bucket index"
+        assert (
+            request_data["dataSource"]["@odata.type"]
+            == "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
+        )
+        assert request_data["dataSource"]["bucketName"] == "test-bucket"
+        assert request_data["dataSource"]["folder"] == "/test/folder"
+        assert request_data["dataSource"]["directoryPath"] == "/"
+        assert request_data["dataSource"]["fileNameGlob"] == "**/*.pdf"
+        assert request_data["extractionStrategy"] == "LLMV4"
+
+    def test_create_index_google_drive(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "google-index-id",
+                "name": "test-google-index",
+                "description": "Test Google Drive index",
+                "lastIngestionStatus": "Queued",
+                "dataSource": {"connectionId": "conn-123", "folder": "/test/folder"},
+            },
+        )
+
+        source = GoogleDriveSourceConfig(
+            connection_id="conn-123",
+            connection_name="Google Drive Connection",
+            leaf_folder_id="folder-456",
+            directory_path="/shared-docs",
+            folder_path="/test/folder",
+            file_type="docx",
+            indexer=Indexer(
+                cron_expression="0 18 * * 2", time_zone_id="Pacific Standard Time"
+            ),
+        )
+
+        index = service.create_index(
+            name="test-google-index",
+            description="Test Google Drive index",
+            source=source,
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "google-index-id"
+        assert index.name == "test-google-index"
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+
+        request_data = json.loads(create_request.content)
+        assert (
+            request_data["dataSource"]["@odata.type"]
+            == "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSourceRequest"
+        )
+        assert request_data["dataSource"]["connectionId"] == "conn-123"
+        assert request_data["dataSource"]["connectionName"] == "Google Drive Connection"
+        assert request_data["dataSource"]["leafFolderId"] == "folder-456"
+        assert request_data["dataSource"]["directoryPath"] == "/shared-docs"
+        assert request_data["dataSource"]["fileNameGlob"] == "**/*.docx"
+        assert request_data["dataSource"]["indexer"]["cronExpression"] == "0 18 * * 2"
+        assert (
+            request_data["dataSource"]["indexer"]["timeZoneId"]
+            == "Pacific Standard Time"
+        )
+
+    def test_create_index_dropbox(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "dropbox-index-id",
+                "name": "test-dropbox-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        source = DropboxSourceConfig(
+            connection_id="dropbox-conn-789",
+            connection_name="Dropbox Connection",
+            directory_path="/company-files",
+            folder_path="/test/folder",
+        )
+
+        index = service.create_index(name="test-dropbox-index", source=source)
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "dropbox-index-id"
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+
+        request_data = json.loads(create_request.content)
+        assert (
+            request_data["dataSource"]["@odata.type"]
+            == "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSourceRequest"
+        )
+        assert request_data["dataSource"]["connectionId"] == "dropbox-conn-789"
+        assert request_data["dataSource"]["connectionName"] == "Dropbox Connection"
+        assert request_data["dataSource"]["directoryPath"] == "/company-files"
+        assert request_data["dataSource"]["fileNameGlob"] == "**/*"
+        assert "preProcessing" not in request_data
+        assert "extractionStrategy" not in request_data
+
+    def test_create_index_onedrive(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "onedrive-index-id",
+                "name": "test-onedrive-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        source = OneDriveSourceConfig(
+            connection_id="onedrive-conn-101",
+            connection_name="OneDrive Connection",
+            leaf_folder_id="onedrive-folder-202",
+            directory_path="/reports",
+            folder_path="/test/folder",
+            file_type="xlsx",
+        )
+
+        index = service.create_index(name="test-onedrive-index", source=source)
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "onedrive-index-id"
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+
+        request_data = json.loads(create_request.content)
+        assert (
+            request_data["dataSource"]["@odata.type"]
+            == "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSourceRequest"
+        )
+        assert request_data["dataSource"]["connectionId"] == "onedrive-conn-101"
+        assert request_data["dataSource"]["leafFolderId"] == "onedrive-folder-202"
+        assert request_data["dataSource"]["fileNameGlob"] == "**/*.xlsx"
+
+    def test_create_index_confluence(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "confluence-index-id",
+                "name": "test-confluence-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        source = ConfluenceSourceConfig(
+            connection_id="confluence-conn-303",
+            connection_name="Confluence Connection",
+            space_id="space-404",
+            directory_path="/wiki-docs",
+            folder_path="/test/folder",
+        )
+
+        index = service.create_index(name="test-confluence-index", source=source)
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "confluence-index-id"
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+
+        request_data = json.loads(create_request.content)
+        assert (
+            request_data["dataSource"]["@odata.type"]
+            == "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSourceRequest"
+        )
+        assert request_data["dataSource"]["connectionId"] == "confluence-conn-303"
+        assert request_data["dataSource"]["connectionName"] == "Confluence Connection"
+
+    @pytest.mark.anyio
+    async def test_create_index_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "async-index-id",
+                "name": "test-async-index",
+                "description": "Test async index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        source = BucketSourceConfig(
+            bucket_name="async-bucket",
+            folder_path="/async/folder",
+        )
+
+        index = await service.create_index_async(
+            name="test-async-index", description="Test async index", source=source
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "async-index-id"
+        assert index.name == "test-async-index"
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+        assert create_request.method == "POST"
+        assert HEADER_USER_AGENT in create_request.headers
+        assert (
+            create_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.create_index_async/{version}"
+        )
+
+    def test_create_index_missing_bucket_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        # Pydantic will raise ValidationError for missing required fields
+        with pytest.raises(ValidationError, match="bucket_name"):
+            BucketSourceConfig(folder_path="/test/folder")  # type: ignore[call-arg]
+
+    def test_create_index_missing_google_drive_fields(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        # Pydantic will raise ValidationError for missing required fields
+        with pytest.raises(ValidationError, match="connection_name"):
+            GoogleDriveSourceConfig(  # type: ignore[call-arg]
+                connection_id="conn-123",
+                folder_path="/test/folder",
+            )
+
+    def test_create_index_with_extraction_strategy(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/create",
+            status_code=200,
+            json={
+                "id": "custom-strategy-index-id",
+                "name": "test-custom-strategy-index",
+                "lastIngestionStatus": "Queued",
+                "extractionStrategy": "NativeV1",
+                "embeddingsEnabled": True,
+                "isEncrypted": True,
+            },
+        )
+
+        source = BucketSourceConfig(
+            bucket_name="test-bucket",
+            folder_path="/test/folder",
+        )
+
+        index = service.create_index(
+            name="test-custom-strategy-index",
+            source=source,
+            extraction_strategy="NativeV1",
+            embeddings_enabled=True,
+            is_encrypted=True,
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.extraction_strategy == "NativeV1"
+        assert index.embeddings_enabled is True
+        assert index.is_encrypted is True
+
+        sent_requests = httpx_mock.get_requests()
+        create_request = sent_requests[1]
+
+        request_data = json.loads(create_request.content)
+        assert request_data["extractionStrategy"] == "NativeV1"
+        assert request_data["embeddingsEnabled"] is True
+        assert request_data["isEncrypted"] is True
+
+    def test_all_requests_pass_spec_parameters(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Verify that all requests pass spec.method, spec.endpoint, spec.params, and spec.headers correctly."""
+        # Mock folder service to always return the test folder key
+        with patch.object(
+            service._folders_service, "retrieve_key", return_value="test-folder-key"
+        ):
+            # Test retrieve_across_folders method (no folder key header)
+            with patch.object(service, "request") as mock_request:
+                mock_response = MagicMock()
+                mock_response.json.return_value = {
+                    "value": [
+                        {
+                            "id": "test-index-id",
+                            "name": "test-index",
+                            "lastIngestionStatus": "Completed",
+                        }
+                    ]
+                }
+                mock_request.return_value = mock_response
+
+                service.retrieve_across_folders()
+
+                assert mock_request.called
+                call_args = mock_request.call_args
+                assert call_args[0][0] == "GET"
+                assert str(call_args[0][1]) == "/ecs_/v2/indexes/allacrossfolders"
+                assert "params" in call_args[1]
+                assert call_args[1]["params"]["$expand"] == "dataSource"
+                # Verify NO folder key header is sent
+                assert "headers" not in call_args[
+                    1
+                ] or "x-uipath-folderkey" not in call_args[1].get("headers", {})
+
+            # Test retrieve method
+            with patch.object(service, "request") as mock_request:
+                mock_response = MagicMock()
+                mock_response.json.return_value = {
+                    "value": [
+                        {
+                            "id": "test-index-id",
+                            "name": "test-index",
+                            "lastIngestionStatus": "Completed",
+                        }
+                    ]
+                }
+                mock_request.return_value = mock_response
+
+                service.retrieve(name="test-index")
+
+                # Verify request was called with spec parameters
+                assert mock_request.called
+                call_args = mock_request.call_args
+                # Check positional args (method and endpoint)
+                assert call_args[0][0] == "GET"  # method
+                assert str(call_args[0][1]) == "/ecs_/v2/indexes"  # endpoint
+                # Check keyword args (params and headers)
+                assert "params" in call_args[1]
+                assert call_args[1]["params"]["$filter"] == "Name eq 'test-index'"
+                assert call_args[1]["params"]["$expand"] == "dataSource"
+                assert "headers" in call_args[1]
+                assert "x-uipath-folderkey" in call_args[1]["headers"]
+                assert (
+                    call_args[1]["headers"]["x-uipath-folderkey"] == "test-folder-key"
+                )
+
+            # Test search method
+            with patch.object(service, "request") as mock_request:
+                # First call for retrieve
+                retrieve_response = MagicMock()
+                retrieve_response.json.return_value = {
+                    "value": [
+                        {
+                            "id": "test-index-id",
+                            "name": "test-index",
+                            "lastIngestionStatus": "Completed",
+                        }
+                    ]
+                }
+                # Second call for search
+                search_response = MagicMock()
+                search_response.json.return_value = []
+                mock_request.side_effect = [retrieve_response, search_response]
+
+                service.search(
+                    name="test-index", query="test query", number_of_results=10
+                )
+
+                # Check the search request (second call)
+                assert mock_request.call_count == 2
+                search_call = mock_request.call_args_list[1]
+                assert search_call[0][0] == "POST"  # method
+                assert str(search_call[0][1]) == "/ecs_/v1/search"  # endpoint
+                assert "json" in search_call[1]
+                assert search_call[1]["json"]["query"]["query"] == "test query"
+                assert search_call[1]["json"]["query"]["numberOfResults"] == 10
+                assert "headers" in search_call[1]
+                assert "x-uipath-folderkey" in search_call[1]["headers"]
+                assert (
+                    search_call[1]["headers"]["x-uipath-folderkey"] == "test-folder-key"
+                )
+
+            # Test create_index method
+            with patch.object(service, "request") as mock_request:
+                mock_response = MagicMock()
+                mock_response.json.return_value = {
+                    "id": "new-index-id",
+                    "name": "test-new-index",
+                    "lastIngestionStatus": "Queued",
+                }
+                mock_request.return_value = mock_response
+
+                source = BucketSourceConfig(
+                    bucket_name="test-bucket",
+                    folder_path="/test/folder",
+                    directory_path="/",
+                )
+                service.create_index(name="test-new-index", source=source)
+
+                assert mock_request.called
+                call_args = mock_request.call_args
+                assert call_args[0][0] == "POST"  # method
+                assert str(call_args[0][1]) == "/ecs_/v2/indexes/create"  # endpoint
+                assert "json" in call_args[1]
+                assert "headers" in call_args[1]
+                assert "x-uipath-folderkey" in call_args[1]["headers"]
+                assert (
+                    call_args[1]["headers"]["x-uipath-folderkey"] == "test-folder-key"
+                )
+
+            # Test ingest_data method
+            with patch.object(service, "request") as mock_request:
+                mock_request.return_value = MagicMock()
+
+                test_index = ContextGroundingIndex(
+                    id="test-index-id",
+                    name="test-index",
+                    last_ingestion_status="Completed",
+                )
+                service.ingest_data(test_index)
+
+                assert mock_request.called
+                call_args = mock_request.call_args
+                assert call_args[0][0] == "POST"  # method
+                assert (
+                    str(call_args[0][1]) == "/ecs_/v2/indexes/test-index-id/ingest"
+                )  # endpoint
+                assert "headers" in call_args[1]
+                assert "x-uipath-folderkey" in call_args[1]["headers"]
+                assert (
+                    call_args[1]["headers"]["x-uipath-folderkey"] == "test-folder-key"
+                )
+
+            # Test delete_index method
+            with patch.object(service, "request") as mock_request:
+                mock_request.return_value = MagicMock()
+
+                test_index = ContextGroundingIndex(
+                    id="test-index-id",
+                    name="test-index",
+                    last_ingestion_status="Completed",
+                )
+                service.delete_index(test_index)
+
+                assert mock_request.called
+                call_args = mock_request.call_args
+                assert call_args[0][0] == "DELETE"  # method
+                assert (
+                    str(call_args[0][1]) == "/ecs_/v2/indexes/test-index-id"
+                )  # endpoint
+                assert "headers" in call_args[1]
+                assert "x-uipath-folderkey" in call_args[1]["headers"]
+                assert (
+                    call_args[1]["headers"]["x-uipath-folderkey"] == "test-folder-key"
+                )
+
+    def test_retrieve_deep_rag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        citation = Citation(ordinal=1, page_number=1, source="abc", reference="abc")
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/deeprag/test-task-id?$expand=content",
+            status_code=200,
+            json={
+                "id": "test-task-id",
+                "name": "test-deep-rag-task",
+                "createdDate": "2024-01-15T10:30:00Z",
+                "lastDeepRagStatus": "Successful",
+                "content": {
+                    "text": "This is the deep RAG response text.",
+                    "citations": [citation.model_dump()],
+                },
+                "failureReason": None,
+            },
+        )
+
+        response = service.retrieve_deep_rag(id="test-task-id")
+
+        assert isinstance(response, DeepRagResponse)
+        assert response.name == "test-deep-rag-task"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+        assert response.last_deep_rag_status == "Successful"
+        assert response.content is not None
+        assert response.content.text == "This is the deep RAG response text."
+        assert response.content.citations == [citation]
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/deeprag/test-task-id?%24expand=content"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_deep_rag/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_deep_rag_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        citation = Citation(ordinal=1, page_number=1, source="abc", reference="abc")
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/deeprag/test-task-id?$expand=content",
+            status_code=200,
+            json={
+                "id": "test-task-id",
+                "name": "test-deep-rag-task",
+                "createdDate": "2024-01-15T10:30:00Z",
+                "lastDeepRagStatus": "Successful",
+                "content": {
+                    "text": "This is the deep RAG response text.",
+                    "citations": [citation.model_dump()],
+                },
+                "failureReason": None,
+            },
+        )
+
+        response = await service.retrieve_deep_rag_async(id="test-task-id")
+
+        assert isinstance(response, DeepRagResponse)
+        assert response.name == "test-deep-rag-task"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+        assert response.last_deep_rag_status == "Successful"
+        assert response.content is not None
+        assert response.content.text == "This is the deep RAG response text."
+        assert response.content.citations == [citation]
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/deeprag/test-task-id?%24expand=content"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_deep_rag_async/{version}"
+        )
+
+    def test_start_deep_rag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createDeepRag?$select=id,lastDeepRagStatus,createdDate",
+            status_code=200,
+            json={
+                "id": "new-deep-rag-task-id",
+                "lastDeepRagStatus": "Queued",
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        response = service.start_deep_rag(
+            index_name="test-index",
+            name="my-deep-rag-task",
+            prompt="Summarize all documents related to financial reports",
+            glob_pattern="*.pdf",
+            citation_mode=CitationMode.INLINE,
+        )
+
+        assert isinstance(response, DeepRagCreationResponse)
+        assert response.id == "new-deep-rag-task-id"
+        assert response.last_deep_rag_status == "Queued"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createDeepRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-deep-rag-task"
+        assert (
+            request_data["prompt"]
+            == "Summarize all documents related to financial reports"
+        )
+        assert request_data["globPattern"] == "*.pdf"
+        assert request_data["citationMode"] == "Inline"
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_deep_rag/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_start_deep_rag_task(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createDeepRag?$select=id,lastDeepRagStatus,createdDate",
+            status_code=200,
+            json={
+                "id": "new-deep-rag-task-id",
+                "lastDeepRagStatus": "Queued",
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        response = await service.start_deep_rag_async(
+            index_name="test-index",
+            name="my-deep-rag-task",
+            prompt="Summarize all documents related to financial reports",
+            glob_pattern="*.pdf",
+            citation_mode=CitationMode.INLINE,
+        )
+
+        assert isinstance(response, DeepRagCreationResponse)
+        assert response.id == "new-deep-rag-task-id"
+        assert response.last_deep_rag_status == "Queued"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createDeepRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-deep-rag-task"
+        assert (
+            request_data["prompt"]
+            == "Summarize all documents related to financial reports"
+        )
+        assert request_data["globPattern"] == "*.pdf"
+        assert request_data["citationMode"] == "Inline"
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_deep_rag_async/{version}"
+        )
+
+    def test_start_batch_transform(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag",
+            status_code=200,
+            json={
+                "id": "new-batch-transform-id",
+                "lastBatchRagStatus": "Queued",
+                "errorMessage": None,
+            },
+        )
+
+        output_columns = [
+            BatchTransformOutputColumn(
+                name="summary",
+                description="A summary of the document",
+            )
+        ]
+
+        response = service.start_batch_transform(
+            name="my-batch-transform",
+            index_name="test-index",
+            prompt="Summarize all documents",
+            output_columns=output_columns,
+            storage_bucket_folder_path_prefix="data",
+            enable_web_search_grounding=False,
+        )
+
+        assert isinstance(response, BatchTransformCreationResponse)
+        assert response.id == "new-batch-transform-id"
+        assert response.last_batch_rag_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-batch-transform"
+        assert request_data["prompt"] == "Summarize all documents"
+        assert request_data["targetFileGlobPattern"] == "data/*"
+        assert request_data["useWebSearchGrounding"] is False
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_batch_transform/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_start_batch_transform_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag",
+            status_code=200,
+            json={
+                "id": "new-batch-transform-id",
+                "lastBatchRagStatus": "Queued",
+                "errorMessage": None,
+            },
+        )
+
+        output_columns = [
+            BatchTransformOutputColumn(
+                name="summary",
+                description="A summary of the document",
+            )
+        ]
+
+        response = await service.start_batch_transform_async(
+            name="my-batch-transform",
+            index_name="test-index",
+            prompt="Summarize all documents",
+            output_columns=output_columns,
+            storage_bucket_folder_path_prefix="data",
+            enable_web_search_grounding=False,
+        )
+
+        assert isinstance(response, BatchTransformCreationResponse)
+        assert response.id == "new-batch-transform-id"
+        assert response.last_batch_rag_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag"
+            in str(sent_requests[3].url)
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_batch_transform_async/{version}"
+        )
+
+    def test_start_batch_transform_with_target_file_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag",
+            status_code=200,
+            json={
+                "id": "new-batch-transform-id",
+                "lastBatchRagStatus": "Queued",
+                "errorMessage": None,
+            },
+        )
+
+        output_columns = [
+            BatchTransformOutputColumn(
+                name="Emoji",
+                description="Emoji",
+            ),
+            BatchTransformOutputColumn(
+                name="Language",
+                description="The output Language should be loaded from the row",
+            ),
+        ]
+
+        response = service.start_batch_transform(
+            name="my-batch-transform",
+            index_name="test-index",
+            prompt="Extract emojis and language",
+            output_columns=output_columns,
+            target_file_name="size_1KB.csv",
+            enable_web_search_grounding=True,
+        )
+
+        assert isinstance(response, BatchTransformCreationResponse)
+        assert response.id == "new-batch-transform-id"
+        assert response.last_batch_rag_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-batch-transform"
+        assert request_data["prompt"] == "Extract emojis and language"
+        assert request_data["targetFileGlobPattern"] == "size_1KB.csv"
+        assert request_data["useWebSearchGrounding"] is True
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_batch_transform/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_start_batch_transform_async_with_target_file_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag",
+            status_code=200,
+            json={
+                "id": "new-batch-transform-id",
+                "lastBatchRagStatus": "Queued",
+                "errorMessage": None,
+            },
+        )
+
+        output_columns = [
+            BatchTransformOutputColumn(
+                name="Emoji",
+                description="Emoji",
+            ),
+            BatchTransformOutputColumn(
+                name="Language",
+                description="The output Language should be loaded from the row",
+            ),
+        ]
+
+        response = await service.start_batch_transform_async(
+            name="my-batch-transform",
+            index_name="test-index",
+            prompt="Extract emojis and language",
+            output_columns=output_columns,
+            target_file_name="size_1KB.csv",
+            enable_web_search_grounding=True,
+        )
+
+        assert isinstance(response, BatchTransformCreationResponse)
+        assert response.id == "new-batch-transform-id"
+        assert response.last_batch_rag_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-batch-transform"
+        assert request_data["prompt"] == "Extract emojis and language"
+        assert request_data["targetFileGlobPattern"] == "size_1KB.csv"
+        assert request_data["useWebSearchGrounding"] is True
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_batch_transform_async/{version}"
+        )
+
+    def test_start_batch_transform_with_combined_prefix_and_filename(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag",
+            status_code=200,
+            json={
+                "id": "new-batch-transform-id",
+                "lastBatchRagStatus": "Queued",
+                "errorMessage": None,
+            },
+        )
+
+        output_columns = [
+            BatchTransformOutputColumn(
+                name="summary",
+                description="A summary of the document",
+            )
+        ]
+
+        response = service.start_batch_transform(
+            name="my-batch-transform",
+            index_name="test-index",
+            prompt="Summarize the document",
+            output_columns=output_columns,
+            storage_bucket_folder_path_prefix="data",
+            target_file_name="size_1KB.csv",
+            enable_web_search_grounding=False,
+        )
+
+        assert isinstance(response, BatchTransformCreationResponse)
+        assert response.id == "new-batch-transform-id"
+        assert response.last_batch_rag_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[3].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/test-index-id/createBatchRag"
+            in str(sent_requests[3].url)
+        )
+
+        request_data = json.loads(sent_requests[3].content)
+        assert request_data["name"] == "my-batch-transform"
+        assert request_data["prompt"] == "Summarize the document"
+        # Verify that both prefix and filename are combined
+        assert request_data["targetFileGlobPattern"] == "data/size_1KB.csv"
+        assert request_data["useWebSearchGrounding"] is False
+
+        assert HEADER_USER_AGENT in sent_requests[3].headers
+        assert (
+            sent_requests[3].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_batch_transform/{version}"
+        )
+
+    def test_retrieve_batch_transform(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        response = service.retrieve_batch_transform(id="test-batch-id")
+
+        assert isinstance(response, BatchTransformResponse)
+        assert response.id == "test-batch-id"
+        assert response.name == "test-batch-transform"
+        assert response.last_batch_rag_status == BatchTransformStatus.SUCCESSFUL
+        assert response.prompt == "Summarize documents"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_batch_transform/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_batch_transform_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        response = await service.retrieve_batch_transform_async(id="test-batch-id")
+
+        assert isinstance(response, BatchTransformResponse)
+        assert response.id == "test-batch-id"
+        assert response.name == "test-batch-transform"
+        assert response.last_batch_rag_status == BatchTransformStatus.SUCCESSFUL
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_batch_transform_async/{version}"
+        )
+
+    def test_download_batch_transform_result(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": "https://storage.example.com/result.csv",
+                "isEncrypted": False,
+            },
+        )
+
+        httpx_mock.add_response(
+            url="https://storage.example.com/result.csv",
+            status_code=200,
+            content=b"col1,col2\nval1,val2",
+        )
+
+        destination = tmp_path / "result.csv"
+        service.download_batch_transform_result(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"col1,col2\nval1,val2"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id"
+        )
+
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.download_batch_transform_result/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_download_batch_transform_result_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": "https://storage.example.com/result.csv",
+                "isEncrypted": False,
+            },
+        )
+
+        httpx_mock.add_response(
+            url="https://storage.example.com/result.csv",
+            status_code=200,
+            content=b"col1,col2\nval1,val2",
+        )
+
+        destination = tmp_path / "result.csv"
+        await service.download_batch_transform_result_async(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"col1,col2\nval1,val2"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "GET"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id"
+        )
+
+        assert sent_requests[1].method == "GET"
+        assert (
+            sent_requests[1].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri"
+        )
+
+        assert HEADER_USER_AGENT in sent_requests[1].headers
+        assert (
+            sent_requests[1].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.download_batch_transform_result_async/{version}"
+        )
+
+    def test_download_batch_transform_result_creates_nested_directories(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": "https://storage.example.com/result.csv",
+                "isEncrypted": False,
+            },
+        )
+
+        httpx_mock.add_response(
+            url="https://storage.example.com/result.csv",
+            status_code=200,
+            content=b"col1,col2\nval1,val2",
+        )
+
+        destination = tmp_path / "output" / "nested" / "result.csv"
+        service.download_batch_transform_result(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"col1,col2\nval1,val2"
+        assert destination.parent.exists()
+
+    def test_download_batch_transform_result_encrypted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/DownloadBlob",
+                "isEncrypted": True,
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/DownloadBlob",
+            status_code=200,
+            content=b"encrypted,data\nval1,val2",
+        )
+
+        destination = tmp_path / "result_encrypted.csv"
+        service.download_batch_transform_result(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"encrypted,data\nval1,val2"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        # Verify the DownloadBlob endpoint was called with Authorization header
+        download_request = sent_requests[2]
+        assert download_request.method == "GET"
+        assert "/DownloadBlob" in str(download_request.url)
+        assert "Authorization" in download_request.headers
+        assert download_request.headers["Authorization"].startswith("Bearer ")
+
+    def test_create_ephemeral_index(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        import uuid
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral",
+            status_code=200,
+            json={
+                "id": "ephemeral-index-id",
+                "name": "ephemeral-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        attachment_ids = [str(uuid.uuid4()), str(uuid.uuid4())]
+        index = service.create_ephemeral_index(
+            usage="DeepRAG",
+            attachments=attachment_ids,
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "ephemeral-index-id"
+        assert index.name == "ephemeral-index"
+        assert index.last_ingestion_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "POST"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral"
+        )
+
+        request_data = json.loads(sent_requests[0].content)
+        assert request_data["usage"] == "DeepRAG"
+        assert "dataSource" in request_data
+        assert request_data["dataSource"]["attachments"] == [
+            str(att) for att in attachment_ids
+        ]
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.create_ephemeral_index/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_create_ephemeral_index_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        import uuid
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral",
+            status_code=200,
+            json={
+                "id": "ephemeral-index-id",
+                "name": "ephemeral-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        attachment_ids = [str(uuid.uuid4()), str(uuid.uuid4())]
+        index = await service.create_ephemeral_index_async(
+            usage="DeepRAG",
+            attachments=attachment_ids,
+        )
+
+        assert isinstance(index, ContextGroundingIndex)
+        assert index.id == "ephemeral-index-id"
+        assert index.name == "ephemeral-index"
+        assert index.last_ingestion_status == "Queued"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "POST"
+        assert (
+            sent_requests[0].url
+            == f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral"
+        )
+
+        request_data = json.loads(sent_requests[0].content)
+        assert request_data["usage"] == "DeepRAG"
+        assert "dataSource" in request_data
+        assert request_data["dataSource"]["attachments"] == [
+            str(att) for att in attachment_ids
+        ]
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.create_ephemeral_index_async/{version}"
+        )
+
+    def test_create_ephemeral_index_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        import uuid
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral",
+            status_code=200,
+            json={
+                "id": "ephemeral-index-id",
+                "name": "ephemeral-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        attachment_ids = [str(uuid.uuid4())]
+        service.create_ephemeral_index(
+            usage="DeepRAG",
+            attachments=attachment_ids,
+            folder_key="test-folder-key",
+        )
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests is not None
+        assert "x-uipath-folderkey" in sent_requests[0].headers
+        assert sent_requests[0].headers["x-uipath-folderkey"] == "test-folder-key"
+
+    @pytest.mark.anyio
+    async def test_create_ephemeral_index_async_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        import uuid
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/createephemeral",
+            status_code=200,
+            json={
+                "id": "ephemeral-index-id",
+                "name": "ephemeral-index",
+                "lastIngestionStatus": "Queued",
+            },
+        )
+
+        attachment_ids = [str(uuid.uuid4())]
+        await service.create_ephemeral_index_async(
+            usage="DeepRAG",
+            attachments=attachment_ids,
+            folder_key="test-folder-key",
+        )
+
+        sent_requests = httpx_mock.get_requests()
+        assert sent_requests is not None
+        assert "x-uipath-folderkey" in sent_requests[0].headers
+        assert sent_requests[0].headers["x-uipath-folderkey"] == "test-folder-key"
+
+    @pytest.mark.anyio
+    async def test_download_batch_transform_result_async_creates_nested_directories(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": "https://storage.example.com/result.csv",
+                "isEncrypted": False,
+            },
+        )
+
+        httpx_mock.add_response(
+            url="https://storage.example.com/result.csv",
+            status_code=200,
+            content=b"col1,col2\nval1,val2",
+        )
+
+        destination = tmp_path / "output" / "nested" / "result.csv"
+        await service.download_batch_transform_result_async(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"col1,col2\nval1,val2"
+        assert destination.parent.exists()
+
+    @pytest.mark.anyio
+    async def test_start_deep_rag_ephemeral_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes/ephemeral-index-id/createDeepRag?$select=id,lastDeepRagStatus,createdDate",
+            status_code=200,
+            json={
+                "id": "new-deep-rag-task-id",
+                "lastDeepRagStatus": "Queued",
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        response = await service.start_deep_rag_ephemeral_async(
+            name="my-ephemeral-deep-rag-task",
+            prompt="Summarize all documents related to financial reports",
+            glob_pattern="*.pdf",
+            citation_mode=CitationMode.INLINE,
+            index_id="ephemeral-index-id",
+        )
+
+        assert isinstance(response, DeepRagCreationResponse)
+        assert response.id == "new-deep-rag-task-id"
+        assert response.last_deep_rag_status == "Queued"
+        assert response.created_date == "2024-01-15T10:30:00Z"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        assert sent_requests[0].method == "POST"
+        assert (
+            f"{base_url}{org}{tenant}/ecs_/v2/indexes/ephemeral-index-id/createDeepRag"
+            in str(sent_requests[0].url)
+        )
+
+        request_data = json.loads(sent_requests[0].content)
+        assert request_data["name"] == "my-ephemeral-deep-rag-task"
+        assert (
+            request_data["prompt"]
+            == "Summarize all documents related to financial reports"
+        )
+        assert request_data["globPattern"] == "*.pdf"
+        assert request_data["citationMode"] == "Inline"
+
+        assert HEADER_USER_AGENT in sent_requests[0].headers
+        assert (
+            sent_requests[0].headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.start_deep_rag_ephemeral_async/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_download_batch_transform_result_async_encrypted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        tmp_path,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id",
+            status_code=200,
+            json={
+                "id": "test-batch-id",
+                "name": "test-batch-transform",
+                "lastBatchRagStatus": "Successful",
+                "prompt": "Summarize documents",
+                "targetFileGlobPattern": "**",
+                "useWebSearchGrounding": False,
+                "outputColumns": [
+                    {"name": "summary", "description": "Document summary"}
+                ],
+                "createdDate": "2024-01-15T10:30:00Z",
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/GetReadUri",
+            status_code=200,
+            json={
+                "uri": f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/DownloadBlob",
+                "isEncrypted": True,
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/batchRag/test-batch-id/DownloadBlob",
+            status_code=200,
+            content=b"encrypted,data\nval1,val2",
+        )
+
+        destination = tmp_path / "result_encrypted.csv"
+        await service.download_batch_transform_result_async(
+            id="test-batch-id",
+            destination_path=str(destination),
+        )
+
+        assert destination.exists()
+        assert destination.read_bytes() == b"encrypted,data\nval1,val2"
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        # Verify the DownloadBlob endpoint was called with Authorization header
+        download_request = sent_requests[2]
+        assert download_request.method == "GET"
+        assert "/DownloadBlob" in str(download_request.url)
+        assert "Authorization" in download_request.headers
+        assert download_request.headers["Authorization"].startswith("Bearer ")
+
+    def test_unified_search(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1.2/search/test-index-id",
+            status_code=200,
+            json={
+                "semanticResults": {
+                    "metadata": {
+                        "operation_id": "test-op",
+                        "strategy": "test-strategy",
+                    },
+                    "values": [
+                        {
+                            "id": "result-1",
+                            "source": "test-source",
+                            "page_number": 1,
+                            "content": "Test content",
+                            "score": 0.95,
+                        }
+                    ],
+                },
+                "explanation": "test explanation",
+            },
+        )
+
+        response = service.unified_search(
+            name="test-index",
+            query="test query",
+            search_mode=SearchMode.SEMANTIC,
+            number_of_results=5,
+        )
+
+        assert isinstance(response, UnifiedQueryResult)
+        assert response.explanation == "test explanation"
+        assert response.semantic_results is not None
+        assert response.semantic_results.metadata is not None
+        assert response.semantic_results.metadata.operation_id == "test-op"
+        assert response.semantic_results.metadata.strategy == "test-strategy"
+        assert len(response.semantic_results.values) == 1
+        assert response.semantic_results.values[0].id == "result-1"
+        assert response.semantic_results.values[0].source == "test-source"
+        assert response.semantic_results.values[0].page_number == 1
+        assert response.semantic_results.values[0].content == "Test content"
+        assert response.semantic_results.values[0].score == 0.95
+
+        sent_requests = httpx_mock.get_requests()
+        if sent_requests is None:
+            raise Exception("No request was sent")
+
+        search_request = sent_requests[3]
+        assert search_request.method == "POST"
+        assert (
+            str(search_request.url)
+            == f"{base_url}{org}{tenant}/ecs_/v1.2/search/test-index-id"
+        )
+        request_body = json.loads(search_request.content)
+        assert request_body["searchMode"] == "Semantic"
+        assert request_body["query"] == "test query"
+        assert request_body["semanticSearchOptions"]["numberOfResults"] == 5
+
+        assert HEADER_USER_AGENT in search_request.headers
+        assert (
+            search_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.unified_search/{version}"
+        )
+
+    @pytest.mark.anyio
+    async def test_unified_search_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1.2/search/test-index-id",
+            status_code=200,
+            json={
+                "semanticResults": {
+                    "metadata": {
+                        "operation_id": "test-op",
+                        "strategy": "test-strategy",
+                    },
+                    "values": [
+                        {
+                            "id": "result-1",
+                            "source": "test-source",
+                            "page_number": 1,
+                            "content": "Test content",
+                            "score": 0.95,
+                        }
+                    ],
+                },
+                "explanation": "test explanation",
+            },
+        )
+
+        response = await service.unified_search_async(
+            name="test-index",
+            query="test query",
+            search_mode=SearchMode.SEMANTIC,
+        )
+
+        assert isinstance(response, UnifiedQueryResult)
+        assert response.explanation == "test explanation"
+        assert response.semantic_results is not None
+        assert response.semantic_results.metadata is not None
+        assert len(response.semantic_results.values) == 1
+
+    def test_unified_search_with_scope(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ContextGroundingService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "test-index",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "test-folder-path",
+                    }
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/ecs_/v1.2/search/test-index-id",
+            status_code=200,
+            json={
+                "semanticResults": {"values": []},
+                "explanation": None,
+            },
+        )
+
+        scope = UnifiedSearchScope(folder="docs", extension=".pdf")
+
+        response = service.unified_search(
+            name="test-index",
+            query="test query",
+            scope=scope,
+        )
+
+        assert isinstance(response, UnifiedQueryResult)
+
+        sent_requests = httpx_mock.get_requests()
+        search_request = sent_requests[3]
+        request_body = json.loads(search_request.content)
+        assert "filter" not in request_body
+        assert request_body["scope"]["folder"] == "docs"
+        assert request_body["scope"]["extension"] == ".pdf"
+
+
+class TestJobKeyHeader:
+    """X-UiPath-JobKey is attached to outbound ECS calls when UIPATH_JOB_KEY is set."""
+
+    _INDEX = ContextGroundingIndex(
+        id="test-index-id",
+        name="test-index",
+        last_ingestion_status="Completed",
+    )
+
+    def test_ingest_data_carries_job_key_header(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv(ENV_JOB_KEY, "job-key-ingest")
+
+        with patch.object(service, "request") as mock_request:
+            mock_request.return_value = MagicMock()
+            service.ingest_data(self._INDEX, folder_key="test-folder-key")
+
+        headers = mock_request.call_args[1]["headers"]
+        assert headers[HEADER_JOB_KEY] == "job-key-ingest"
+
+    @pytest.mark.anyio
+    async def test_ingest_data_async_carries_job_key_header(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv(ENV_JOB_KEY, "job-key-ingest-async")
+
+        with patch.object(service, "request_async") as mock_request:
+            mock_request.return_value = MagicMock()
+            await service.ingest_data_async(self._INDEX, folder_key="test-folder-key")
+
+        headers = mock_request.call_args[1]["headers"]
+        assert headers[HEADER_JOB_KEY] == "job-key-ingest-async"
+
+    def test_unified_search_carries_job_key_header(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv(ENV_JOB_KEY, "job-key-search")
+
+        with patch.object(service, "request") as mock_request:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+                "semanticResults": {"values": []},
+                "explanation": None,
+            }
+            mock_request.return_value = mock_response
+            with patch.object(service, "retrieve", return_value=self._INDEX):
+                service.unified_search(
+                    name="test-index",
+                    query="test query",
+                    folder_key="test-folder-key",
+                )
+
+        headers = mock_request.call_args[1]["headers"]
+        assert headers[HEADER_JOB_KEY] == "job-key-search"
+
+    def test_start_deep_rag_carries_job_key_header(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv(ENV_JOB_KEY, "job-key-deeprag")
+
+        with patch.object(service, "request") as mock_request:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+                "id": "new-deep-rag-task-id",
+                "lastDeepRagStatus": "Queued",
+                "createdDate": "2024-01-15T10:30:00Z",
+            }
+            mock_request.return_value = mock_response
+            service.start_deep_rag(
+                index_id="test-index-id",
+                name="my-deep-rag-task",
+                prompt="Summarize",
+                glob_pattern="*.pdf",
+                citation_mode=CitationMode.INLINE,
+                folder_key="test-folder-key",
+            )
+
+        headers = mock_request.call_args[1]["headers"]
+        assert headers[HEADER_JOB_KEY] == "job-key-deeprag"
+
+    def test_start_batch_transform_carries_job_key_header(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv(ENV_JOB_KEY, "job-key-batch")
+
+        with patch.object(service, "request") as mock_request:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+                "id": "new-batch-id",
+                "lastBatchRagStatus": "Queued",
+            }
+            mock_request.return_value = mock_response
+            service.start_batch_transform(
+                index_id="test-index-id",
+                name="my-batch-task",
+                prompt="Extract",
+                output_columns=[
+                    BatchTransformOutputColumn(name="col1", description="d")
+                ],
+                enable_web_search_grounding=False,
+                folder_key="test-folder-key",
+            )
+
+        headers = mock_request.call_args[1]["headers"]
+        assert headers[HEADER_JOB_KEY] == "job-key-batch"
+
+    def test_ingest_data_omits_job_key_header_when_env_unset(
+        self,
+        service: ContextGroundingService,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.delenv(ENV_JOB_KEY, raising=False)
+
+        with patch.object(service, "request") as mock_request:
+            mock_request.return_value = MagicMock()
+            service.ingest_data(self._INDEX, folder_key="test-folder-key")
+
+        headers = mock_request.call_args[1]["headers"]
+        assert HEADER_JOB_KEY not in headers
diff --git a/packages/uipath-platform/tests/services/test_conversations_service.py b/packages/uipath-platform/tests/services/test_conversations_service.py
new file mode 100644
index 000000000..37e08bdfa
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_conversations_service.py
@@ -0,0 +1,163 @@
+import pytest
+from pytest_httpx import HTTPXMock
+from uipath.core.chat import UiPathConversationMessage
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import ConversationsService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig, execution_context: UiPathExecutionContext
+) -> ConversationsService:
+    return ConversationsService(config=config, execution_context=execution_context)
+
+
+class TestConversationsService:
+    class TestRetrieveMessage:
+        @pytest.mark.anyio
+        async def test_retrieve_message(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ConversationsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test retrieving a specific message from an exchange."""
+            conversation_id = "123"
+            exchange_id = "202cf2d1-926e-422d-8cf2-4f5735fa91fa"
+            message_id = "08de239e-90da-4d17-b986-b7785268d8d7"
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/autopilotforeveryone_/api/v1/conversation/{conversation_id}/exchange/{exchange_id}/message/{message_id}",
+                status_code=200,
+                json={
+                    "messageId": message_id,
+                    "role": "assistant",
+                    "contentParts": [],
+                    "toolCalls": [],
+                    "createdAt": "2024-01-01T00:00:00Z",
+                    "updatedAt": "2024-01-01T00:00:00Z",
+                },
+            )
+
+            result = await service.retrieve_message_async(
+                conversation_id=conversation_id,
+                exchange_id=exchange_id,
+                message_id=message_id,
+            )
+
+            assert isinstance(result, UiPathConversationMessage)
+            assert result.message_id == message_id
+            assert result.role == "assistant"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert (
+                sent_request.url
+                == f"{base_url}{org}{tenant}/autopilotforeveryone_/api/v1/conversation/{conversation_id}/exchange/{exchange_id}/message/{message_id}"
+            )
+
+        @pytest.mark.anyio
+        async def test_retrieve_message_with_content_parts(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ConversationsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            """Test retrieving a message with content parts."""
+            conversation_id = "123"
+            exchange_id = "202cf2d1-926e-422d-8cf2-4f5735fa91fa"
+            message_id = "08de239e-90da-4d17-b986-b7785268d8d7"
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/autopilotforeveryone_/api/v1/conversation/{conversation_id}/exchange/{exchange_id}/message/{message_id}",
+                status_code=200,
+                json={
+                    "messageId": message_id,
+                    "role": "user",
+                    "contentParts": [
+                        {
+                            "contentPartId": "cp-1",
+                            "mimeType": "text/plain",
+                            "data": {"inline": "Hello, world!"},
+                            "citations": [],
+                            "createdAt": "2024-01-01T00:00:00Z",
+                            "updatedAt": "2024-01-01T00:00:00Z",
+                        }
+                    ],
+                    "toolCalls": [],
+                    "createdAt": "2024-01-01T00:00:00Z",
+                    "updatedAt": "2024-01-01T00:00:00Z",
+                },
+            )
+
+            result = await service.retrieve_message_async(
+                conversation_id=conversation_id,
+                exchange_id=exchange_id,
+                message_id=message_id,
+            )
+
+            assert isinstance(result, UiPathConversationMessage)
+            assert result.message_id == message_id
+            assert result.role == "user"
+            assert result.content_parts is not None
+            assert len(result.content_parts) == 1
+            assert result.content_parts[0].content_part_id == "cp-1"
+            assert result.content_parts[0].mime_type == "text/plain"
+
+        @pytest.mark.anyio
+        async def test_retrieve_message_with_tool_calls(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ConversationsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            """Test retrieving a message with tool calls."""
+            conversation_id = "123"
+            exchange_id = "202cf2d1-926e-422d-8cf2-4f5735fa91fa"
+            message_id = "08de239e-90da-4d17-b986-b7785268d8d7"
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/autopilotforeveryone_/api/v1/conversation/{conversation_id}/exchange/{exchange_id}/message/{message_id}",
+                status_code=200,
+                json={
+                    "messageId": message_id,
+                    "role": "assistant",
+                    "contentParts": [],
+                    "toolCalls": [
+                        {
+                            "toolCallId": "tc-1",
+                            "name": "get_weather",
+                            "input": {"city": "San Francisco"},
+                            "createdAt": "2024-01-01T00:00:00Z",
+                            "updatedAt": "2024-01-01T00:00:00Z",
+                        }
+                    ],
+                    "createdAt": "2024-01-01T00:00:00Z",
+                    "updatedAt": "2024-01-01T00:00:00Z",
+                },
+            )
+
+            result = await service.retrieve_message_async(
+                conversation_id=conversation_id,
+                exchange_id=exchange_id,
+                message_id=message_id,
+            )
+
+            assert isinstance(result, UiPathConversationMessage)
+            assert result.message_id == message_id
+            assert result.role == "assistant"
+            assert result.tool_calls is not None
+            assert len(result.tool_calls) == 1
+            assert result.tool_calls[0].tool_call_id == "tc-1"
+            assert result.tool_calls[0].name == "get_weather"
diff --git a/packages/uipath-platform/tests/services/test_documents_service.py b/packages/uipath-platform/tests/services/test_documents_service.py
new file mode 100644
index 000000000..1a6543afb
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_documents_service.py
@@ -0,0 +1,3644 @@
+import json
+from pathlib import Path
+from typing import Any
+from unittest.mock import Mock, patch
+from uuid import UUID, uuid4
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.documents import (
+    ActionPriority,
+    ClassificationResult,
+    DocumentsService,
+    ExtractionResponse,
+    ProjectType,
+    ValidateClassificationAction,
+    ValidateExtractionAction,
+)
+from uipath.platform.errors import (
+    OperationFailedException,
+    OperationNotCompleteException,
+)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+):
+    return DocumentsService(
+        config=config,
+        execution_context=execution_context,
+        polling_interval=0.001,  # 1ms for fast tests
+        polling_timeout=10,  # 10 seconds for tests
+    )
+
+
+@pytest.fixture
+def documents_tests_data_path(tests_data_path: Path) -> Path:
+    return tests_data_path / "documents_service"
+
+
+@pytest.fixture
+def classification_response(documents_tests_data_path: Path) -> dict:  # type: ignore
+    with open(documents_tests_data_path / "classification_response.json", "r") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def ixp_extraction_response(documents_tests_data_path: Path) -> dict:  # type: ignore
+    with open(documents_tests_data_path / "ixp_extraction_response.json", "r") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def modern_extraction_response(documents_tests_data_path: Path) -> dict:  # type: ignore
+    with open(documents_tests_data_path / "modern_extraction_response.json", "r") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def create_validation_action_response(documents_tests_data_path: Path) -> dict:  # type: ignore
+    with open(
+        documents_tests_data_path
+        / "extraction_validation_action_response_unassigned.json",
+        "r",
+    ) as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def extraction_validation_action_response_completed(
+    documents_tests_data_path: Path,
+) -> dict:  # type: ignore
+    with open(
+        documents_tests_data_path
+        / "extraction_validation_action_response_completed.json",
+        "r",
+    ) as f:
+        return json.load(f)
+
+
+class TestDocumentsService:
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.parametrize(
+        "tag,version,project_name,project_type,file,file_path,error",
+        [
+            (
+                "Production",
+                None,
+                "TestProject",
+                ProjectType.MODERN,
+                None,
+                None,
+                "Exactly one of `file, file_path` must be provided",
+            ),
+            (
+                "Production",
+                4,
+                "TestProject",
+                ProjectType.MODERN,
+                b"something",
+                None,
+                "Exactly one of `tag, version` must be provided",
+            ),
+            (
+                "Production",
+                None,
+                "TestProject",
+                ProjectType.MODERN,
+                b"something",
+                "something",
+                "Exactly one of `file, file_path` must be provided",
+            ),
+            (
+                "Production",
+                None,
+                None,
+                ProjectType.PRETRAINED,
+                b"something",
+                None,
+                "`tag` must not be provided",
+            ),
+            (
+                None,
+                None,
+                "TestProject",
+                ProjectType.PRETRAINED,
+                b"something",
+                None,
+                "`project_name` must not be provided",
+            ),
+            (
+                None,
+                None,
+                None,
+                ProjectType.PRETRAINED,
+                b"something",
+                "pathto/file.pdf",
+                "Exactly one of `file, file_path` must be provided",
+            ),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_classify_with_invalid_parameters(
+        self,
+        service: DocumentsService,
+        mode: str,
+        tag,
+        version,
+        project_name,
+        project_type,
+        file,
+        file_path,
+        error,
+    ):
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match=error,
+        ):
+            if mode == "async":
+                await service.classify_async(
+                    tag=tag,
+                    version=version,
+                    project_name=project_name,
+                    project_type=project_type,
+                    file=file,
+                    file_path=file_path,
+                )
+            else:
+                service.classify(
+                    tag=tag,
+                    version=version,
+                    project_name=project_name,
+                    project_type=project_type,
+                    file=file,
+                    file_path=file_path,
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_classification_result_predefined(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        document_id = str(uuid4())
+        document_type_id = "receipts"
+        operation_id = str(uuid4())
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.PRETRAINED.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            "ml-classification"
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        classification_response["classificationResults"][0]["DocumentId"] = document_id
+        classification_response["classificationResults"][0]["DocumentTypeId"] = (
+            document_type_id
+        )
+        classification_result = ClassificationResult.model_validate(
+            classification_response["classificationResults"][0]
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": modern_extraction_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                classification_result=classification_result
+            )
+        else:
+            response = service.extract(classification_result=classification_result)
+
+        # ASSERT
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.PRETRAINED
+        modern_extraction_response["extractorId"] = document_type_id
+        modern_extraction_response["tag"] = None
+        modern_extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == modern_extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_classification_result_modern_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        document_type_id = str(uuid4())
+        classifier_id = "classifier_2"
+        version = 2
+        extractor_id = "extractor_2"
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            classifier_id
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        classification_response["classificationResults"][0]["DocumentId"] = document_id
+        classification_response["classificationResults"][0]["DocumentTypeId"] = (
+            document_type_id
+        )
+        classification_result = ClassificationResult.model_validate(
+            classification_response["classificationResults"][0]
+        )
+
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "id": classifier_id,
+                "projectVersion": version,
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "extractors": [
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 1,
+                        "documentTypeId": str(uuid4()),
+                    },
+                    {
+                        "id": extractor_id,
+                        "projectVersion": version,
+                        "documentTypeId": document_type_id,
+                    },
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 3,
+                        "documentTypeId": str(uuid4()),
+                    },
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        statuses = ["NotStarted", "Running", "Succeeded"]
+        for status in statuses:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/result/{operation_id}?api-version=1.1",
+                status_code=200,
+                match_headers={
+                    "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+                },
+                json={"status": status, "result": modern_extraction_response},
+            )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                classification_result=classification_result
+            )
+        else:
+            response = service.extract(classification_result=classification_result)
+
+        # ASSERT
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.MODERN
+        modern_extraction_response["extractorId"] = extractor_id
+        modern_extraction_response["tag"] = None
+        modern_extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == modern_extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_classification_result_modern_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        document_type_id = str(uuid4())
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = None
+        classification_response["classificationResults"][0]["Tag"] = "Production"
+        classification_response["classificationResults"][0]["DocumentId"] = document_id
+        classification_response["classificationResults"][0]["DocumentTypeId"] = (
+            document_type_id
+        )
+        classification_result = ClassificationResult.model_validate(
+            classification_response["classificationResults"][0]
+        )
+
+        operation_id = str(uuid4())
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/document-types/{document_type_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/document-types/{document_type_id}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": modern_extraction_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                classification_result=classification_result
+            )
+        else:
+            response = service.extract(classification_result=classification_result)
+
+        # ASSERT
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.MODERN
+        modern_extraction_response["extractorId"] = None
+        modern_extraction_response["tag"] = "Production"
+        modern_extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == modern_extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_classify_predefined(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        document_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        operation_id = str(uuid4())
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/classification/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/classification/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": classification_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.classify_async(
+                project_type=ProjectType.PRETRAINED,
+                file=b"test content",
+            )
+        else:
+            response = service.classify(
+                project_type=ProjectType.PRETRAINED,
+                file=b"test content",
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.PRETRAINED.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            "ml-classification"
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        assert (
+            response[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_classify_with_version_classifier_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        version = 5
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProject"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "classifiers": [
+                    {"id": "classifier_1", "projectVersion": 1},
+                    {"id": "classifier_2", "projectVersion": 2},
+                    {"id": "classifier_3", "projectVersion": 3},
+                ]
+            },
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match=f"Classifier for version '{version}' not found.",
+        ):
+            if mode == "async":
+                await service.classify_async(
+                    version=version,
+                    project_name="TestProject",
+                    project_type=ProjectType.MODERN,
+                    file=b"test content",
+                )
+            else:
+                service.classify(
+                    version=version,
+                    project_name="TestProject",
+                    project_type=ProjectType.MODERN,
+                    file=b"test content",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_classify_modern_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+        version = 2
+        classifier_id = "classifier_2"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProject"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "classifiers": [
+                    {"id": "classifier_1", "projectVersion": 1},
+                    {"id": classifier_id, "projectVersion": version},
+                    {"id": "classifier_3", "projectVersion": 3},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/classification/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": classification_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.classify_async(
+                version=version,
+                project_name="TestProject",
+                project_type=ProjectType.MODERN,
+                file=b"test content",
+            )
+        else:
+            response = service.classify(
+                version=version,
+                project_name="TestProject",
+                project_type=ProjectType.MODERN,
+                file=b"test content",
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            classifier_id
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        assert (
+            response[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_classify_modern_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        classification_response: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProject"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/tags?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "tags": [
+                    {"name": "Production"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        operation_id = str(uuid4())
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/classification/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/classification/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": classification_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.classify_async(
+                tag="Production",
+                project_name="TestProject",
+                project_type=ProjectType.MODERN,
+                file=b"test content",
+            )
+        else:
+            response = service.classify(
+                tag="Production",
+                project_name="TestProject",
+                project_type=ProjectType.MODERN,
+                file=b"test content",
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = None
+        classification_response["classificationResults"][0]["Tag"] = "Production"
+        assert (
+            response[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "tag,version,project_name,file,file_path,classification_result,project_type,document_type_name, error",
+        [
+            (
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                "`classification_result` must be provided",
+            ),
+            (
+                "live",
+                None,
+                "TestProject",
+                None,
+                None,
+                None,
+                None,
+                None,
+                "`classification_result` must be provided",
+            ),
+            (
+                "live",
+                None,
+                "TestProject",
+                None,
+                None,
+                None,
+                ProjectType.IXP,
+                None,
+                "`classification_result` must be provided",
+            ),
+            (
+                "live",
+                None,
+                "TestProject",
+                b"something",
+                None,
+                None,
+                ProjectType.MODERN,
+                None,
+                "`document_type_name` must be provided",
+            ),
+            (
+                "live",
+                None,
+                "TestProject",
+                b"something",
+                None,
+                "dummy classification result",
+                ProjectType.MODERN,
+                "dummy doctype",
+                "`classification_result` must not be provided",
+            ),
+            (
+                None,
+                None,
+                "TestProject",
+                b"something",
+                None,
+                None,
+                ProjectType.MODERN,
+                "dummy doctype",
+                "Exactly one of `version, tag` must be provided",
+            ),
+            (
+                "live",
+                None,
+                "TestProject",
+                b"something",
+                "path/to/file.pdf",
+                None,
+                ProjectType.MODERN,
+                "dummy doctype",
+                "Exactly one of `file, file_path` must be provided",
+            ),
+            (
+                "live",
+                4,
+                "TestProject",
+                b"something",
+                None,
+                None,
+                ProjectType.MODERN,
+                "dummy doctype",
+                "Exactly one of `version, tag` must be provided",
+            ),
+            (
+                "live",
+                None,
+                None,
+                b"something",
+                None,
+                None,
+                ProjectType.PRETRAINED,
+                "dummy doctype",
+                "`tag` must not be provided",
+            ),
+        ],
+    )
+    async def test_extract_with_invalid_parameters(
+        self,
+        service: DocumentsService,
+        mode: str,
+        tag,
+        version,
+        project_name,
+        file,
+        file_path,
+        classification_result,
+        project_type,
+        document_type_name,
+        error,
+    ):
+        # ACT & ASSERT
+        with pytest.raises(ValueError, match=error):
+            if mode == "async":
+                await service.extract_async(
+                    tag=tag,
+                    version=version,
+                    project_name=project_name,
+                    project_type=project_type,
+                    file=file,
+                    file_path=file_path,
+                    classification_result=classification_result,
+                    document_type_name=document_type_name,
+                )
+            else:
+                service.extract(
+                    tag=tag,
+                    version=version,
+                    project_name=project_name,
+                    project_type=project_type,
+                    file=file,
+                    file_path=file_path,
+                    classification_result=classification_result,
+                    document_type_name=document_type_name,
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_ixp_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+        extractor_id = "ixp_3"
+        version = 3
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=IXP",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProjectIXP"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "extractors": [
+                    {
+                        "id": extractor_id,
+                        "projectVersion": version,
+                        "documentTypeId": str(UUID(int=0)),
+                    },
+                    {
+                        "id": "ixp_2",
+                        "projectVersion": 2,
+                        "documentTypeId": str(UUID(int=0)),
+                    },
+                    {
+                        "id": "ixp_1",
+                        "projectVersion": 1,
+                        "documentTypeId": str(UUID(int=0)),
+                    },
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": ixp_extraction_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                project_name="TestProjectIXP",
+                project_type=ProjectType.IXP,
+                version=version,
+                file=b"test content",
+            )
+        else:
+            response = service.extract(
+                project_name="TestProjectIXP",
+                project_type=ProjectType.IXP,
+                version=version,
+                file=b"test content",
+            )
+
+        # ASSERT
+        expected_response = ixp_extraction_response
+        expected_response["projectId"] = project_id
+        expected_response["projectType"] = ProjectType.IXP.value
+        expected_response["extractorId"] = extractor_id
+        expected_response["tag"] = None
+        expected_response["documentTypeId"] = str(UUID(int=0))
+        assert response.model_dump() == expected_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_ixp_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=IXP",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProjectIXP"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/tags?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "tags": [
+                    {"name": "draft"},
+                    {"name": "live"},
+                    {"name": "production"},
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/live/document-types/{UUID(int=0)}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/live/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "NotStarted", "result": ixp_extraction_response},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/live/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Running", "result": ixp_extraction_response},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/live/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": ixp_extraction_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                project_name="TestProjectIXP",
+                project_type=ProjectType.IXP,
+                tag="live",
+                file=b"test content",
+            )
+        else:
+            response = service.extract(
+                project_name="TestProjectIXP",
+                project_type=ProjectType.IXP,
+                tag="live",
+                file=b"test content",
+            )
+
+        # ASSERT
+        expected_response = ixp_extraction_response
+        expected_response["projectId"] = project_id
+        expected_response["projectType"] = ProjectType.IXP.value
+        expected_response["extractorId"] = None
+        expected_response["tag"] = "live"
+        expected_response["documentTypeId"] = str(UUID(int=0))
+        assert response.model_dump() == expected_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_predefined(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        modern_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        document_id = str(uuid4())
+        document_type_id = "receipts"
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/document-types?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "documentTypes": [
+                    {"id": str(uuid4()), "name": "Receipt"},
+                    {"id": document_type_id, "name": "Invoice"},
+                    {"id": str(uuid4()), "name": "Contract"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        statuses = ["NotStarted", "Running", "Succeeded"]
+        for status in statuses:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/extraction/result/{operation_id}?api-version=1.1",
+                status_code=200,
+                match_headers={
+                    "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+                },
+                json={"status": status, "result": modern_extraction_response},
+            )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                project_type=ProjectType.PRETRAINED,
+                file=b"test content",
+                document_type_name="Invoice",
+            )
+        else:
+            response = service.extract(
+                project_type=ProjectType.PRETRAINED,
+                file=b"test content",
+                document_type_name="Invoice",
+            )
+
+        # ASSERT
+        expected_response = modern_extraction_response
+        expected_response["projectId"] = project_id
+        expected_response["projectType"] = ProjectType.PRETRAINED.value
+        expected_response["extractorId"] = document_type_id
+        expected_response["tag"] = None
+        expected_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == expected_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_modern_with_version_extractor_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        version = 5
+        document_type_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProjectModern"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/document-types?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "documentTypes": [
+                    {"id": str(uuid4()), "name": "Receipt"},
+                    {"id": document_type_id, "name": "Invoice"},
+                    {"id": str(uuid4()), "name": "Contract"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "extractors": [
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 1,
+                        "documentTypeId": str(uuid4()),
+                    },
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 2,
+                        "documentTypeId": str(uuid4()),
+                    },
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 3,
+                        "documentTypeId": str(uuid4()),
+                    },
+                ]
+            },
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match=f"Extractor for version '{version}' and document type id '{document_type_id}' not found.",
+        ):
+            if mode == "async":
+                await service.extract_async(
+                    project_name="TestProjectModern",
+                    version=version,
+                    file=b"test content",
+                    project_type=ProjectType.MODERN,
+                    document_type_name="Invoice",
+                )
+            else:
+                service.extract(
+                    project_name="TestProjectModern",
+                    version=version,
+                    file=b"test content",
+                    project_type=ProjectType.MODERN,
+                    document_type_name="Invoice",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_modern_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        modern_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_type_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+        extractor_id = str(uuid4())
+        version = 2
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProjectModern"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/document-types?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "documentTypes": [
+                    {"id": str(uuid4()), "name": "Receipt"},
+                    {"id": document_type_id, "name": "Invoice"},
+                    {"id": str(uuid4()), "name": "Contract"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "extractors": [
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 1,
+                        "documentTypeId": str(uuid4()),
+                    },
+                    {
+                        "id": extractor_id,
+                        "projectVersion": version,
+                        "documentTypeId": document_type_id,
+                    },
+                    {
+                        "id": str(uuid4()),
+                        "projectVersion": 3,
+                        "documentTypeId": str(uuid4()),
+                    },
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        statuses = ["NotStarted", "Running", "Succeeded"]
+        for status in statuses:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/extraction/result/{operation_id}?api-version=1.1",
+                status_code=200,
+                match_headers={
+                    "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+                },
+                json={"status": status, "result": modern_extraction_response},
+            )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                project_name="TestProjectModern",
+                version=version,
+                file=b"test content",
+                project_type=ProjectType.MODERN,
+                document_type_name="Invoice",
+            )
+        else:
+            response = service.extract(
+                project_name="TestProjectModern",
+                version=version,
+                file=b"test content",
+                project_type=ProjectType.MODERN,
+                document_type_name="Invoice",
+            )
+
+        # ASSERT
+        expected_response = modern_extraction_response
+        expected_response["projectId"] = project_id
+        expected_response["projectType"] = ProjectType.MODERN.value
+        expected_response["extractorId"] = extractor_id
+        expected_response["tag"] = None
+        expected_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == expected_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_modern_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        modern_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_type_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=Modern",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProjectModern"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/tags?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "tags": [
+                    {"name": "Development"},
+                    {"name": "Staging"},
+                    {"name": "Production"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/result/{document_id}?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={"status": "Succeeded", "result": {}},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/document-types?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            json={
+                "documentTypes": [
+                    {"id": str(uuid4()), "name": "Receipt"},
+                    {"id": document_type_id, "name": "Invoice"},
+                    {"id": str(uuid4()), "name": "Contract"},
+                ]
+            },
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/document-types/{document_type_id}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={
+                "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+            },
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        statuses = ["NotStarted", "Running", "Succeeded"]
+        for status in statuses:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/document-types/{document_type_id}/extraction/result/{operation_id}?api-version=1.1",
+                status_code=200,
+                match_headers={
+                    "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+                },
+                json={"status": status, "result": modern_extraction_response},
+            )
+
+        # ACT
+        if mode == "async":
+            response = await service.extract_async(
+                project_name="TestProjectModern",
+                tag="Production",
+                file=b"test content",
+                project_type=ProjectType.MODERN,
+                document_type_name="Invoice",
+            )
+        else:
+            response = service.extract(
+                project_name="TestProjectModern",
+                tag="Production",
+                file=b"test content",
+                project_type=ProjectType.MODERN,
+                document_type_name="Invoice",
+            )
+
+        # ASSERT
+        expected_response = modern_extraction_response
+        expected_response["projectId"] = project_id
+        expected_response["projectType"] = ProjectType.MODERN.value
+        expected_response["extractorId"] = None
+        expected_response["tag"] = "Production"
+        expected_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == expected_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_modern_without_document_type_name(
+        self, service: DocumentsService, mode: str
+    ):
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match="`document_type_name` must be provided",
+        ):
+            if mode == "async":
+                await service.extract_async(
+                    project_name="TestProjectModern",
+                    tag="Production",
+                    file=b"test content",
+                    project_type=ProjectType.MODERN,
+                )
+            else:
+                service.extract(
+                    project_name="TestProjectModern",
+                    tag="Production",
+                    file=b"test content",
+                    project_type=ProjectType.MODERN,
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_get_document_type_id_not_found(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/dummy_project_id/document-types?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={
+                "documentTypes": [
+                    {"id": str(uuid4()), "name": "Receipt"},
+                    {"id": str(uuid4()), "name": "Invoice"},
+                    {"id": str(uuid4()), "name": "Contract"},
+                ]
+            },
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match="Document type 'NonExistentType' not found.",
+        ):
+            if mode == "async":
+                await service._get_document_type_id_async(
+                    project_id="dummy_project_id",
+                    document_type_name="NonExistentType",
+                    project_type=ProjectType.MODERN,
+                    classification_result=None,
+                )
+            else:
+                service._get_document_type_id(
+                    project_id="dummy_project_id",
+                    document_type_name="NonExistentType",
+                    project_type=ProjectType.MODERN,
+                    classification_result=None,
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_both_file_and_file_path_provided(
+        self,
+        service: DocumentsService,
+        mode: str,
+    ):
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match="Exactly one of `file, file_path` must be provided",
+        ):
+            if mode == "async":
+                await service.extract_async(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                    file_path="path/to/file.pdf",
+                )
+            else:
+                service.extract(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                    file_path="path/to/file.pdf",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_wrong_project_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=IXP",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": str(uuid4()), "name": "YetAnotherProject"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(ValueError, match="Project 'TestProject' not found."):
+            if mode == "async":
+                await service.extract_async(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                )
+            else:
+                service.extract(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_extract_with_wrong_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=IXP",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={
+                "projects": [
+                    {"id": str(uuid4()), "name": "OtherProject"},
+                    {"id": project_id, "name": "TestProject"},
+                    {"id": str(uuid4()), "name": "AnotherProject"},
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/tags?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"tags": [{"name": "staging"}]},
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(ValueError, match="Tag 'live' not found."):
+            if mode == "async":
+                await service.extract_async(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                )
+            else:
+                service.extract(
+                    project_name="TestProject",
+                    project_type=ProjectType.IXP,
+                    tag="live",
+                    file=b"test content",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_classification_action_pretrained(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        classification_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+        tag = None
+        action_title = "TestAction"
+        action_priority = ActionPriority.LOW
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        classification_result = classification_response["classificationResults"][0]
+        classification_result["ProjectId"] = project_id
+        classification_result["ProjectType"] = ProjectType.PRETRAINED.value
+        classification_result["ClassifierId"] = "ml-classification"
+        classification_result["Tag"] = tag
+        classification_result = ClassificationResult.model_validate(
+            classification_result
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+                "classificationResults": [
+                    classification_result.model_dump(),
+                ],
+                "documentId": classification_result.document_id,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_classification_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+        else:
+            response = service.create_validate_classification_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["classifierId"] = "ml-classification"
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["operationId"] = operation_id
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_classification_action_modern_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        classification_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        classifier_id = str(uuid4())
+        action_title = "TestAction"
+        action_priority = ActionPriority.HIGH
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        classification_result = classification_response["classificationResults"][0]
+        classification_result["ProjectId"] = project_id
+        classification_result["ProjectType"] = ProjectType.MODERN.value
+        classification_result["ClassifierId"] = classifier_id
+        classification_result["Tag"] = None
+        classification_result = ClassificationResult.model_validate(
+            classification_result
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+                "classificationResults": [
+                    classification_result.model_dump(),
+                ],
+                "documentId": classification_result.document_id,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_classification_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+        else:
+            response = service.create_validate_classification_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.MODERN.value
+        create_validation_action_response["classifierId"] = classifier_id
+        create_validation_action_response["tag"] = None
+        create_validation_action_response["operationId"] = operation_id
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_classification_action_modern_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        classification_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "Production"
+        action_title = "TestAction"
+        action_priority = ActionPriority.MEDIUM
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        classification_result = classification_response["classificationResults"][0]
+        classification_result["ProjectId"] = project_id
+        classification_result["ProjectType"] = ProjectType.MODERN.value
+        classification_result["ClassifierId"] = None
+        classification_result["Tag"] = tag
+        classification_result = ClassificationResult.model_validate(
+            classification_result
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+                "classificationResults": [
+                    classification_result.model_dump(),
+                ],
+                "documentId": classification_result.document_id,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/classifiers/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_classification_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+        else:
+            response = service.create_validate_classification_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                classification_results=[classification_result],
+            )
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.MODERN.value
+        create_validation_action_response["classifierId"] = None
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["operationId"] = operation_id
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_classification_action_with_empty_classification_results(
+        self,
+        service: DocumentsService,
+        mode: str,
+    ):
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match="`classification_results` must not be empty",
+        ):
+            if mode == "async":
+                await service.create_validate_classification_action_async(
+                    action_title="TestAction",
+                    action_priority=ActionPriority.MEDIUM,
+                    action_catalog="TestCatalog",
+                    action_folder="TestFolder",
+                    storage_bucket_name="TestBucket",
+                    storage_bucket_directory_path="Test/Directory/Path",
+                    classification_results=[],
+                )
+            else:
+                service.create_validate_classification_action(
+                    action_title="TestAction",
+                    action_priority=ActionPriority.MEDIUM,
+                    action_catalog="TestCatalog",
+                    action_folder="TestFolder",
+                    storage_bucket_name="TestBucket",
+                    storage_bucket_directory_path="Test/Directory/Path",
+                    classification_results=[],
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_classification_action_with_optional_params_omitted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        classification_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+        classifier_id = "ml-classification"
+        tag = None
+        action_title = "TestAction"
+
+        classification_result = classification_response["classificationResults"][0]
+        classification_result["ProjectId"] = project_id
+        classification_result["ProjectType"] = ProjectType.PRETRAINED.value
+        classification_result["ClassifierId"] = classifier_id
+        classification_result["Tag"] = tag
+        classification_result = ClassificationResult.model_validate(
+            classification_result
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "actionTitle": action_title,
+                "actionPriority": None,
+                "actionCatalog": None,
+                "actionFolder": None,
+                "storageBucketName": None,
+                "storageBucketDirectoryPath": None,
+                "classificationResults": [
+                    classification_result.model_dump(),
+                ],
+                "documentId": classification_result.document_id,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_classification_action_async(
+                classification_results=[classification_result],
+                action_title=action_title,
+            )
+        else:
+            response = service.create_validate_classification_action(
+                classification_results=[classification_result],
+                action_title=action_title,
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["classifierId"] = classifier_id
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["operationId"] = operation_id
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_extraction_action_pretrained(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        modern_extraction_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+        document_type_id = "invoices"
+        tag = None
+        action_title = "TestAction"
+        action_priority = ActionPriority.MEDIUM
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": modern_extraction_response["extractionResult"],
+                "documentId": modern_extraction_response["extractionResult"][
+                    "DocumentId"
+                ],
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.PRETRAINED.value
+        modern_extraction_response["extractorId"] = document_type_id
+        modern_extraction_response["tag"] = tag
+        modern_extraction_response["documentTypeId"] = document_type_id
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_extraction_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    modern_extraction_response
+                ),
+            )
+        else:
+            response = service.create_validate_extraction_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    modern_extraction_response
+                ),
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["extractorId"] = document_type_id
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["validatedExtractionResults"] = None
+        create_validation_action_response["dataProjection"] = None
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_extraction_action_ixp_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        document_type_id = str(UUID(int=0))
+        extractor_id = "ixp-4"
+        tag = None
+        action_title = "TestAction"
+        action_priority = ActionPriority.LOW
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": ixp_extraction_response["extractionResult"],
+                "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+            json={"operationId": operation_id},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        ixp_extraction_response["projectId"] = project_id
+        ixp_extraction_response["projectType"] = ProjectType.IXP.value
+        ixp_extraction_response["extractorId"] = extractor_id
+        ixp_extraction_response["tag"] = tag
+        ixp_extraction_response["documentTypeId"] = document_type_id
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_extraction_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+        else:
+            response = service.create_validate_extraction_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.IXP.value
+        create_validation_action_response["extractorId"] = extractor_id
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["validatedExtractionResults"] = None
+        create_validation_action_response["dataProjection"] = None
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_extraction_action_ixp_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        document_type_id = str(UUID(int=0))
+        tag = "live"
+        action_title = "TestAction"
+        action_priority = ActionPriority.HIGH
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": ixp_extraction_response["extractionResult"],
+                "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "NotStarted"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Running"},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        ixp_extraction_response["projectId"] = project_id
+        ixp_extraction_response["projectType"] = ProjectType.IXP.value
+        ixp_extraction_response["extractorId"] = None
+        ixp_extraction_response["tag"] = tag
+        ixp_extraction_response["documentTypeId"] = document_type_id
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_extraction_action_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+        else:
+            response = service.create_validate_extraction_action(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.IXP.value
+        create_validation_action_response["extractorId"] = None
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["validatedExtractionResults"] = None
+        create_validation_action_response["dataProjection"] = None
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_create_validate_extraction_action_with_optional_params_omitted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        modern_extraction_response: dict,  # type: ignore
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+        document_type_id = "invoices"
+        tag = None
+        action_title = "TestAction"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": modern_extraction_response["extractionResult"],
+                "documentId": modern_extraction_response["extractionResult"][
+                    "DocumentId"
+                ],
+                "actionTitle": action_title,
+                "actionPriority": None,
+                "actionCatalog": None,
+                "actionFolder": None,
+                "storageBucketName": None,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": None,
+            },
+            json={"operationId": operation_id},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.PRETRAINED.value
+        modern_extraction_response["extractorId"] = document_type_id
+        modern_extraction_response["tag"] = tag
+        modern_extraction_response["documentTypeId"] = document_type_id
+
+        # ACT
+        if mode == "async":
+            response = await service.create_validate_extraction_action_async(
+                extraction_response=ExtractionResponse.model_validate(
+                    modern_extraction_response
+                ),
+                action_title=action_title,
+            )
+        else:
+            response = service.create_validate_extraction_action(
+                extraction_response=ExtractionResponse.model_validate(
+                    modern_extraction_response
+                ),
+                action_title=action_title,
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["extractorId"] = document_type_id
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["validatedExtractionResults"] = None
+        create_validation_action_response["dataProjection"] = None
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_get_validate_classification_result_pretrained(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        classification_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedClassificationResults"] = (
+            classification_response["classificationResults"]
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/ml-classification/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["classifierId"] = "ml-classification"
+        create_validation_action_response["tag"] = None
+        create_validation_action_response["operationId"] = operation_id
+
+        # ACT
+        if mode == "async":
+            results = await service.get_validate_classification_result_async(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            results = service.get_validate_classification_result(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.PRETRAINED.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            "ml-classification"
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        assert (
+            results[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_get_validate_classification_result_modern_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        classification_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        classifier_id = str(uuid4())
+
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedClassificationResults"] = (
+            classification_response["classificationResults"]
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/classifiers/{classifier_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.MODERN.value
+        create_validation_action_response["classifierId"] = classifier_id
+        create_validation_action_response["tag"] = None
+        create_validation_action_response["operationId"] = operation_id
+
+        # ACT
+        if mode == "async":
+            results = await service.get_validate_classification_result_async(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            results = service.get_validate_classification_result(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = (
+            classifier_id
+        )
+        classification_response["classificationResults"][0]["Tag"] = None
+        assert (
+            results[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_get_validate_classification_result_modern_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        classification_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedClassificationResults"] = (
+            classification_response["classificationResults"]
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/Production/classifiers/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.MODERN.value
+        create_validation_action_response["classifierId"] = None
+        create_validation_action_response["tag"] = "Production"
+        create_validation_action_response["operationId"] = operation_id
+
+        # ACT
+        if mode == "async":
+            results = await service.get_validate_classification_result_async(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            results = service.get_validate_classification_result(
+                validation_action=ValidateClassificationAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        classification_response["classificationResults"][0]["ProjectId"] = project_id
+        classification_response["classificationResults"][0]["ProjectType"] = (
+            ProjectType.MODERN.value
+        )
+        classification_response["classificationResults"][0]["ClassifierId"] = None
+        classification_response["classificationResults"][0]["Tag"] = "Production"
+        assert (
+            results[0].model_dump()
+            == classification_response["classificationResults"][0]
+        )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_get_validate_extraction_result_pretrained(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(UUID(int=0))
+        operation_id = str(uuid4())
+        document_type_id = "invoices"
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.PRETRAINED.value
+        create_validation_action_response["extractorId"] = document_type_id
+        create_validation_action_response["tag"] = None
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedExtractionResults"] = (
+            modern_extraction_response["extractionResult"]
+        )
+        create_validation_action_response["dataProjection"] = (
+            modern_extraction_response.get("dataProjection", None)
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{document_type_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.get_validate_extraction_result_async(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            response = service.get_validate_extraction_result(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        modern_extraction_response["projectId"] = project_id
+        modern_extraction_response["projectType"] = ProjectType.PRETRAINED.value
+        modern_extraction_response["extractorId"] = document_type_id
+        modern_extraction_response["tag"] = None
+        modern_extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == modern_extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.parametrize(
+        "project_type,extraction_response_fixture",
+        [
+            (ProjectType.MODERN, "modern_extraction_response"),
+            (ProjectType.IXP, "ixp_extraction_response"),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_get_validate_extraction_result_with_version(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+        project_type: ProjectType,
+        extraction_response_fixture: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        document_type_id = str(UUID(int=0))
+        extractor_id = str(uuid4())
+
+        # Select the appropriate extraction response based on the fixture name
+        extraction_response = (
+            modern_extraction_response
+            if extraction_response_fixture == "modern_extraction_response"
+            else ixp_extraction_response
+        )
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = project_type.value
+        create_validation_action_response["extractorId"] = extractor_id
+        create_validation_action_response["tag"] = None
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedExtractionResults"] = (
+            extraction_response["extractionResult"]
+        )
+        create_validation_action_response["dataProjection"] = extraction_response.get(
+            "dataProjection", None
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/extractors/{extractor_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.get_validate_extraction_result_async(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            response = service.get_validate_extraction_result(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        extraction_response["projectId"] = project_id
+        extraction_response["projectType"] = project_type
+        extraction_response["extractorId"] = extractor_id
+        extraction_response["tag"] = None
+        extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.parametrize(
+        "project_type,tag,extraction_response_fixture",
+        [
+            (ProjectType.MODERN, "Production", "modern_extraction_response"),
+            (ProjectType.IXP, "live", "ixp_extraction_response"),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_get_validate_extraction_result_with_tag(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        org: str,
+        tenant: str,
+        service: DocumentsService,
+        create_validation_action_response: dict,  # type: ignore
+        modern_extraction_response: dict,  # type: ignore
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+        project_type: ProjectType,
+        tag: str,
+        extraction_response_fixture: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        document_type_id = str(UUID(int=0))
+
+        # Select the appropriate extraction response based on the fixture name
+        extraction_response = (
+            modern_extraction_response
+            if extraction_response_fixture == "modern_extraction_response"
+            else ixp_extraction_response
+        )
+
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = project_type.value
+        create_validation_action_response["extractorId"] = None
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = document_type_id
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["actionStatus"] = "Completed"
+        create_validation_action_response["validatedExtractionResults"] = (
+            extraction_response["extractionResult"]
+        )
+        create_validation_action_response["dataProjection"] = extraction_response.get(
+            "dataProjection", None
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.get_validate_extraction_result_async(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+        else:
+            response = service.get_validate_extraction_result(
+                validation_action=ValidateExtractionAction.model_validate(
+                    create_validation_action_response
+                )
+            )
+
+        # ASSERT
+        extraction_response["projectId"] = project_id
+        extraction_response["projectType"] = project_type
+        extraction_response["extractorId"] = None
+        extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+        assert response.model_dump() == extraction_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    @patch("uipath.platform.documents._documents_service.time")
+    async def test_wait_for_operation_timeout(
+        self,
+        mock_time: Mock,
+        service: DocumentsService,
+        mode: str,
+    ):
+        # ARRANGE
+        mock_time.monotonic.side_effect = [0, 10, 30, 60, 200, 280, 310, 350]
+
+        def mock_result_getter():
+            return "Running", None, None
+
+        async def mock_result_getter_async():
+            return "Running", None, None
+
+        # ACT & ASSERT
+        with pytest.raises(TimeoutError, match="Operation timed out."):
+            if mode == "async":
+                await service._wait_for_operation_async(
+                    result_getter=mock_result_getter_async,
+                    wait_statuses=["NotStarted", "Running"],
+                    success_status="Succeeded",
+                )
+            else:
+                service._wait_for_operation(
+                    result_getter=mock_result_getter,
+                    wait_statuses=["NotStarted", "Running"],
+                    success_status="Succeeded",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_wait_for_operation_failed(
+        self,
+        service: DocumentsService,
+        mode: str,
+    ):
+        # ARRANGE
+
+        def mock_result_getter():
+            return "Failed", "Dummy error", None
+
+        async def mock_result_getter_async():
+            return "Failed", "Dummy error", None
+
+        # ACT & ASSERT
+        with pytest.raises(
+            Exception, match="Operation failed with status: Failed, error: Dummy error"
+        ):
+            if mode == "async":
+                await service._wait_for_operation_async(
+                    result_getter=mock_result_getter_async,
+                    wait_statuses=["NotStarted", "Running"],
+                    success_status="Succeeded",
+                )
+            else:
+                service._wait_for_operation(
+                    result_getter=mock_result_getter,
+                    wait_statuses=["NotStarted", "Running"],
+                    success_status="Succeeded",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_start_ixp_extraction(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        document_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects?api-version=1.1&type=IXP",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={
+                "projects": [
+                    {"id": project_id, "name": "TestProjectIXP"},
+                ]
+            },
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/digitization/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_files={"File": b"test content"},
+            json={"documentId": document_id},
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/staging/document-types/{UUID(int=0)}/extraction/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={"documentId": document_id},
+            json={"operationId": operation_id},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.start_ixp_extraction_async(
+                project_name="TestProjectIXP",
+                tag="staging",
+                file=b"test content",
+            )
+        else:
+            response = service.start_ixp_extraction(
+                project_name="TestProjectIXP",
+                tag="staging",
+                file=b"test content",
+            )
+
+        # ASSERT
+        assert response.operation_id == operation_id
+        assert response.document_id == document_id
+        assert response.project_id == project_id
+        assert response.tag == "staging"
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_start_ixp_extraction_invalid_parameters(
+        self,
+        service: DocumentsService,
+        mode: str,
+    ):
+        # ACT & ASSERT
+        with pytest.raises(
+            ValueError,
+            match="Exactly one of `file, file_path` must be provided",
+        ):
+            if mode == "async":
+                await service.start_ixp_extraction_async(
+                    project_name="TestProject",
+                    tag="staging",
+                )
+            else:
+                service.start_ixp_extraction(
+                    project_name="TestProject",
+                    tag="staging",
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_result_success(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict[str, Any],
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/staging/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": ixp_extraction_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.retrieve_ixp_extraction_result_async(
+                project_id=project_id,
+                tag="staging",
+                operation_id=operation_id,
+            )
+        else:
+            response = service.retrieve_ixp_extraction_result(
+                project_id=project_id,
+                tag="staging",
+                operation_id=operation_id,
+            )
+
+        # ASSERT
+        assert response.project_id == project_id
+        assert response.tag == "staging"
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_result_not_complete(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/staging/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Running"},
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            OperationNotCompleteException,
+            match=f"IXP extraction '{operation_id}' is not complete. Current status: Running",
+        ) as exc_info:
+            if mode == "async":
+                await service.retrieve_ixp_extraction_result_async(
+                    project_id=project_id,
+                    tag="staging",
+                    operation_id=operation_id,
+                )
+            else:
+                service.retrieve_ixp_extraction_result(
+                    project_id=project_id,
+                    tag="staging",
+                    operation_id=operation_id,
+                )
+
+        assert exc_info.value.operation_id == operation_id
+        assert exc_info.value.status == "Running"
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_result_failed(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/staging/document-types/{UUID(int=0)}/extraction/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Failed", "error": "Dummy extraction error"},
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            OperationFailedException,
+            match=f"IXP extraction '{operation_id}' failed with status: Failed error: Dummy extraction error",
+        ):
+            if mode == "async":
+                await service.retrieve_ixp_extraction_result_async(
+                    project_id=project_id,
+                    tag="staging",
+                    operation_id=operation_id,
+                )
+            else:
+                service.retrieve_ixp_extraction_result(
+                    project_id=project_id,
+                    tag="staging",
+                    operation_id=operation_id,
+                )
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_start_ixp_extraction_validation(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+        action_title = "TestAction"
+        action_priority = ActionPriority.HIGH
+        action_catalog = "TestCatalog"
+        action_folder = "TestFolder"
+        storage_bucket_name = "TestBucket"
+        storage_bucket_directory_path = "Test/Directory/Path"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": ixp_extraction_response["extractionResult"],
+                "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+            json={"operationId": operation_id},
+        )
+
+        ixp_extraction_response["projectId"] = project_id
+        ixp_extraction_response["projectType"] = ProjectType.IXP.value
+        ixp_extraction_response["extractorId"] = None
+        ixp_extraction_response["tag"] = tag
+        ixp_extraction_response["documentTypeId"] = str(UUID(int=0))
+
+        # ACT
+        if mode == "async":
+            response = await service.start_ixp_extraction_validation_async(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+        else:
+            response = service.start_ixp_extraction_validation(
+                action_title=action_title,
+                action_priority=action_priority,
+                action_catalog=action_catalog,
+                action_folder=action_folder,
+                storage_bucket_name=storage_bucket_name,
+                storage_bucket_directory_path=storage_bucket_directory_path,
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+            )
+
+        # ASSERT
+        assert response.model_dump() == {
+            "projectId": project_id,
+            "tag": tag,
+            "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+            "operationId": operation_id,
+        }
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_start_ixp_extraction_validation_with_optional_params_omitted(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        ixp_extraction_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+        action_title = "TestAction"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            match_json={
+                "extractionResult": ixp_extraction_response["extractionResult"],
+                "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+                "actionTitle": action_title,
+                "actionPriority": None,
+                "actionCatalog": None,
+                "actionFolder": None,
+                "storageBucketName": None,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": None,
+            },
+            json={"operationId": operation_id},
+        )
+
+        ixp_extraction_response["projectId"] = project_id
+        ixp_extraction_response["projectType"] = ProjectType.IXP.value
+        ixp_extraction_response["extractorId"] = None
+        ixp_extraction_response["tag"] = tag
+        ixp_extraction_response["documentTypeId"] = str(UUID(int=0))
+
+        # ACT
+        if mode == "async":
+            response = await service.start_ixp_extraction_validation_async(
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+                action_title=action_title,
+            )
+        else:
+            response = service.start_ixp_extraction_validation(
+                extraction_response=ExtractionResponse.model_validate(
+                    ixp_extraction_response
+                ),
+                action_title=action_title,
+            )
+
+        # ASSERT
+        assert response.model_dump() == {
+            "projectId": project_id,
+            "tag": tag,
+            "documentId": ixp_extraction_response["extractionResult"]["DocumentId"],
+            "operationId": operation_id,
+        }
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_validation_result_unassigned(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        create_validation_action_response: dict,  # type: ignore
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Succeeded", "result": create_validation_action_response},
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.retrieve_ixp_extraction_validation_result_async(
+                project_id=project_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+        else:
+            response = service.retrieve_ixp_extraction_validation_result(
+                project_id=project_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+
+        # ASSERT
+        create_validation_action_response["projectId"] = project_id
+        create_validation_action_response["projectType"] = ProjectType.IXP.value
+        create_validation_action_response["extractorId"] = None
+        create_validation_action_response["tag"] = tag
+        create_validation_action_response["documentTypeId"] = str(UUID(int=0))
+        create_validation_action_response["operationId"] = operation_id
+        create_validation_action_response["validatedExtractionResults"] = None
+        create_validation_action_response["dataProjection"] = None
+        assert response.model_dump() == create_validation_action_response
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_validation_result_completed(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+        extraction_validation_action_response_completed: dict,  # type: ignore
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={
+                "status": "Succeeded",
+                "result": extraction_validation_action_response_completed,
+            },
+        )
+
+        # ACT
+        if mode == "async":
+            response = await service.retrieve_ixp_extraction_validation_result_async(
+                project_id=project_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+        else:
+            response = service.retrieve_ixp_extraction_validation_result(
+                project_id=project_id,
+                tag=tag,
+                operation_id=operation_id,
+            )
+
+        # ASSERT
+        extraction_validation_action_response_completed["projectId"] = project_id
+        extraction_validation_action_response_completed["projectType"] = (
+            ProjectType.IXP.value
+        )
+        extraction_validation_action_response_completed["extractorId"] = None
+        extraction_validation_action_response_completed["tag"] = tag
+        extraction_validation_action_response_completed["documentTypeId"] = str(
+            UUID(int=0)
+        )
+        extraction_validation_action_response_completed["operationId"] = operation_id
+        assert response.model_dump() == extraction_validation_action_response_completed
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_validation_result_not_complete(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Running"},
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            OperationNotCompleteException,
+            match=f"IXP Create Validate Extraction Action '{operation_id}' is not complete. Current status: Running",
+        ) as exc_info:
+            if mode == "async":
+                await service.retrieve_ixp_extraction_validation_result_async(
+                    project_id=project_id,
+                    tag=tag,
+                    operation_id=operation_id,
+                )
+            else:
+                service.retrieve_ixp_extraction_validation_result(
+                    project_id=project_id,
+                    tag=tag,
+                    operation_id=operation_id,
+                )
+
+        assert exc_info.value.operation_id == operation_id
+        assert exc_info.value.status == "Running"
+
+    @pytest.mark.parametrize("mode", ["sync", "async"])
+    @pytest.mark.asyncio
+    async def test_retrieve_ixp_extraction_validation_result_failed(
+        self,
+        httpx_mock: HTTPXMock,
+        service: DocumentsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        mode: str,
+    ):
+        # ARRANGE
+        project_id = str(uuid4())
+        operation_id = str(uuid4())
+        tag = "live"
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}?api-version=1.1",
+            status_code=200,
+            match_headers={"X-UiPath-Internal-ConsumptionSourceType": "CodedAgents"},
+            json={"status": "Failed", "error": "Dummy error"},
+        )
+
+        # ACT & ASSERT
+        with pytest.raises(
+            OperationFailedException,
+            match=f"IXP Create Validate Extraction Action '{operation_id}' failed with status: Failed error: Dummy error",
+        ):
+            if mode == "async":
+                await service.retrieve_ixp_extraction_validation_result_async(
+                    project_id=project_id,
+                    tag=tag,
+                    operation_id=operation_id,
+                )
+            else:
+                service.retrieve_ixp_extraction_validation_result(
+                    project_id=project_id,
+                    tag=tag,
+                    operation_id=operation_id,
+                )
diff --git a/packages/uipath-platform/tests/services/test_entities_service.py b/packages/uipath-platform/tests/services/test_entities_service.py
new file mode 100644
index 000000000..258c3a9d8
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_entities_service.py
@@ -0,0 +1,2649 @@
+import json
+import re
+import uuid
+from dataclasses import make_dataclass
+from typing import Optional
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common._bindings import (
+    EntityResourceOverwrite,
+    _resource_overwrites,
+)
+from uipath.platform.entities import ChoiceSetValue, DataFabricEntityItem, Entity
+from uipath.platform.entities._entities_service import EntitiesService
+from uipath.platform.entities._entity_data_service import EntityDataService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> EntitiesService:
+    return EntitiesService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture(params=[True, False], ids=["correct_schema", "incorrect_schema"])
+def record_schema(request):
+    is_correct = request.param
+    field_type = int if is_correct else str
+    schema_name = f"RecordSchema{'Correct' if is_correct else 'Incorrect'}"
+
+    RecordSchema = make_dataclass(
+        schema_name, [("name", str), ("integer_field", field_type)]
+    )
+
+    return RecordSchema, is_correct
+
+
+@pytest.fixture(params=[True, False], ids=["optional_field", "required_field"])
+def record_schema_optional(request):
+    is_optional = request.param
+    field_type = Optional[int] | None if is_optional else int
+    schema_name = f"RecordSchema{'Optional' if is_optional else 'Required'}"
+
+    RecordSchemaOptional = make_dataclass(
+        schema_name, [("name", str), ("integer_field", field_type)]
+    )
+
+    return RecordSchemaOptional, is_optional
+
+
+class TestEntitiesService:
+    def test_retrieve(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/{entity_key}",
+            status_code=200,
+            json={
+                "name": "TestEntity",
+                "displayName": "TestEntity",
+                "entityType": "TestEntityType",
+                "description": "TestEntity Description",
+                "fields": [
+                    {
+                        "id": "12345",
+                        "name": "field_name",
+                        "isPrimaryKey": True,
+                        "isForeignKey": False,
+                        "isExternalField": False,
+                        "isHiddenField": True,
+                        "isUnique": True,
+                        "referenceType": "ManyToOne",
+                        "sqlType": {"name": "VARCHAR", "LengthLimit": 100},
+                        "isRequired": True,
+                        "displayName": "Field Display Name",
+                        "description": "This is a brief description of the field.",
+                        "isSystemField": False,
+                        "isAttachment": False,
+                        "isRbacEnabled": True,
+                    }
+                ],
+                "isRbacEnabled": False,
+                "id": f"{entity_key}",
+            },
+        )
+
+        entity = service.retrieve(entity_key=str(entity_key))
+
+        assert isinstance(entity, Entity)
+        assert entity.id == f"{entity_key}"
+        assert entity.name == "TestEntity"
+        assert entity.display_name == "TestEntity"
+        assert entity.entity_type == "TestEntityType"
+        assert entity.description == "TestEntity Description"
+        assert entity.fields is not None
+        assert entity.fields[0].id == "12345"
+        assert entity.fields[0].name == "field_name"
+        assert entity.fields[0].is_primary_key
+        assert not entity.fields[0].is_foreign_key
+        assert entity.fields[0].sql_type.name == "VARCHAR"
+        assert entity.fields[0].sql_type.length_limit == 100
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/datafabric_/api/Entity/{entity_key}"
+        )
+
+    def test_retrieve_records_with_no_schema_succeeds(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{str(entity_key)}/read?start=0&limit=1",
+            status_code=200,
+            json={
+                "totalCount": 1,
+                "value": [
+                    {"Id": "12345", "name": "record_name", "integer_field": 10},
+                    {"Id": "12346", "name": "record_name2", "integer_field": 11},
+                ],
+            },
+        )
+
+        records = service.list_records(entity_key=str(entity_key), start=0, limit=1)
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert isinstance(records, list)
+        assert len(records) == 2
+        assert records[0].id == "12345"
+        assert records[0].name == "record_name"
+        assert records[0].integer_field == 10
+        assert records[1].id == "12346"
+        assert records[1].name == "record_name2"
+        assert records[1].integer_field == 11
+
+    def test_retrieve_records_with_schema_succeeds(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        record_schema,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{str(entity_key)}/read?start=0&limit=1",
+            status_code=200,
+            json={
+                "totalCount": 1,
+                "value": [
+                    {"Id": "12345", "name": "record_name", "integer_field": 10},
+                    {"Id": "12346", "name": "record_name2", "integer_field": 11},
+                ],
+            },
+        )
+
+        # Define the schema for the record. A wrong schema should make the validation fail
+        RecordSchema, is_schema_correct = record_schema
+
+        if is_schema_correct:
+            records = service.list_records(
+                entity_key=str(entity_key), schema=RecordSchema, start=0, limit=1
+            )
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert isinstance(records, list)
+            assert len(records) == 2
+            assert records[0].id == "12345"
+            assert records[0].name == "record_name"
+            assert records[0].integer_field == 10
+            assert records[1].id == "12346"
+            assert records[1].name == "record_name2"
+            assert records[1].integer_field == 11
+        else:
+            # Validation should fail and raise an exception
+            with pytest.raises((ValueError, TypeError)):
+                service.list_records(
+                    entity_key=str(entity_key), schema=RecordSchema, start=0, limit=1
+                )
+
+    # Schema validation should take into account optional fields
+    def test_retrieve_records_with_optional_fields(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+        record_schema_optional,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{str(entity_key)}/read?start=0&limit=1",
+            status_code=200,
+            json={
+                "totalCount": 1,
+                "value": [
+                    {
+                        "Id": "12345",
+                        "name": "record_name",
+                    },
+                    {
+                        "Id": "12346",
+                        "name": "record_name2",
+                    },
+                ],
+            },
+        )
+
+        RecordSchemaOptional, is_field_optional = record_schema_optional
+
+        if is_field_optional:
+            records = service.list_records(
+                entity_key=str(entity_key),
+                schema=RecordSchemaOptional,
+                start=0,
+                limit=1,
+            )
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert isinstance(records, list)
+            assert len(records) == 2
+            assert records[0].id == "12345"
+            assert records[0].name == "record_name"
+            assert records[1].id == "12346"
+            assert records[1].name == "record_name2"
+        else:
+            # Validation should fail and raise an exception for missing required field
+            with pytest.raises((ValueError, TypeError)):
+                service.list_records(
+                    entity_key=str(entity_key),
+                    schema=RecordSchemaOptional,
+                    start=0,
+                    limit=1,
+                )
+
+    def test_retrieve_records_without_start_and_limit(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{str(entity_key)}/read",
+            status_code=200,
+            json={
+                "totalCount": 1,
+                "value": [
+                    {"Id": "12345", "name": "record_name", "integer_field": 10},
+                ],
+            },
+        )
+
+        records = service.list_records(entity_key=str(entity_key))
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        # Verify no start or limit query params are sent
+        assert "start" not in str(sent_request.url.params)
+        assert "limit" not in str(sent_request.url.params)
+
+        assert isinstance(records, list)
+        assert len(records) == 1
+        assert records[0].id == "12345"
+
+    @pytest.mark.parametrize(
+        "sql_query",
+        [
+            "SELECT id FROM Customers WHERE id = 1",
+            "SELECT id, name FROM Customers LIMIT 10",
+            "SELECT COUNT(id) FROM Customers",
+            "SELECT SUM(amount) FROM Orders",
+            "SELECT AVG(price) FROM Products",
+            "SELECT MIN(created), MAX(created) FROM Events",
+            "SELECT COUNT(id) AS total, SUM(amount) AS amt FROM Orders",
+            "SELECT COUNT(id), name FROM Customers LIMIT 10",
+            "SELECT id, name, email, phone FROM Customers LIMIT 5",
+            "SELECT DISTINCT id FROM Customers WHERE id > 100",
+            "SELECT id FROM Customers WHERE name = 'foo;bar'",
+            "SELECT id FROM Customers WHERE id = 1;",
+            "SELECT id FROM Customers WHERE name = 'DELETE'",
+            "SELECT id FROM Customers WHERE status = 'UPDATE me'",
+        ],
+    )
+    def test_validate_sql_query_allows_supported_select_queries(
+        self, sql_query: str, service: EntitiesService
+    ) -> None:
+        service._data._validate_sql_query(sql_query)
+
+    @pytest.mark.parametrize(
+        "sql_query,error_message",
+        [
+            ("", "SQL query cannot be empty."),
+            ("   ", "SQL query cannot be empty."),
+            (
+                "SELECT id FROM Customers; SELECT id FROM Orders",
+                "Only a single SELECT statement is allowed.",
+            ),
+            ("INSERT INTO Customers VALUES (1)", "Only SELECT statements are allowed."),
+            (
+                "WITH cte AS (SELECT id FROM Customers) SELECT id FROM cte",
+                "SQL construct 'WITH' is not allowed in entity queries.",
+            ),
+            (
+                "SELECT id FROM Customers UNION SELECT id FROM Orders",
+                "SQL construct 'UNION' is not allowed in entity queries.",
+            ),
+            (
+                "SELECT id, SUM(amount) OVER (PARTITION BY id) FROM Orders LIMIT 10",
+                "SQL construct 'OVER' is not allowed in entity queries.",
+            ),
+            (
+                "SELECT id FROM (SELECT id FROM Customers) c",
+                "Subqueries are not allowed.",
+            ),
+            (
+                "SELECT COALESCE((SELECT max(id) FROM Orders), 0) FROM Customers WHERE id = 1",
+                "Subqueries are not allowed.",
+            ),
+            (
+                "SELECT id FROM Customers",
+                "Queries without WHERE must include a LIMIT clause.",
+            ),
+            (
+                "SELECT UPPER(name) FROM Customers",
+                "Queries without WHERE must include a LIMIT clause.",
+            ),
+            (
+                "SELECT COALESCE(name, 'N/A') FROM Customers",
+                "Queries without WHERE must include a LIMIT clause.",
+            ),
+            (
+                "SELECT 1 LIMIT 1",
+                "Queries must include a FROM clause.",
+            ),
+            (
+                "SELECT COUNT(*) FROM Customers",
+                "COUNT(*) is not supported. Use COUNT(column_name) instead.",
+            ),
+            (
+                "SELECT COUNT(*), name FROM Customers LIMIT 10",
+                "COUNT(*) is not supported. Use COUNT(column_name) instead.",
+            ),
+            (
+                "SELECT COUNT(*) AS total FROM Customers",
+                "COUNT(*) is not supported. Use COUNT(column_name) instead.",
+            ),
+            (
+                "SELECT * FROM Customers LIMIT 10",
+                "SELECT * is not allowed. Specify column names instead.",
+            ),
+            (
+                "SELECT Customers.* FROM Customers LIMIT 10",
+                "SELECT * is not allowed. Specify column names instead.",
+            ),
+            (
+                "SELECT t.* FROM Customers t LIMIT 10",
+                "SELECT * is not allowed. Specify column names instead.",
+            ),
+            (
+                "SELECT * FROM Customers WHERE status = 'Active'",
+                "SELECT * is not allowed. Specify column names instead.",
+            ),
+            (
+                "SELECT Customers.* FROM Customers WHERE status = 'Active'",
+                "SELECT * is not allowed. Specify column names instead.",
+            ),
+            (
+                "SELECT id, name, email, phone, address FROM Customers LIMIT 10",
+                "Selecting more than 4 columns without filtering is not allowed.",
+            ),
+        ],
+    )
+    def test_validate_sql_query_rejects_disallowed_queries(
+        self, sql_query: str, error_message: str, service: EntitiesService
+    ) -> None:
+        with pytest.raises(ValueError, match=re.escape(error_message)):
+            service._data._validate_sql_query(sql_query)
+
+    def test_query_entity_records_rejects_invalid_sql_before_network_call(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        service._data.request = MagicMock()  # type: ignore[method-assign]
+
+        with pytest.raises(
+            ValueError, match=re.escape("Only SELECT statements are allowed.")
+        ):
+            service.query_entity_records("UPDATE Customers SET name = 'X'")
+
+        service._data.request.assert_not_called()
+
+    def test_query_entity_records_calls_request_for_valid_sql(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"results": [{"id": 1}, {"id": 2}]}
+
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        result = service.query_entity_records("SELECT id FROM Customers WHERE id > 0")
+
+        assert result == [{"id": 1}, {"id": 2}]
+        service._data.request.assert_called_once()
+
+    @pytest.mark.anyio
+    async def test_query_entity_records_async_rejects_invalid_sql_before_network_call(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        service._data.request_async = AsyncMock()  # type: ignore[method-assign]
+
+        with pytest.raises(ValueError, match=re.escape("Subqueries are not allowed.")):
+            await service.query_entity_records_async(
+                "SELECT id FROM Customers WHERE id IN (SELECT id FROM Orders)"
+            )
+
+        service._data.request_async.assert_not_called()
+
+    @pytest.mark.anyio
+    async def test_query_entity_records_async_calls_request_for_valid_sql(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"results": [{"id": "c1"}]}
+
+        service._data.request_async = AsyncMock(return_value=response)  # type: ignore[method-assign]
+
+        result = await service.query_entity_records_async(
+            "SELECT id FROM Customers WHERE id = 'c1'"
+        )
+
+        assert result == [{"id": "c1"}]
+        service._data.request_async.assert_called_once()
+
+    def test_query_entity_records_builds_routing_context_from_folders_map(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_map={"Customers": "solution_folder", "Orders": "folder-2"},
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": [{"id": 1}]}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        result = service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+
+        assert result == [{"id": 1}]
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["query"] == "SELECT id FROM Customers LIMIT 10"
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {"entityName": "Customers", "folderId": "solution_folder"},
+                {"entityName": "Orders", "folderId": "folder-2"},
+            ]
+        }
+
+    @pytest.mark.anyio
+    async def test_query_entity_records_async_builds_routing_context_from_folders_map(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_map={"Customers": "solution_folder"},
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": [{"id": "c1"}]}
+        service._data.request_async = AsyncMock(return_value=response)  # type: ignore[method-assign]
+
+        result = await service.query_entity_records_async(
+            "SELECT id FROM Customers WHERE id = 'c1'"
+        )
+
+        assert result == [{"id": "c1"}]
+        call_kwargs = service._data.request_async.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {"entityName": "Customers", "folderId": "solution_folder"},
+            ]
+        }
+
+    def test_query_entity_records_without_routing_context_omits_key(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {"results": []}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        service.query_entity_records("SELECT id FROM Customers WHERE id > 0")
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert "routingContext" not in body
+
+    def test_query_entity_records_picks_up_entity_overwrites_from_context(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        from uipath.platform.common._bindings import (
+            EntityResourceOverwrite,
+            _resource_overwrites,
+        )
+
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": [{"id": 1}]}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Overwritten Customers",
+            folder_id="overwritten-folder-id",
+        )
+        token = _resource_overwrites.set({"entity.Customers": overwrite})
+        try:
+            service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+        finally:
+            _resource_overwrites.reset(token)
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "overwritten-folder-id",
+                    "overrideEntityName": "Overwritten Customers",
+                },
+            ]
+        }
+
+    def test_query_entity_records_merges_folders_map_with_entity_name_overrides(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_map={
+                "Customers": "overwritten-folder-id",
+                "Orders": "orders-folder",
+            },
+            entity_name_overrides={"Customers": "Overwritten Customers"},
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": []}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        routings = body["routingContext"]["entityRoutings"]
+        assert {
+            "entityName": "Customers",
+            "folderId": "overwritten-folder-id",
+            "overrideEntityName": "Overwritten Customers",
+        } in routings
+        assert {"entityName": "Orders", "folderId": "orders-folder"} in routings
+        # Exactly two routings — no duplicates
+        assert len(routings) == 2
+
+    def test_resolve_entity_set_uses_effective_sql_name_in_routing_context(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+        )
+        service.retrieve_by_name = MagicMock(  # type: ignore[method-assign]
+            return_value=MagicMock(spec=Entity)
+        )
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Overwritten Customers",
+            folder_id="known-folder-key",
+        )
+        token = _resource_overwrites.set({"entity.entity-1": overwrite})
+        try:
+            resolution = service.resolve_entity_set(
+                [
+                    DataFabricEntityItem(
+                        id="entity-1",
+                        name="Customers",
+                        folder_key="original-folder-key",
+                    )
+                ]
+            )
+        finally:
+            _resource_overwrites.reset(token)
+
+        assert resolution.entities_service._routing_strategy.routing_context is not None
+        assert resolution.entities_service._routing_strategy.routing_context.model_dump(
+            by_alias=True, exclude_none=True
+        ) == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "known-folder-key",
+                    "overrideEntityName": "Overwritten Customers",
+                }
+            ]
+        }
+        service.retrieve_by_name.assert_called_once_with(
+            "Overwritten Customers",
+            "known-folder-key",
+        )
+
+    @pytest.mark.asyncio
+    async def test_resolve_entity_set_async_resolves_folder_paths_before_fetch(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        folders_service = MagicMock()
+        folders_service.retrieve_key_async = AsyncMock(
+            return_value="resolved-folder-id"
+        )
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+        )
+        service.retrieve_by_name_async = AsyncMock(  # type: ignore[method-assign]
+            return_value=MagicMock(spec=Entity)
+        )
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Overwritten Customers",
+            folder_path="Shared/Finance",
+        )
+        token = _resource_overwrites.set({"entity.entity-1": overwrite})
+        try:
+            resolution = await service.resolve_entity_set_async(
+                [
+                    DataFabricEntityItem(
+                        id="entity-1",
+                        name="Customers",
+                        folder_key="original-folder-key",
+                    )
+                ]
+            )
+        finally:
+            _resource_overwrites.reset(token)
+
+        folders_service.retrieve_key_async.assert_awaited_once_with(
+            folder_path="Shared/Finance"
+        )
+        assert resolution.entities_service._routing_strategy.routing_context is not None
+        assert resolution.entities_service._routing_strategy.routing_context.model_dump(
+            by_alias=True, exclude_none=True
+        ) == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "resolved-folder-id",
+                    "overrideEntityName": "Overwritten Customers",
+                }
+            ]
+        }
+        service.retrieve_by_name_async.assert_awaited_once_with(
+            "Overwritten Customers",
+            "resolved-folder-id",
+        )
+
+    def test_query_entity_records_context_overwrite_same_name_no_override_field(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        from uipath.platform.common._bindings import (
+            EntityResourceOverwrite,
+            _resource_overwrites,
+        )
+
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": []}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Customers",
+            folder_id="different-folder-id",
+        )
+        token = _resource_overwrites.set({"entity.Customers": overwrite})
+        try:
+            service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+        finally:
+            _resource_overwrites.reset(token)
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "different-folder-id",
+                },
+            ]
+        }
+
+    def test_query_entity_records_resolves_overwrite_folder_path_to_folder_key(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        from uipath.platform.common._bindings import (
+            EntityResourceOverwrite,
+            _resource_overwrites,
+        )
+
+        folders_service = MagicMock()
+        folders_service.retrieve_key.return_value = "resolved-folder-id"
+
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": []}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Overwritten Customers",
+            folder_path="Shared/Finance",
+        )
+        token = _resource_overwrites.set({"entity.Customers": overwrite})
+        try:
+            service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+        finally:
+            _resource_overwrites.reset(token)
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "resolved-folder-id",
+                    "overrideEntityName": "Overwritten Customers",
+                },
+            ]
+        }
+
+    def test_query_entity_records_uses_folder_id_directly_without_resolution(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        from uipath.platform.common._bindings import (
+            EntityResourceOverwrite,
+            _resource_overwrites,
+        )
+
+        folders_service = MagicMock()
+        folders_service.retrieve_key.return_value = None
+
+        service = EntitiesService(
+            config=config,
+            execution_context=execution_context,
+            folders_service=folders_service,
+        )
+        response = MagicMock()
+        response.json.return_value = {"results": []}
+        service._data.request = MagicMock(return_value=response)  # type: ignore[method-assign]
+
+        overwrite = EntityResourceOverwrite(
+            resource_type="entity",
+            name="Overwritten Customers",
+            folder_id="known-folder-key",
+        )
+        token = _resource_overwrites.set({"entity.Customers": overwrite})
+        try:
+            service.query_entity_records("SELECT id FROM Customers LIMIT 10")
+        finally:
+            _resource_overwrites.reset(token)
+
+        # folder_id is a key — should NOT be sent through FolderService
+        folders_service.retrieve_key.assert_not_called()
+
+        call_kwargs = service._data.request.call_args
+        body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert body["routingContext"] == {
+            "entityRoutings": [
+                {
+                    "entityName": "Customers",
+                    "folderId": "known-folder-key",
+                    "overrideEntityName": "Overwritten Customers",
+                },
+            ]
+        }
+
+    def test_list_choicesets(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/choiceset",
+            status_code=200,
+            json=[
+                {
+                    "name": "Status",
+                    "displayName": "Status",
+                    "entityType": "ChoiceSet",
+                    "description": "Status choices",
+                    "isRbacEnabled": False,
+                    "id": "cs-001",
+                },
+                {
+                    "name": "Priority",
+                    "displayName": "Priority",
+                    "entityType": "ChoiceSet",
+                    "description": "Priority levels",
+                    "isRbacEnabled": False,
+                    "id": "cs-002",
+                },
+            ],
+        )
+
+        choicesets = service.list_choicesets()
+
+        assert isinstance(choicesets, list)
+        assert len(choicesets) == 2
+        assert choicesets[0].name == "Status"
+        assert choicesets[0].entity_type == "ChoiceSet"
+        assert choicesets[0].id == "cs-001"
+        assert choicesets[1].name == "Priority"
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert sent_request.method == "GET"
+        assert str(sent_request.url).endswith("/datafabric_/api/Entity/choiceset")
+
+    @pytest.mark.anyio
+    async def test_list_choicesets_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/choiceset",
+            status_code=200,
+            json=[
+                {
+                    "name": "Role",
+                    "displayName": "Role",
+                    "entityType": "ChoiceSet",
+                    "isRbacEnabled": False,
+                    "id": "cs-003",
+                },
+            ],
+        )
+
+        choicesets = await service.list_choicesets_async()
+
+        assert len(choicesets) == 1
+        assert choicesets[0].name == "Role"
+        assert choicesets[0].id == "cs-003"
+
+    def test_get_choiceset_values(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        choiceset_id = "cs-001"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{choiceset_id}/query_expansion",
+            status_code=200,
+            json={
+                "totalRecordCount": 3,
+                "jsonValue": json.dumps(
+                    [
+                        {
+                            "Id": "v1",
+                            "Name": "Active",
+                            "DisplayName": "Active",
+                            "NumberId": 0,
+                            "CreateTime": "2026-01-01T00:00:00Z",
+                            "UpdateTime": "2026-01-01T00:00:00Z",
+                        },
+                        {
+                            "Id": "v2",
+                            "Name": "Inactive",
+                            "DisplayName": "Inactive",
+                            "NumberId": 1,
+                            "CreateTime": "2026-01-01T00:00:00Z",
+                            "UpdateTime": "2026-01-01T00:00:00Z",
+                        },
+                        {
+                            "Id": "v3",
+                            "Name": "Pending",
+                            "DisplayName": "Pending",
+                            "NumberId": 2,
+                        },
+                    ]
+                ),
+            },
+        )
+
+        values = service.get_choiceset_values(choiceset_id)
+
+        assert isinstance(values, list)
+        assert len(values) == 3
+        assert isinstance(values[0], ChoiceSetValue)
+        assert values[0].id == "v1"
+        assert values[0].name == "Active"
+        assert values[0].display_name == "Active"
+        assert values[0].number_id == 0
+        assert values[1].number_id == 1
+        assert values[2].name == "Pending"
+        assert values[2].created_by is None
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert sent_request.method == "POST"
+
+    def test_get_choiceset_values_with_pagination(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        choiceset_id = "cs-001"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{choiceset_id}/query_expansion?start=0&limit=2",
+            status_code=200,
+            json={
+                "totalRecordCount": 5,
+                "jsonValue": json.dumps(
+                    [
+                        {
+                            "Id": "v1",
+                            "Name": "Active",
+                            "DisplayName": "Active",
+                            "NumberId": 0,
+                        },
+                        {
+                            "Id": "v2",
+                            "Name": "Inactive",
+                            "DisplayName": "Inactive",
+                            "NumberId": 1,
+                        },
+                    ]
+                ),
+            },
+        )
+
+        values = service.get_choiceset_values(choiceset_id, start=0, limit=2)
+
+        assert len(values) == 2
+        assert values[0].name == "Active"
+        assert values[1].name == "Inactive"
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert "start=0" in str(sent_request.url)
+        assert "limit=2" in str(sent_request.url)
+
+    @pytest.mark.anyio
+    async def test_get_choiceset_values_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        choiceset_id = "cs-002"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{choiceset_id}/query_expansion",
+            status_code=200,
+            json={
+                "totalRecordCount": 1,
+                "jsonValue": json.dumps(
+                    [
+                        {
+                            "Id": "v1",
+                            "Name": "ReadOnly",
+                            "DisplayName": "Read Only",
+                            "NumberId": 0,
+                        },
+                    ]
+                ),
+            },
+        )
+
+        values = await service.get_choiceset_values_async(choiceset_id)
+
+        assert len(values) == 1
+        assert values[0].display_name == "Read Only"
+        assert values[0].number_id == 0
+
+    def test_get_choiceset_values_empty(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        choiceset_id = "cs-empty"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{choiceset_id}/query_expansion",
+            status_code=200,
+            json={
+                "totalRecordCount": 0,
+                "jsonValue": "[]",
+            },
+        )
+
+        values = service.get_choiceset_values(choiceset_id)
+
+        assert values == []
+
+
+class TestEntitiesServiceNewMethods:
+    """Single-record, structured-query, attachment, schema and bulk-import tests."""
+
+    def test_insert_record_fires_post_with_expansion_level(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        from uipath.platform.entities import EntityRecord
+
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/insert?expansionLevel=2",
+            status_code=200,
+            json={"Id": "rec-1", "name": "alice"},
+        )
+
+        record = service.insert_record(
+            entity_key=str(entity_key),
+            data={"name": "alice"},
+            expansion_level=2,
+        )
+
+        assert isinstance(record, EntityRecord)
+        assert record.id == "rec-1"
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert sent.method == "POST"
+        assert json.loads(sent.content) == {"name": "alice"}
+
+    async def test_insert_record_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/insert",
+            status_code=200,
+            json={"Id": "rec-1"},
+        )
+
+        record = await service.insert_record_async(
+            entity_key=str(entity_key), data={"name": "bob"}
+        )
+        assert record.id == "rec-1"
+
+    def test_get_record(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        record_id = "12345"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/read/{record_id}?expansionLevel=1",
+            status_code=200,
+            json={"Id": record_id, "name": "found"},
+        )
+
+        record = service.get_record(
+            entity_key=str(entity_key), record_id=record_id, expansion_level=1
+        )
+
+        assert record.id == record_id
+
+    def test_update_record_accepts_dict(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        record_id = "rec-9"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update/{record_id}",
+            status_code=200,
+            json={"Id": record_id, "name": "updated"},
+        )
+
+        record = service.update_record(
+            entity_key=str(entity_key),
+            record_id=record_id,
+            data={"name": "updated"},
+        )
+
+        assert record.id == record_id
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert json.loads(sent.content) == {"name": "updated"}
+
+    def test_delete_record_uses_http_delete(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        record_id = "rec-9"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/delete/{record_id}",
+            method="DELETE",
+            status_code=200,
+        )
+
+        service.delete_record(entity_key=str(entity_key), record_id=record_id)
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert sent.method == "DELETE"
+
+    def test_query_v1_with_filter_and_pagination(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityQueryFilter,
+            EntityQueryFilterGroup,
+            EntityQuerySortOption,
+            LogicalOperator,
+            QueryFilterOperator,
+        )
+
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/query.*"
+            ),
+            status_code=200,
+            json={
+                "value": [{"Id": "1", "name": "alice"}, {"Id": "2", "name": "bob"}],
+                "totalRecordCount": 5,
+            },
+        )
+
+        result = service.retrieve_records(
+            entity_key=str(entity_key),
+            filter_group=EntityQueryFilterGroup(
+                logical_operator=LogicalOperator.And,
+                query_filters=[
+                    EntityQueryFilter(
+                        field_name="status",
+                        operator=QueryFilterOperator.Equals,
+                        value="active",
+                    )
+                ],
+            ),
+            sort_options=[EntityQuerySortOption(field_name="name", is_descending=True)],
+            selected_fields=["Id", "name"],
+            start=0,
+            limit=2,
+            expansion_level=1,
+        )
+
+        assert result.total_count == 5
+        assert len(result.items) == 2
+        assert result.has_next_page is True
+        # Backend doesn't return next_cursor on this endpoint — caller paginates
+        # by passing the next ``start`` themselves.
+        assert result.next_cursor is None
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert "/query" in str(sent.url) and "/v2/" not in str(sent.url)
+        # expansionLevel is a URL query param, not body
+        assert sent.url.params.get("expansionLevel") == "1"
+        body = json.loads(sent.content)
+        assert body["filterGroup"]["logicalOperator"] == 0  # And
+        assert body["filterGroup"]["queryFilters"][0]["fieldName"] == "status"
+        assert body["sortOptions"][0]["fieldName"] == "name"
+        assert body["selectedFields"] == ["Id", "name"]
+        # start/limit go in BODY, not as $top/$skip query params
+        assert body["start"] == 0
+        assert body["limit"] == 2
+
+    def test_query_aggregate_response_handles_id_less_rows(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """Aggregate / GROUP BY rows lack ``Id`` — parsed as :class:`AggregateRow`."""
+        from uipath.platform.entities import (
+            AggregateRow,
+            EntityAggregate,
+            EntityAggregateFunction,
+        )
+
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/query.*"
+            ),
+            status_code=200,
+            json={
+                "value": [
+                    {"status": "active", "total": 12},
+                    {"status": "inactive", "total": 7},
+                ],
+                "totalRecordCount": 2,
+            },
+        )
+
+        result = service.retrieve_records(
+            entity_key=str(entity_key),
+            selected_fields=["status"],
+            group_by=["status"],
+            aggregates=[
+                EntityAggregate(
+                    function=EntityAggregateFunction.Count,
+                    field="Id",
+                    alias="total",
+                )
+            ],
+        )
+
+        assert result.total_count == 2
+        assert len(result.items) == 2
+        # Aggregate rows lack ``Id`` and are exposed as :class:`AggregateRow`.
+        for row in result.items:
+            assert isinstance(row, AggregateRow)
+        assert result.items[0].status == "active"
+        assert result.items[0].total == 12
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        body = json.loads(sent.content)
+        assert body["aggregates"][0]["function"] == "COUNT"
+        assert body["aggregates"][0]["alias"] == "total"
+        assert body["groupBy"] == ["status"]
+
+    def test_query_v2_when_binnings_provided(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        from uipath.platform.entities import EntityAggregateFunction, EntityBinning
+
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/v2/EntityService/entity/{entity_key}/query.*"
+            ),
+            status_code=200,
+            json={"value": [], "totalCount": 0},
+        )
+
+        service.retrieve_records(
+            entity_key=str(entity_key),
+            binnings=[
+                EntityBinning(
+                    field_name="status",
+                    aggregate_function=EntityAggregateFunction.Count,
+                    alias="total",
+                )
+            ],
+        )
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert "/v2/EntityService/" in str(sent.url)
+
+    def test_upload_attachment_sends_multipart(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_id = "ent-1"
+        record_id = "rec-1"
+        field_name = "doc"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Attachment/entity/{entity_id}/{record_id}/{field_name}?expansionLevel=1",
+            method="POST",
+            status_code=200,
+            json={"Id": record_id, "doc": "uploaded"},
+        )
+
+        result = service.upload_attachment(
+            entity_id=entity_id,
+            record_id=record_id,
+            field_name=field_name,
+            file=b"hello world",
+            expansion_level=1,
+        )
+
+        assert result.get("doc") == "uploaded"
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert b"hello world" in sent.content
+
+    def test_download_attachment_returns_bytes(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_id = "ent-1"
+        record_id = "rec-1"
+        field_name = "doc"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Attachment/entity/{entity_id}/{record_id}/{field_name}",
+            method="GET",
+            status_code=200,
+            content=b"file-content",
+        )
+
+        content = service.download_attachment(
+            entity_id=entity_id, record_id=record_id, field_name=field_name
+        )
+        assert content == b"file-content"
+
+    def test_delete_attachment(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_id = "ent-1"
+        record_id = "rec-1"
+        field_name = "doc"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Attachment/entity/{entity_id}/{record_id}/{field_name}",
+            method="DELETE",
+            status_code=200,
+            json={},
+        )
+
+        result = service.delete_attachment(
+            entity_id=entity_id, record_id=record_id, field_name=field_name
+        )
+        assert result == {}
+
+    def test_create_entity_returns_id(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityCreateOptions,
+            EntityFieldDataType,
+        )
+
+        new_entity_id = str(uuid.uuid4())
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity",
+            method="POST",
+            status_code=200,
+            json=new_entity_id,
+        )
+
+        created_id = service.create_entity(
+            name="productCatalog",
+            fields=[
+                EntityCreateFieldOptions(
+                    field_name="productName",
+                    type=EntityFieldDataType.STRING,
+                    is_required=True,
+                    length_limit=200,
+                ),
+            ],
+            options=EntityCreateOptions(
+                display_name="Product Catalog",
+                description="Catalog of products",
+                is_rbac_enabled=True,
+            ),
+        )
+
+        assert created_id == new_entity_id
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        body = json.loads(sent.content)
+        assert body["displayName"] == "Product Catalog"
+        assert body["entityDefinition"]["name"] == "productCatalog"
+        assert body["entityDefinition"]["fields"][0]["name"] == "productName"
+        assert body["entityDefinition"]["isRbacEnabled"] is True
+
+    def test_delete_entity(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_id = "ent-doomed"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/{entity_id}",
+            method="DELETE",
+            status_code=200,
+        )
+
+        service.delete_entity(entity_id=entity_id)
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert sent.method == "DELETE"
+
+    def test_update_entity_metadata(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        from uipath.platform.entities import EntityMetadataUpdateOptions
+
+        entity_id = "ent-meta"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/{entity_id}/metadata",
+            method="PATCH",
+            status_code=200,
+            json={},
+        )
+
+        service.update_entity_metadata(
+            entity_id=entity_id,
+            metadata=EntityMetadataUpdateOptions(
+                display_name="New Name", is_rbac_enabled=False
+            ),
+        )
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        body = json.loads(sent.content)
+        assert body == {"displayName": "New Name", "isRbacEnabled": False}
+
+    def test_import_records(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_id = "ent-imp"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_id}/bulk-upload",
+            method="POST",
+            status_code=200,
+            json={
+                "totalRecords": 10,
+                "insertedRecords": 9,
+                "errorFileLink": "https://example.com/errors.csv",
+            },
+        )
+
+        result = service.import_records(entity_id=entity_id, file=b"a,b,c\n1,2,3\n")
+        assert result.total_records == 10
+        assert result.inserted_records == 9
+        assert result.error_file_link == "https://example.com/errors.csv"
+
+    def test_list_records_returns_paginated_metadata(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/read.*"
+            ),
+            status_code=200,
+            json={
+                "totalCount": 7,
+                "value": [{"Id": "1"}, {"Id": "2"}, {"Id": "3"}],
+            },
+        )
+
+        records = service.list_records(
+            entity_key=str(entity_key),
+            start=0,
+            limit=3,
+            expansion_level=2,
+            filter="status eq 'active'",
+            orderby="name asc",
+            select=["Id", "name"],
+            expand=["Company"],
+        )
+
+        # New pagination metadata: backend totalCount surfaced verbatim.
+        assert records.total_count == 7
+        assert records.has_next_page is True
+        # Backend does not currently emit next_cursor; caller paginates with start.
+        assert records.next_cursor is None
+
+        # Backward-compat: behaves as a list.
+        assert isinstance(records, list)
+        assert len(records) == 3
+        assert records[0].id == "1"
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        params = sent.url.params
+        assert params.get("expansionLevel") == "2"
+        assert params.get("$filter") == "status eq 'active'"
+        assert params.get("$orderby") == "name asc"
+        assert params.get("$select") == "Id,name"
+        assert params.get("$expand") == "Company"
+
+    def test_insert_records_passes_expansion_level_and_fail_on_first(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/insert-batch.*"
+            ),
+            status_code=200,
+            json={"successRecords": [{"Id": "1"}], "failureRecords": []},
+        )
+
+        service.insert_records(
+            entity_key=str(entity_key),
+            records=[{"name": "alice"}],
+            expansion_level=1,
+            fail_on_first=True,
+        )
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        params = sent.url.params
+        assert params.get("expansionLevel") == "1"
+        assert params.get("failOnFirst") == "true"
+        # Records are normalized to dicts before being sent.
+        assert json.loads(sent.content) == [{"name": "alice"}]
+
+    def test_update_records_recovers_failure_records_from_4xx(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """A 400 response that lists per-record failures should parse into the response.
+
+        The caller receives an ``EntityRecordsBatchResponse`` with the failed
+        records populated rather than an exception, so unknown record ids on
+        update can be handled the same way as any other batch failure.
+        """
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update-batch",
+            method="POST",
+            status_code=400,
+            json={
+                "successRecords": [],
+                "failureRecords": [
+                    {"error": "Record not found", "record": {"Id": "missing"}}
+                ],
+            },
+        )
+
+        result = service.update_records(
+            entity_key=str(entity_key),
+            records=[{"Id": "missing", "name": "x"}],
+        )
+
+        assert len(result.failure_records) == 1
+        assert result.failure_records[0].error == "Record not found"
+
+    def test_delete_records_recovers_failure_records_from_4xx(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/delete-batch",
+            method="POST",
+            status_code=400,
+            json={
+                "successRecords": [],
+                "failureRecords": [{"error": "not found"}],
+            },
+        )
+
+        result = service.delete_records(
+            entity_key=str(entity_key), record_ids=["missing"]
+        )
+
+        assert result.failure_records[0].error == "not found"
+
+    def test_record_to_dict_accepts_dict_pydantic_and_object(self) -> None:
+        from uipath.platform.entities import EntityCreateFieldOptions
+
+        # dict
+        assert EntityDataService._record_to_dict({"a": 1}) == {"a": 1}
+        # Pydantic model — uses model_dump
+        result = EntityDataService._record_to_dict(
+            EntityCreateFieldOptions(field_name="x")
+        )
+        assert result["fieldName"] == "x"
+        # Object with __dict__
+        from dataclasses import dataclass
+
+        @dataclass
+        class Rec:
+            name: str
+
+        assert EntityDataService._record_to_dict(Rec(name="bob")) == {"name": "bob"}
+
+
+class TestEntitiesServiceCreateEntitySqlTypeMapping:
+    """Verify ``create_entity`` produces the SQL types and constraint defaults the backend expects."""
+
+    def _captured_field(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        field_options,
+    ):
+        from uipath.platform.entities import EntityCreateOptions
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity",
+            method="POST",
+            status_code=200,
+            json="00000000-0000-0000-0000-000000000001",
+        )
+        service.create_entity(
+            name="myEntity",
+            fields=[field_options],
+            options=EntityCreateOptions(display_name="My Entity"),
+        )
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        body = json.loads(sent.content)
+        return body["entityDefinition"]["fields"][0]
+
+    def test_string_field_maps_to_nvarchar_with_default_length(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        f = self._captured_field(
+            httpx_mock,
+            service,
+            base_url,
+            org,
+            tenant,
+            EntityCreateFieldOptions(
+                field_name="productName", type=EntityFieldDataType.STRING
+            ),
+        )
+        assert f["sqlType"]["name"] == "NVARCHAR"
+        assert f["sqlType"]["lengthLimit"] == 200  # default
+        assert f["fieldDisplayType"] == "Basic"
+
+    def test_decimal_field_includes_precision_and_value_bounds(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        f = self._captured_field(
+            httpx_mock,
+            service,
+            base_url,
+            org,
+            tenant,
+            EntityCreateFieldOptions(
+                field_name="price",
+                type=EntityFieldDataType.DECIMAL,
+                decimal_precision=4,
+            ),
+        )
+        assert f["sqlType"]["name"] == "DECIMAL"
+        assert f["sqlType"]["decimalPrecision"] == 4
+        assert f["sqlType"]["lengthLimit"] == 1000
+        assert f["sqlType"]["maxValue"] == 1_000_000_000_000
+        assert f["sqlType"]["minValue"] == -1_000_000_000_000
+
+    def test_boolean_field_maps_to_bit(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        f = self._captured_field(
+            httpx_mock,
+            service,
+            base_url,
+            org,
+            tenant,
+            EntityCreateFieldOptions(
+                field_name="isActive", type=EntityFieldDataType.BOOLEAN
+            ),
+        )
+        assert f["sqlType"]["name"] == "BIT"
+        assert f["sqlType"]["lengthLimit"] == 100
+
+    def test_file_field_maps_to_uniqueidentifier_with_file_display_type(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        f = self._captured_field(
+            httpx_mock,
+            service,
+            base_url,
+            org,
+            tenant,
+            EntityCreateFieldOptions(
+                field_name="document", type=EntityFieldDataType.FILE
+            ),
+        )
+        assert f["sqlType"]["name"] == "UNIQUEIDENTIFIER"
+        assert f["fieldDisplayType"] == "File"
+        assert f["sqlType"]["lengthLimit"] == 300
+
+
+class TestEntitiesServiceValidation:
+    """Client-side validation rejects bad entity / field definitions before any HTTP call."""
+
+    def test_create_entity_rejects_invalid_entity_name(self, service) -> None:
+
+        with pytest.raises(ValueError, match="Invalid entity name"):
+            service.create_entity(name="1bad", fields=[])
+
+    def test_create_entity_rejects_invalid_field_name(self, service) -> None:
+        from uipath.platform.entities import EntityCreateFieldOptions
+
+        with pytest.raises(ValueError, match="Invalid field name"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[EntityCreateFieldOptions(field_name="9bad")],
+            )
+
+    def test_create_entity_rejects_reserved_field_name(self, service) -> None:
+        from uipath.platform.entities import EntityCreateFieldOptions
+
+        with pytest.raises(ValueError, match="reserved"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[EntityCreateFieldOptions(field_name="Id")],
+            )
+
+    def test_create_entity_rejects_unsupported_constraint_for_type(
+        self, service
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="does not accept"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.STRING,
+                        decimal_precision=2,  # not allowed on STRING
+                    )
+                ],
+            )
+
+    def test_create_entity_rejects_out_of_range_constraint(self, service) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="out of range"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.STRING,
+                        length_limit=99999,  # > 4000
+                    )
+                ],
+            )
+
+    def test_create_entity_rejects_min_ge_max(self, service) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="strictly less than"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.INTEGER,
+                        min_value=100,
+                        max_value=10,
+                    )
+                ],
+            )
+
+    def test_create_entity_rejects_choiceset_without_choice_set_id(
+        self, service
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="choice_set_id"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.CHOICE_SET_SINGLE,
+                    )
+                ],
+            )
+
+    def test_create_entity_rejects_choice_set_multiple_without_choice_set_id(
+        self, service
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="choice_set_id"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.CHOICE_SET_MULTIPLE,
+                    )
+                ],
+            )
+
+    def test_create_entity_rejects_relationship_without_reference_entity(
+        self, service
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        with pytest.raises(ValueError, match="reference_entity_name"):
+            service.create_entity(
+                name="goodEntity",
+                fields=[
+                    EntityCreateFieldOptions(
+                        field_name="myField",
+                        type=EntityFieldDataType.RELATIONSHIP,
+                    )
+                ],
+            )
+
+    def test_entity_query_filter_rejects_in_without_value_list(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        with pytest.raises(ValueError, match="non-empty value_list"):
+            EntityQueryFilter(
+                field_name="status",
+                operator=QueryFilterOperator.In,
+            )
+
+    def test_entity_query_filter_rejects_in_with_scalar_value(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        with pytest.raises(ValueError, match="value must be omitted"):
+            EntityQueryFilter(
+                field_name="status",
+                operator=QueryFilterOperator.In,
+                value="active",
+                value_list=["active", "pending"],
+            )
+
+    def test_entity_query_filter_rejects_scalar_op_with_value_list(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        with pytest.raises(ValueError, match="value_list must be omitted"):
+            EntityQueryFilter(
+                field_name="amount",
+                operator=QueryFilterOperator.GreaterThan,
+                value_list=["10"],
+            )
+
+    def test_entity_query_filter_rejects_strict_op_with_null_value(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        with pytest.raises(ValueError, match="non-null value"):
+            EntityQueryFilter(
+                field_name="amount",
+                operator=QueryFilterOperator.GreaterThan,
+            )
+
+    def test_entity_query_filter_allows_equals_with_null_value(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        f = EntityQueryFilter(
+            field_name="middle_name",
+            operator=QueryFilterOperator.Equals,
+        )
+        assert f.value is None and f.value_list is None
+
+    def test_entity_query_filter_allows_in_with_value_list(self) -> None:
+        from uipath.platform.entities import EntityQueryFilter, QueryFilterOperator
+
+        f = EntityQueryFilter(
+            field_name="status",
+            operator=QueryFilterOperator.In,
+            value_list=["a", "b"],
+        )
+        assert f.value_list == ["a", "b"]
+
+
+class TestEntitiesServiceAsyncAndEdgeCases:
+    async def test_get_record_async(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        entity_key = uuid.uuid4()
+        record_id = "rec-1"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/read/{record_id}",
+            status_code=200,
+            json={"Id": record_id, "name": "found"},
+        )
+        record = await service.get_record_async(
+            entity_key=str(entity_key), record_id=record_id
+        )
+        assert record.id == record_id
+
+    async def test_query_async_v1(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/query"
+            ),
+            status_code=200,
+            json={"value": [{"Id": "1"}], "totalRecordCount": 1},
+        )
+        result = await service.retrieve_records_async(entity_key=str(entity_key))
+        assert result.total_count == 1
+
+    async def test_delete_record_async(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        entity_key = uuid.uuid4()
+        record_id = "rec-1"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/delete/{record_id}",
+            method="DELETE",
+            status_code=200,
+        )
+        await service.delete_record_async(
+            entity_key=str(entity_key), record_id=record_id
+        )
+
+    async def test_create_entity_async(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        from uipath.platform.entities import (
+            EntityCreateFieldOptions,
+            EntityFieldDataType,
+        )
+
+        new_id = "00000000-0000-0000-0000-000000000123"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity",
+            method="POST",
+            status_code=200,
+            json=new_id,
+        )
+        result = await service.create_entity_async(
+            name="goodEntity",
+            fields=[
+                EntityCreateFieldOptions(
+                    field_name="myField", type=EntityFieldDataType.STRING
+                )
+            ],
+        )
+        assert result == new_id
+
+    async def test_delete_entity_async(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/ent-1",
+            method="DELETE",
+            status_code=200,
+        )
+        await service.delete_entity_async(entity_id="ent-1")
+
+    async def test_update_entity_metadata_async_with_dict(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/ent-1/metadata",
+            method="PATCH",
+            status_code=200,
+            json={},
+        )
+        # Accepts a plain dict too
+        await service.update_entity_metadata_async(
+            entity_id="ent-1", metadata={"displayName": "X", "description": "Y"}
+        )
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert json.loads(sent.content) == {"displayName": "X", "description": "Y"}
+
+    def test_update_entity_metadata_normalizes_snake_case_dict_keys(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        """Snake_case dict keys must be sent to the backend as camelCase."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/ent-1/metadata",
+            method="PATCH",
+            status_code=200,
+            json={},
+        )
+        service.update_entity_metadata(
+            entity_id="ent-1",
+            metadata={
+                "display_name": "New Name",
+                "description": "Updated",
+                "is_rbac_enabled": True,
+            },
+        )
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert json.loads(sent.content) == {
+            "displayName": "New Name",
+            "description": "Updated",
+            "isRbacEnabled": True,
+        }
+
+    async def test_upload_attachment_async_via_file_path(
+        self, httpx_mock, service, base_url, org, tenant, version, tmp_path
+    ) -> None:
+        path = tmp_path / "data.bin"
+        path.write_bytes(b"file-on-disk")
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Attachment/entity/ent/rec/doc",
+            method="POST",
+            status_code=200,
+            json={"Id": "rec", "doc": "ok"},
+        )
+        result = await service.upload_attachment_async(
+            entity_id="ent",
+            record_id="rec",
+            field_name="doc",
+            file_path=str(path),
+        )
+        assert result["doc"] == "ok"
+
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert b"file-on-disk" in sent.content
+
+    async def test_download_and_delete_attachment_async(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        url = f"{base_url}{org}{tenant}/datafabric_/api/Attachment/entity/e/r/f"
+        httpx_mock.add_response(
+            url=url, method="GET", status_code=200, content=b"bytes"
+        )
+        httpx_mock.add_response(url=url, method="DELETE", status_code=200, json={})
+
+        content = await service.download_attachment_async(
+            entity_id="e", record_id="r", field_name="f"
+        )
+        assert content == b"bytes"
+        assert (
+            await service.delete_attachment_async(
+                entity_id="e", record_id="r", field_name="f"
+            )
+            == {}
+        )
+
+    def test_open_file_rejects_both_file_and_path(self) -> None:
+        with pytest.raises(ValueError, match="exactly one of"):
+            EntityDataService._open_file(file=b"x", file_path="some/path")
+
+    def test_open_file_rejects_neither_file_nor_path(self) -> None:
+        with pytest.raises(ValueError, match="exactly one of"):
+            EntityDataService._open_file(file=None, file_path=None)
+
+    def test_4xx_recovery_only_400_with_strict_shape(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        """5xx and 4xx other than 400 must propagate; 400 with valid shape recovers."""
+        entity_key = uuid.uuid4()
+        # 500 with the shape — must propagate, not be silently treated as success.
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update-batch",
+            method="POST",
+            status_code=500,
+            json={"successRecords": [], "failureRecords": []},
+        )
+        from uipath.platform.errors._enriched_exception import EnrichedException
+
+        with pytest.raises(EnrichedException):
+            service.update_records(
+                entity_key=str(entity_key), records=[{"Id": "x", "name": "y"}]
+            )
+
+    def test_4xx_recovery_404_propagates(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        entity_key = uuid.uuid4()
+        # 404 with valid shape — still propagates because not a 400.
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update-batch",
+            method="POST",
+            status_code=404,
+            json={"successRecords": [], "failureRecords": []},
+        )
+        from uipath.platform.errors._enriched_exception import EnrichedException
+
+        with pytest.raises(EnrichedException):
+            service.update_records(
+                entity_key=str(entity_key), records=[{"Id": "x", "name": "y"}]
+            )
+
+    def test_4xx_recovery_400_unrelated_body_propagates(
+        self, httpx_mock, service, base_url, org, tenant, version
+    ) -> None:
+        """A 400 with an error body that lacks ``successRecords``/``failureRecords``
+        must surface as an exception (so generic validation errors aren't masked)."""
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update-batch",
+            method="POST",
+            status_code=400,
+            json={"error": "Validation failed", "code": "InvalidArg"},
+        )
+        from uipath.platform.errors._enriched_exception import EnrichedException
+
+        with pytest.raises(EnrichedException):
+            service.update_records(
+                entity_key=str(entity_key), records=[{"Id": "x", "name": "y"}]
+            )
+
+
+class TestEntitiesServiceAsyncCoverage:
+    """Async-variant tests for previously uncovered paths on schema / data services."""
+
+    async def test_retrieve_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/{entity_key}",
+            status_code=200,
+            json={
+                "name": "Customers",
+                "displayName": "Customers",
+                "entityType": "Entity",
+                "fields": [],
+                "isRbacEnabled": False,
+                "id": str(entity_key),
+            },
+        )
+        entity = await service.retrieve_async(entity_key=str(entity_key))
+        assert entity.id == str(entity_key)
+
+    def test_retrieve_by_name(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/Customers/metadata",
+            status_code=200,
+            json={
+                "name": "Customers",
+                "displayName": "Customers",
+                "entityType": "Entity",
+                "fields": [],
+                "isRbacEnabled": False,
+                "id": "ent-1",
+            },
+        )
+        entity = service.retrieve_by_name("Customers", folder_key="folder-1")
+        assert entity.name == "Customers"
+        sent = httpx_mock.get_request()
+        assert sent is not None
+        assert sent.headers.get("X-UIPATH-FolderKey") == "folder-1"
+
+    async def test_retrieve_by_name_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity/Orders/metadata",
+            status_code=200,
+            json={
+                "name": "Orders",
+                "displayName": "Orders",
+                "entityType": "Entity",
+                "fields": [],
+                "isRbacEnabled": False,
+                "id": "ent-2",
+            },
+        )
+        entity = await service.retrieve_by_name_async("Orders")
+        assert entity.name == "Orders"
+
+    def test_list_entities_basic(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity",
+            status_code=200,
+            json=[
+                {
+                    "name": "Customers",
+                    "displayName": "Customers",
+                    "entityType": "Entity",
+                    "fields": [],
+                    "isRbacEnabled": False,
+                    "id": "ent-1",
+                },
+                {
+                    "name": "Orders",
+                    "displayName": "Orders",
+                    "entityType": "Entity",
+                    "fields": [],
+                    "isRbacEnabled": False,
+                    "id": "ent-2",
+                },
+            ],
+        )
+        entities = service.list_entities()
+        assert len(entities) == 2
+
+    async def test_list_entities_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/Entity",
+            status_code=200,
+            json=[
+                {
+                    "name": "Customers",
+                    "displayName": "Customers",
+                    "entityType": "Entity",
+                    "fields": [],
+                    "isRbacEnabled": False,
+                    "id": "ent-1",
+                }
+            ],
+        )
+        entities = await service.list_entities_async()
+        assert len(entities) == 1
+
+    async def test_list_records_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/read.*"
+            ),
+            status_code=200,
+            json={
+                "totalRecordCount": 2,
+                "value": [{"Id": "1"}, {"Id": "2"}],
+            },
+        )
+        records = await service.list_records_async(
+            entity_key=str(entity_key), start=0, limit=10
+        )
+        assert records.total_count == 2
+
+    async def test_update_record_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update/rec-1",
+            method="POST",
+            status_code=200,
+            json={"Id": "rec-1", "name": "renamed"},
+        )
+        rec = await service.update_record_async(
+            entity_key=str(entity_key),
+            record_id="rec-1",
+            data={"name": "renamed"},
+        )
+        assert rec.id == "rec-1"
+
+    async def test_insert_records_async_batch(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/insert-batch.*"
+            ),
+            status_code=200,
+            json={
+                "successRecords": [{"Id": "1", "name": "a"}],
+                "failureRecords": [],
+            },
+        )
+        result = await service.insert_records_async(
+            entity_key=str(entity_key),
+            records=[{"name": "a"}],
+            expansion_level=1,
+            fail_on_first=True,
+        )
+        assert len(result.success_records) == 1
+
+    async def test_update_records_async_recovers_400_failures(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/update-batch",
+            method="POST",
+            status_code=400,
+            json={
+                "successRecords": [],
+                "failureRecords": [{"error": "not found"}],
+            },
+        )
+        result = await service.update_records_async(
+            entity_key=str(entity_key),
+            records=[{"Id": "missing", "name": "x"}],
+        )
+        assert result.failure_records[0].error == "not found"
+
+    async def test_delete_records_async_batch(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=re.compile(
+                rf"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/delete-batch.*"
+            ),
+            status_code=200,
+            json={
+                "successRecords": [{"Id": "rec-1"}],
+                "failureRecords": [],
+            },
+        )
+        result = await service.delete_records_async(
+            entity_key=str(entity_key),
+            record_ids=["rec-1"],
+            fail_on_first=False,
+        )
+        assert len(result.success_records) == 1
+
+    async def test_import_records_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/ent-1/bulk-upload",
+            method="POST",
+            status_code=200,
+            json={
+                "totalRecords": 3,
+                "insertedRecords": 3,
+                "errorFileLink": None,
+            },
+        )
+        result = await service.import_records_async(
+            entity_id="ent-1", file=b"a,b\n1,2\n"
+        )
+        assert result.inserted_records == 3
+
+    def test_validate_entity_batch_handles_success_and_failure_records(
+        self,
+        service: EntitiesService,
+    ) -> None:
+        response = MagicMock()
+        response.json.return_value = {
+            "successRecords": [{"Id": "ok-1", "name": "first"}],
+            "failureRecords": [{"error": "duplicate", "record": {"name": "dup"}}],
+        }
+        result = service.validate_entity_batch(response)
+        assert len(result.success_records) == 1
+        assert result.success_records[0].id == "ok-1"
+        assert result.failure_records[0].error == "duplicate"
+
+    def test_5xx_with_batch_shape_still_propagates(
+        self,
+        httpx_mock: HTTPXMock,
+        service: EntitiesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        """500 with successRecords/failureRecords shape must NOT be recovered."""
+        from uipath.platform.errors._enriched_exception import EnrichedException
+
+        entity_key = uuid.uuid4()
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/datafabric_/api/EntityService/entity/{entity_key}/insert-batch",
+            method="POST",
+            status_code=500,
+            json={"successRecords": [], "failureRecords": []},
+        )
+        with pytest.raises(EnrichedException):
+            service.insert_records(
+                entity_key=str(entity_key),
+                records=[{"name": "x"}],
+            )
diff --git a/packages/uipath-platform/tests/services/test_external_application_service.py b/packages/uipath-platform/tests/services/test_external_application_service.py
new file mode 100644
index 000000000..15c267888
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_external_application_service.py
@@ -0,0 +1,218 @@
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+
+from uipath.platform.common._external_application_service import (
+    ExternalApplicationService,
+)
+from uipath.platform.common.auth import TokenData
+from uipath.platform.errors import EnrichedException
+
+IDENTITY_SERVICE_SYNC = (
+    "uipath.platform.identity.IdentityService.get_client_credentials_token"
+)
+IDENTITY_SERVICE_ASYNC = (
+    "uipath.platform.identity.IdentityService.get_client_credentials_token_async"
+)
+
+
+class TestExternalApplicationService:
+    @pytest.mark.parametrize(
+        "url,expected_domain",
+        [
+            ("https://alpha.uipath.com", "alpha"),
+            ("https://sub.alpha.uipath.com", "alpha"),
+            ("https://staging.uipath.com", "staging"),
+            ("https://env.staging.uipath.com", "staging"),
+            ("https://cloud.uipath.com", "cloud"),
+            ("https://org.cloud.uipath.com", "cloud"),
+            ("https://something-else.com", "cloud"),
+            ("not-a-url", "cloud"),
+        ],
+    )
+    def test_extract_domain_from_base_url(self, url: str, expected_domain: str):
+        service = ExternalApplicationService(url)
+        assert service._domain == expected_domain
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_success(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        fake_token = TokenData(access_token="fake-token")
+
+        if use_async:
+            with patch(
+                IDENTITY_SERVICE_ASYNC, new_callable=AsyncMock, return_value=fake_token
+            ):
+                token = await service.get_token_data_async("client-id", "client-secret")
+        else:
+            with patch(IDENTITY_SERVICE_SYNC, return_value=fake_token):
+                token = service.get_token_data("client-id", "client-secret")
+
+        assert token.access_token == "fake-token"
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_invalid_client(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        response = httpx.Response(
+            400, json={}, request=httpx.Request("POST", "http://test")
+        )
+        side_effect = httpx.HTTPStatusError(
+            "", request=response.request, response=response
+        )
+
+        with pytest.raises(EnrichedException) as exc:
+            if use_async:
+                with patch(
+                    IDENTITY_SERVICE_ASYNC,
+                    new_callable=AsyncMock,
+                    side_effect=side_effect,
+                ):
+                    await service.get_token_data_async("bad-id", "bad-secret")
+            else:
+                with patch(IDENTITY_SERVICE_SYNC, side_effect=side_effect):
+                    service.get_token_data("bad-id", "bad-secret")
+
+        assert "400" in str(exc.value)
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_unauthorized(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        response = httpx.Response(
+            401, json={}, request=httpx.Request("POST", "http://test")
+        )
+        side_effect = httpx.HTTPStatusError(
+            "", request=response.request, response=response
+        )
+
+        with pytest.raises(EnrichedException) as exc:
+            if use_async:
+                with patch(
+                    IDENTITY_SERVICE_ASYNC,
+                    new_callable=AsyncMock,
+                    side_effect=side_effect,
+                ):
+                    await service.get_token_data_async("bad-id", "bad-secret")
+            else:
+                with patch(IDENTITY_SERVICE_SYNC, side_effect=side_effect):
+                    service.get_token_data("bad-id", "bad-secret")
+
+        assert "401" in str(exc.value)
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_unexpected_status(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        response = httpx.Response(
+            500, json={}, request=httpx.Request("POST", "http://test")
+        )
+        side_effect = httpx.HTTPStatusError(
+            "", request=response.request, response=response
+        )
+
+        with pytest.raises(EnrichedException) as exc:
+            if use_async:
+                with patch(
+                    IDENTITY_SERVICE_ASYNC,
+                    new_callable=AsyncMock,
+                    side_effect=side_effect,
+                ):
+                    await service.get_token_data_async("client-id", "client-secret")
+            else:
+                with patch(IDENTITY_SERVICE_SYNC, side_effect=side_effect):
+                    service.get_token_data("client-id", "client-secret")
+
+        assert "500" in str(exc.value)
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_network_error(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        side_effect = httpx.RequestError("network down")
+
+        with pytest.raises(Exception) as exc:
+            if use_async:
+                with patch(
+                    IDENTITY_SERVICE_ASYNC,
+                    new_callable=AsyncMock,
+                    side_effect=side_effect,
+                ):
+                    await service.get_token_data_async("client-id", "client-secret")
+            else:
+                with patch(IDENTITY_SERVICE_SYNC, side_effect=side_effect):
+                    service.get_token_data("client-id", "client-secret")
+
+        assert "Network error during authentication" in str(exc.value)
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_get_access_token_unexpected_exception(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        side_effect = ValueError("weird error")
+
+        with pytest.raises(Exception) as exc:
+            if use_async:
+                with patch(
+                    IDENTITY_SERVICE_ASYNC,
+                    new_callable=AsyncMock,
+                    side_effect=side_effect,
+                ):
+                    await service.get_token_data_async("client-id", "client-secret")
+            else:
+                with patch(IDENTITY_SERVICE_SYNC, side_effect=side_effect):
+                    service.get_token_data("client-id", "client-secret")
+
+        assert "Unexpected error during authentication" in str(exc.value)
+
+
+class TestExternalApplicationServiceDelegation:
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_delegates_to_identity_service(self, use_async: bool):
+        service = ExternalApplicationService("https://cloud.uipath.com")
+        fake_token = TokenData(access_token="delegated-token")
+
+        if use_async:
+            with patch.object(
+                service._identity_service,
+                "get_client_credentials_token_async",
+                new_callable=AsyncMock,
+                return_value=fake_token,
+            ) as mock_get_token:
+                result = await service.get_token_data_async(
+                    "my-id", "my-secret", scope="OR.Execution"
+                )
+
+            mock_get_token.assert_called_once_with(
+                client_id="my-id",
+                client_secret="my-secret",
+                scope="OR.Execution",
+            )
+        else:
+            with patch.object(
+                service._identity_service,
+                "get_client_credentials_token",
+                return_value=fake_token,
+            ) as mock_get_token:
+                result = service.get_token_data(
+                    "my-id", "my-secret", scope="OR.Execution"
+                )
+
+            mock_get_token.assert_called_once_with(
+                client_id="my-id",
+                client_secret="my-secret",
+                scope="OR.Execution",
+            )
+        assert result.access_token == "delegated-token"
+
+    @pytest.mark.parametrize(
+        "base_url,expected_domain",
+        [
+            ("https://alpha.uipath.com", "https://alpha.uipath.com"),
+            ("https://sub.alpha.uipath.com", "https://alpha.uipath.com"),
+            ("https://staging.uipath.com", "https://staging.uipath.com"),
+            ("https://env.staging.uipath.com", "https://staging.uipath.com"),
+            ("https://cloud.uipath.com", "https://cloud.uipath.com"),
+            ("https://org.cloud.uipath.com", "https://cloud.uipath.com"),
+            ("https://something-else.com", "https://cloud.uipath.com"),
+        ],
+    )
+    def test_domain_mapping_for_delegation(self, base_url: str, expected_domain: str):
+        service = ExternalApplicationService(base_url)
+        assert service._identity_service._domain == expected_domain
diff --git a/packages/uipath-platform/tests/services/test_folder_context.py b/packages/uipath-platform/tests/services/test_folder_context.py
new file mode 100644
index 000000000..ceaf33f88
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_folder_context.py
@@ -0,0 +1,116 @@
+"""Tests for folder path header encoding.
+
+Non-ASCII characters in folder paths must be Base64-encoded (UTF-16LE)
+and sent via the X-UIPATH-FolderPath-Encoded header, since HTTP headers
+require ASCII values. The Orchestrator decodes this with
+Convert.FromBase64String + Encoding.Unicode (UTF-16LE).
+"""
+
+from base64 import b64decode
+
+import pytest
+
+from uipath.platform.common._folder_context import (
+    FolderContext,
+    folder_path_header,
+    header_folder,
+)
+from uipath.platform.common.constants import (
+    HEADER_FOLDER_KEY,
+    HEADER_FOLDER_PATH,
+    HEADER_FOLDER_PATH_ENCODED,
+)
+
+# --- folder_path_header() ---
+
+
+class TestFolderPathHeader:
+    def test_ascii_path_uses_plain_header(self) -> None:
+        headers = folder_path_header("MyFolder/SubFolder")
+        assert headers == {HEADER_FOLDER_PATH: "MyFolder/SubFolder"}
+
+    def test_non_ascii_path_uses_encoded_header(self) -> None:
+        path = "VA\xa0Certificate"
+        headers = folder_path_header(path)
+        assert HEADER_FOLDER_PATH not in headers
+        assert HEADER_FOLDER_PATH_ENCODED in headers
+
+    def test_encoded_value_is_base64_utf16le(self) -> None:
+        path = "Debug_Poétry Writer"
+        headers = folder_path_header(path)
+        value = headers[HEADER_FOLDER_PATH_ENCODED]
+        decoded = b64decode(value).decode("utf-16-le")
+        assert decoded == path
+
+    def test_encoded_value_is_ascii_safe(self) -> None:
+        headers = folder_path_header("VA\xa0Certificate/Poétry")
+        headers[HEADER_FOLDER_PATH_ENCODED].encode("ascii")
+
+    def test_round_trip_with_non_breaking_space(self) -> None:
+        path = "VA\xa0Certificate of Eligibility Agent"
+        headers = folder_path_header(path)
+        decoded = b64decode(headers[HEADER_FOLDER_PATH_ENCODED]).decode("utf-16-le")
+        assert decoded == path
+
+
+# --- header_folder() ---
+
+
+class TestHeaderFolder:
+    def test_ascii_folder_path(self) -> None:
+        headers = header_folder(None, "MyFolder/SubFolder")
+        assert headers == {HEADER_FOLDER_PATH: "MyFolder/SubFolder"}
+
+    def test_non_ascii_folder_path_uses_encoded_header(self) -> None:
+        headers = header_folder(None, "VA\xa0Certificate")
+        assert HEADER_FOLDER_PATH not in headers
+        assert HEADER_FOLDER_PATH_ENCODED in headers
+
+    def test_folder_key_returned_as_is(self) -> None:
+        headers = header_folder("some-uuid-key", None)
+        assert headers == {HEADER_FOLDER_KEY: "some-uuid-key"}
+
+    def test_none_path_and_key_returns_empty(self) -> None:
+        assert header_folder(None, None) == {}
+
+    def test_both_key_and_path_raises(self) -> None:
+        with pytest.raises(ValueError):
+            header_folder("key", "path")
+
+
+# --- FolderContext.folder_headers ---
+
+
+class TestFolderContextHeaders:
+    def test_non_ascii_folder_path_uses_encoded_header(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        path = "VA\xa0Certificate"
+        monkeypatch.setenv("UIPATH_FOLDER_PATH", path)
+        monkeypatch.delenv("UIPATH_FOLDER_KEY", raising=False)
+        ctx = FolderContext()
+        headers = ctx.folder_headers
+        assert HEADER_FOLDER_PATH not in headers
+        value = headers[HEADER_FOLDER_PATH_ENCODED]
+        value.encode("ascii")
+        assert b64decode(value).decode("utf-16-le") == path
+
+    def test_ascii_folder_path_uses_plain_header(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_FOLDER_PATH", "my-folder")
+        monkeypatch.delenv("UIPATH_FOLDER_KEY", raising=False)
+        ctx = FolderContext()
+        assert ctx.folder_headers == {HEADER_FOLDER_PATH: "my-folder"}
+
+    def test_folder_key_takes_precedence(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_FOLDER_KEY", "my-key")
+        monkeypatch.setenv("UIPATH_FOLDER_PATH", "my-path")
+        ctx = FolderContext()
+        assert ctx.folder_headers == {HEADER_FOLDER_KEY: "my-key"}
+
+    def test_no_env_vars_returns_empty(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("UIPATH_FOLDER_KEY", raising=False)
+        monkeypatch.delenv("UIPATH_FOLDER_PATH", raising=False)
+        ctx = FolderContext()
+        assert ctx.folder_headers == {}
diff --git a/tests/sdk/services/test_folder_service.py b/packages/uipath-platform/tests/services/test_folder_service.py
similarity index 71%
rename from tests/sdk/services/test_folder_service.py
rename to packages/uipath-platform/tests/services/test_folder_service.py
index b91ff4c63..ae4b6804f 100644
--- a/tests/sdk/services/test_folder_service.py
+++ b/packages/uipath-platform/tests/services/test_folder_service.py
@@ -1,16 +1,16 @@
 import pytest
 from pytest_httpx import HTTPXMock
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.folder_service import FolderService
-from uipath._utils.constants import HEADER_USER_AGENT
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_USER_AGENT
+from uipath.platform.errors import FolderNotFoundException
+from uipath.platform.orchestrator._folder_service import FolderService
 
 
 @pytest.fixture
 def service(
-    config: Config,
-    execution_context: ExecutionContext,
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
     monkeypatch: pytest.MonkeyPatch,
 ) -> FolderService:
     monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
@@ -368,3 +368,134 @@ def test_retrieve_key_found_on_third_page(
         for i, request in enumerate(requests):
             assert request.method == "GET"
             assert request.url == expected_urls[i]
+
+    def test_retrieve_folder_key_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: FolderService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test retrieve_folder_key resolves folder_path to folder_key."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=Production&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "retrieved-folder-key",
+                        "FullyQualifiedName": "Finance/Production",
+                    }
+                ]
+            },
+        )
+
+        retrieved_key = service.retrieve_folder_key(folder_path="Finance/Production")
+
+        assert retrieved_key == "retrieved-folder-key"
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+
+    def test_retrieve_folder_key_raises_error(
+        self,
+        service: FolderService,
+    ) -> None:
+        """Test retrieve_folder_key raises ValueError when folder_path is not provided."""
+        with pytest.raises(ValueError) as exc_info:
+            service.retrieve_folder_key(folder_path=None)
+
+        assert "Cannot obtain folder_key without providing folder_path" in str(
+            exc_info.value
+        )
+
+    def test_retrieve_folder_key_not_found_raises_error(
+        self,
+        httpx_mock: HTTPXMock,
+        service: FolderService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test retrieve_folder_key raises ValueError when folder_path is not found."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=Folder&skip=0&take=20",
+            status_code=200,
+            json={"PageItems": []},
+        )
+
+        with pytest.raises(FolderNotFoundException) as exc_info:
+            service.retrieve_folder_key(folder_path="NonExistent/Folder")
+
+        assert "Folder NonExistent/Folder not found" in str(exc_info.value)
+
+    @pytest.mark.anyio
+    async def test_retrieve_folder_key_async_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: FolderService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test retrieve_folder_key_async resolves folder_path to folder_key."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=Production&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "async-retrieved-key",
+                        "FullyQualifiedName": "Finance/Production",
+                    }
+                ]
+            },
+        )
+
+        retrieved_key = await service.retrieve_folder_key_async(
+            folder_path="Finance/Production"
+        )
+
+        assert retrieved_key == "async-retrieved-key"
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "GET"
+
+    @pytest.mark.anyio
+    async def test_retrieve_folder_key_async_raises_error(
+        self,
+        service: FolderService,
+    ) -> None:
+        """Test retrieve_folder_key_async raises ValueError when folder_path is not provided."""
+        with pytest.raises(ValueError) as exc_info:
+            await service.retrieve_folder_key_async(folder_path=None)
+
+        assert "Cannot obtain folder_key without providing folder_path" in str(
+            exc_info.value
+        )
+
+    @pytest.mark.anyio
+    async def test_retrieve_folder_key_async_not_found_raises_error(
+        self,
+        httpx_mock: HTTPXMock,
+        service: FolderService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test retrieve_folder_key_async raises ValueError when folder_path is not found."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=Folder&skip=0&take=20",
+            status_code=200,
+            json={"PageItems": []},
+        )
+
+        with pytest.raises(FolderNotFoundException) as exc_info:
+            await service.retrieve_folder_key_async(folder_path="NonExistent/Folder")
+
+        assert "Folder NonExistent/Folder not found" in str(exc_info.value)
diff --git a/packages/uipath-platform/tests/services/test_governance_provider.py b/packages/uipath-platform/tests/services/test_governance_provider.py
new file mode 100644
index 000000000..24e489f65
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_governance_provider.py
@@ -0,0 +1,166 @@
+"""Tests for UiPathPlatformGovernanceProvider."""
+
+from __future__ import annotations
+
+import pytest
+from pytest_httpx import HTTPXMock
+from uipath.core.governance import (
+    EnforcementMode,
+    FiredRule,
+    GovernanceCompensationProvider,
+    GovernancePolicyProvider,
+    GovernRequest,
+    PolicyContext,
+)
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.governance import (
+    GovernanceService,
+    UiPathPlatformGovernanceProvider,
+)
+
+ORG_ID = "11111111-1111-1111-1111-111111111111"
+TENANT_ID = "22222222-2222-2222-2222-222222222222"
+
+
+def _make_request() -> GovernRequest:
+    return GovernRequest(
+        validators=["pii_detection"],
+        rules=[
+            FiredRule(
+                rule_id="ASI-01",
+                rule_name="Block PII in flight",
+                pack_name="agent-safety",
+                validator="pii_detection",
+            )
+        ],
+        data={"prompt": "hello"},
+        hook="before_model",
+        trace_id="0123456789abcdef0123456789abcdef",
+        src_timestamp="2026-06-22T10:00:00Z",
+        agent_name="my-agent",
+        runtime_id="runtime-1",
+    )
+
+
+@pytest.fixture
+def provider(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> UiPathPlatformGovernanceProvider:
+    monkeypatch.setenv("UIPATH_ORGANIZATION_ID", ORG_ID)
+    monkeypatch.setenv("UIPATH_TENANT_ID", TENANT_ID)
+    service = GovernanceService(config=config, execution_context=execution_context)
+    return UiPathPlatformGovernanceProvider(service=service)
+
+
+class TestConstruction:
+    def test_accepts_existing_service(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        service = GovernanceService(config=config, execution_context=execution_context)
+        provider = UiPathPlatformGovernanceProvider(service=service)
+        assert provider.service is service
+
+    def test_builds_service_from_config(
+        self,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
+    ) -> None:
+        provider = UiPathPlatformGovernanceProvider(
+            config=config, execution_context=execution_context
+        )
+        assert isinstance(provider.service, GovernanceService)
+
+    def test_requires_service_or_full_kwargs(self) -> None:
+        with pytest.raises(ValueError, match="GovernanceService"):
+            UiPathPlatformGovernanceProvider()
+
+
+class TestProtocolConformance:
+    def test_satisfies_policy_provider_protocol(
+        self, provider: UiPathPlatformGovernanceProvider
+    ) -> None:
+        assert isinstance(provider, GovernancePolicyProvider)
+
+    def test_satisfies_compensation_provider_protocol(
+        self, provider: UiPathPlatformGovernanceProvider
+    ) -> None:
+        assert isinstance(provider, GovernanceCompensationProvider)
+
+
+class TestDelegation:
+    def test_get_policy_delegates_to_service(
+        self,
+        httpx_mock: HTTPXMock,
+        provider: UiPathPlatformGovernanceProvider,
+        base_url: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=(
+                f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy"
+                "?agentType=conversational"
+            ),
+            status_code=200,
+            json={"mode": "enforce", "policies": "rules: []"},
+        )
+
+        response = provider.get_policy(PolicyContext(is_conversational=True))
+
+        assert response.mode is EnforcementMode.ENFORCE
+        assert response.policies == "rules: []"
+
+    async def test_get_policy_async_delegates_to_service(
+        self,
+        httpx_mock: HTTPXMock,
+        provider: UiPathPlatformGovernanceProvider,
+        base_url: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+            status_code=200,
+            json={"mode": "audit", "policies": ""},
+        )
+
+        response = await provider.get_policy_async(PolicyContext())
+
+        assert response.mode is EnforcementMode.AUDIT
+
+    def test_compensate_delegates_to_service(
+        self,
+        httpx_mock: HTTPXMock,
+        provider: UiPathPlatformGovernanceProvider,
+        base_url: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            status_code=200,
+            json={},
+        )
+
+        provider.compensate(_make_request())
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 1
+        assert requests[0].method == "POST"
+
+    async def test_compensate_async_delegates_to_service(
+        self,
+        httpx_mock: HTTPXMock,
+        provider: UiPathPlatformGovernanceProvider,
+        base_url: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            status_code=200,
+            json={},
+        )
+
+        await provider.compensate_async(_make_request())
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 1
+        assert requests[0].method == "POST"
diff --git a/packages/uipath-platform/tests/services/test_governance_service.py b/packages/uipath-platform/tests/services/test_governance_service.py
new file mode 100644
index 000000000..e437fdda0
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_governance_service.py
@@ -0,0 +1,594 @@
+"""Tests for GovernanceService."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+from uipath.core.governance import GovernancePolicyProvider, PolicyContext
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common import resolve_trace_id
+from uipath.platform.governance import (
+    FiredRule,
+    GovernanceService,
+    PolicyResponse,
+)
+
+ORG_ID = "11111111-1111-1111-1111-111111111111"
+TENANT_ID = "22222222-2222-2222-2222-222222222222"
+TENANT_ID_HEX = TENANT_ID.replace("-", "").lower()
+
+
+def _compensate_kwargs(**overrides: Any) -> dict[str, Any]:
+    """Default kwargs for ``service.compensate(...)``."""
+    defaults: dict[str, Any] = dict(
+        validators=["pii_detection"],
+        rules=[
+            FiredRule(
+                rule_id="ASI-01",
+                rule_name="Block PII in flight",
+                pack_name="agent-safety",
+                validator="pii_detection",
+            )
+        ],
+        data={"prompt": "hello"},
+        hook="before_model",
+        trace_id="0123456789abcdef0123456789abcdef",
+        src_timestamp="2026-06-22T10:00:00Z",
+        agent_name="my-agent",
+        runtime_id="runtime-1",
+    )
+    defaults.update(overrides)
+    return defaults
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> GovernanceService:
+    monkeypatch.setenv("UIPATH_ORGANIZATION_ID", ORG_ID)
+    monkeypatch.setenv("UIPATH_TENANT_ID", TENANT_ID)
+    return GovernanceService(config=config, execution_context=execution_context)
+
+
+class TestGovernanceService:
+    """Test GovernanceService functionality."""
+
+    class TestRetrievePolicy:
+        """Test retrieve_policy (sync)."""
+
+        def test_returns_parsed_policy(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+                status_code=200,
+                json={"mode": "enforce", "policies": "rules: []"},
+            )
+
+            result = service.retrieve_policy()
+
+            assert isinstance(result, PolicyResponse)
+            assert result.mode == "enforce"
+            assert result.policies == "rules: []"
+
+        def test_defaults_when_fields_missing(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+                status_code=200,
+                json={},
+            )
+
+            result = service.retrieve_policy()
+
+            assert result.mode is None
+            assert result.policies == ""
+
+        def test_sends_tenant_header_and_bearer_token(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            secret: str,
+        ) -> None:
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={"mode": "audit", "policies": ""})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+            )
+
+            service.retrieve_policy()
+
+            request = captured["request"]
+            assert request.method == "GET"
+            assert request.headers["x-uipath-internal-tenantid"] == TENANT_ID
+            assert request.headers["authorization"] == f"Bearer {secret}"
+            # No agentType query param when caller omits it.
+            assert "agentType" not in request.url.params
+
+        @pytest.mark.parametrize(
+            ("is_conversational", "expected"),
+            [(True, "conversational"), (False, "autonomous")],
+        )
+        def test_appends_agent_type_query_param(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            is_conversational: bool,
+            expected: str,
+        ) -> None:
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={"mode": "audit", "policies": ""})
+
+            httpx_mock.add_callback(
+                capture,
+                url=(
+                    f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy"
+                    f"?agentType={expected}"
+                ),
+            )
+
+            service.retrieve_policy(is_conversational=is_conversational)
+
+            assert captured["request"].url.params["agentType"] == expected
+
+        def test_raises_when_organization_id_missing(
+            self,
+            config: UiPathApiConfig,
+            execution_context: UiPathExecutionContext,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ORGANIZATION_ID", raising=False)
+            monkeypatch.setenv("UIPATH_TENANT_ID", TENANT_ID)
+            service = GovernanceService(
+                config=config, execution_context=execution_context
+            )
+
+            with pytest.raises(ValueError, match="UIPATH_ORGANIZATION_ID"):
+                service.retrieve_policy()
+
+        def test_raises_when_tenant_id_missing(
+            self,
+            config: UiPathApiConfig,
+            execution_context: UiPathExecutionContext,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv("UIPATH_ORGANIZATION_ID", ORG_ID)
+            monkeypatch.delenv("UIPATH_TENANT_ID", raising=False)
+            service = GovernanceService(
+                config=config, execution_context=execution_context
+            )
+
+            with pytest.raises(ValueError, match="UIPATH_TENANT_ID"):
+                service.retrieve_policy()
+
+        def test_raises_on_http_error(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            from uipath.platform.errors import EnrichedException
+
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+                status_code=500,
+                text="boom",
+            )
+
+            with pytest.raises(EnrichedException):
+                service.retrieve_policy()
+
+    class TestRetrievePolicyAsync:
+        """Test retrieve_policy_async."""
+
+        async def test_returns_parsed_policy(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=(
+                    f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy"
+                    "?agentType=autonomous"
+                ),
+                status_code=200,
+                json={"mode": "audit", "policies": "rules: []"},
+            )
+
+            result = await service.retrieve_policy_async(is_conversational=False)
+
+            assert result.mode == "audit"
+            assert result.policies == "rules: []"
+
+    class TestCompensate:
+        """Test compensate (sync)."""
+
+        def test_posts_aliased_payload(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            secret: str,
+        ) -> None:
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            )
+
+            service.compensate(**_compensate_kwargs())
+
+            request = captured["request"]
+            assert request.method == "POST"
+            assert request.headers["x-uipath-internal-tenantid"] == TENANT_ID
+            assert request.headers["authorization"] == f"Bearer {secret}"
+
+            body = json.loads(request.content)
+            assert body["type"] == ["pii_detection"]
+            assert body["rules"] == [
+                {
+                    "ruleId": "ASI-01",
+                    "ruleName": "Block PII in flight",
+                    "packName": "agent-safety",
+                    "validator": "pii_detection",
+                }
+            ]
+            assert body["traceId"] == "0123456789abcdef0123456789abcdef"
+            assert body["src_timestamp"] == "2026-06-22T10:00:00Z"
+            assert body["agentName"] == "my-agent"
+            assert body["runtimeId"] == "runtime-1"
+            assert body["hook"] == "before_model"
+            assert body["data"] == {"prompt": "hello"}
+
+        def test_autofills_job_context_from_config(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv("UIPATH_FOLDER_KEY", "folder-from-env")
+            monkeypatch.setenv("UIPATH_JOB_KEY", "job-from-env")
+            monkeypatch.setenv("UIPATH_PROCESS_UUID", "process-from-env")
+            monkeypatch.setenv("UIPATH_AGENT_ID", "agent-from-env")
+            monkeypatch.setenv("UIPATH_PROCESS_VERSION", "1.2.3")
+
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            )
+
+            service.compensate(**_compensate_kwargs())
+
+            body = json.loads(captured["request"].content)
+            assert body["folderKey"] == "folder-from-env"
+            assert body["jobKey"] == "job-from-env"
+            assert body["processKey"] == "process-from-env"
+            assert body["referenceId"] == "agent-from-env"
+            assert body["agentVersion"] == "1.2.3"
+
+        def test_caller_overrides_take_precedence(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv("UIPATH_FOLDER_KEY", "env-folder")
+            monkeypatch.setenv("UIPATH_JOB_KEY", "env-job")
+
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            )
+
+            service.compensate(**_compensate_kwargs(folder_key="explicit-folder"))
+
+            body = json.loads(captured["request"].content)
+            # Caller-supplied value wins.
+            assert body["folderKey"] == "explicit-folder"
+            # Env-backed fallback fills the unset one.
+            assert body["jobKey"] == "env-job"
+            # Unset and unbacked → key omitted.
+            assert "processKey" not in body
+
+        def test_caller_empty_string_is_not_overridden_by_env(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv("UIPATH_FOLDER_KEY", "env-folder")
+
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            )
+
+            # Explicit empty string is still a caller value — must not be
+            # silently replaced by the env-backed UiPathConfig fallback.
+            service.compensate(**_compensate_kwargs(folder_key=""))
+
+            body = json.loads(captured["request"].content)
+            assert body["folderKey"] == ""
+
+        def test_omits_job_context_keys_with_no_value(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            for env_key in (
+                "UIPATH_FOLDER_KEY",
+                "UIPATH_JOB_KEY",
+                "UIPATH_PROCESS_UUID",
+                "UIPATH_AGENT_ID",
+                "UIPATH_PROCESS_VERSION",
+                "UIPATH_PROJECT_ID",
+            ):
+                monkeypatch.delenv(env_key, raising=False)
+
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={})
+
+            httpx_mock.add_callback(
+                capture,
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+            )
+
+            service.compensate(**_compensate_kwargs())
+
+            body = json.loads(captured["request"].content)
+            for absent in (
+                "folderKey",
+                "jobKey",
+                "processKey",
+                "referenceId",
+                "agentVersion",
+            ):
+                assert absent not in body
+
+        def test_raises_on_http_error(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            from uipath.platform.errors import EnrichedException
+
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+                status_code=400,
+                text="bad payload",
+            )
+
+            with pytest.raises(EnrichedException):
+                service.compensate(**_compensate_kwargs())
+
+        def test_raises_when_org_id_missing(
+            self,
+            config: UiPathApiConfig,
+            execution_context: UiPathExecutionContext,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.delenv("UIPATH_ORGANIZATION_ID", raising=False)
+            monkeypatch.setenv("UIPATH_TENANT_ID", TENANT_ID)
+            service = GovernanceService(
+                config=config, execution_context=execution_context
+            )
+
+            with pytest.raises(ValueError, match="UIPATH_ORGANIZATION_ID"):
+                service.compensate(**_compensate_kwargs())
+
+    class TestCompensateAsync:
+        """Test compensate_async."""
+
+        async def test_posts_aliased_payload(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/govern",
+                status_code=200,
+                json={},
+            )
+
+            await service.compensate_async(**_compensate_kwargs())
+
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 1
+            assert requests[0].method == "POST"
+
+    class TestProtocolConformance:
+        """``get_policy`` adapter is the only protocol-shaped surface left
+        on :class:`GovernanceService`; compensation conformance is tested
+        against :class:`UiPathPlatformGovernanceProvider`.
+        """
+
+        def test_satisfies_policy_provider_protocol(
+            self, service: GovernanceService
+        ) -> None:
+            assert isinstance(service, GovernancePolicyProvider)
+
+        def test_get_policy_delegates_to_retrieve_policy(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=(
+                    f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy"
+                    "?agentType=conversational"
+                ),
+                status_code=200,
+                json={"mode": "enforce", "policies": "rules: []"},
+            )
+
+            response = service.get_policy(PolicyContext(is_conversational=True))
+
+            assert response.mode == "enforce"
+            assert response.policies == "rules: []"
+
+        async def test_get_policy_async_delegates(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            base_url: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}/{ORG_ID}/agenticgovernance_/api/v1/runtime/policy",
+                status_code=200,
+                json={"mode": "audit", "policies": ""},
+            )
+
+            response = await service.get_policy_async(PolicyContext())
+
+            assert response.mode == "audit"
+
+    class TestServiceUrlOverride:
+        """Honor UIPATH_SERVICE_URL_AGENTICGOVERNANCE for local dev."""
+
+        def test_redirects_policy_fetch_to_override(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv(
+                "UIPATH_SERVICE_URL_AGENTICGOVERNANCE", "http://localhost:8123"
+            )
+            captured: dict[str, httpx.Request] = {}
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                captured["request"] = request
+                return httpx.Response(200, json={"mode": "audit", "policies": ""})
+
+            httpx_mock.add_callback(
+                capture, url="http://localhost:8123/api/v1/runtime/policy"
+            )
+
+            service.retrieve_policy()
+
+            request = captured["request"]
+            # Routing headers replace the platform router, org-UUID path is dropped.
+            assert request.headers["X-UiPath-Internal-TenantId"] == TENANT_ID
+            assert request.headers["X-UiPath-Internal-AccountId"] == ORG_ID
+            assert ORG_ID not in str(request.url)
+
+        def test_redirects_compensate_to_override(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GovernanceService,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            monkeypatch.setenv(
+                "UIPATH_SERVICE_URL_AGENTICGOVERNANCE", "http://localhost:8123"
+            )
+            httpx_mock.add_response(
+                url="http://localhost:8123/api/v1/runtime/govern",
+                method="POST",
+                status_code=200,
+                json={},
+            )
+
+            service.compensate(**_compensate_kwargs())
+
+            sent = httpx_mock.get_requests()[-1]
+            assert sent.method == "POST"
+            assert sent.headers["X-UiPath-Internal-AccountId"] == ORG_ID
+
+
+class TestResolveTraceId:
+    """Test the resolve_trace_id helper."""
+
+    def test_returns_fallback_when_no_source_set(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("UIPATH_TRACE_ID", raising=False)
+
+        assert resolve_trace_id(fallback="fallback-id") == "fallback-id"
+
+    def test_returns_none_when_no_fallback(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("UIPATH_TRACE_ID", raising=False)
+
+        assert resolve_trace_id() is None
+
+    def test_reads_uipath_trace_id_in_hex_form(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TRACE_ID", "0123456789abcdef0123456789abcdef")
+
+        assert resolve_trace_id() == "0123456789abcdef0123456789abcdef"
+
+    def test_normalizes_uipath_trace_id_in_uuid_form(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TRACE_ID", TENANT_ID)
+
+        assert resolve_trace_id() == TENANT_ID_HEX
+
+    def test_falls_through_when_uipath_trace_id_is_malformed(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TRACE_ID", "not-a-valid-trace-id")
+
+        # No OTel context active → falls through to caller-supplied fallback.
+        assert resolve_trace_id(fallback="recovered") == "recovered"
diff --git a/packages/uipath-platform/tests/services/test_guardrails_decorators.py b/packages/uipath-platform/tests/services/test_guardrails_decorators.py
new file mode 100644
index 000000000..e578cba84
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_guardrails_decorators.py
@@ -0,0 +1,1171 @@
+"""Tests for the guardrails decorator framework in uipath-platform.
+
+Focus: meaningful business behaviour — serialization, PRE/POST evaluation,
+modification flow, stage enforcement, factory-function path, and integration
+scenarios modelled on the joke-agent-decorator sample.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import logging
+from typing import Annotated, Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pydantic import BaseModel
+from uipath.core.guardrails import (
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+)
+
+from uipath.platform.guardrails.decorators import (
+    BlockAction,
+    CustomValidator,
+    GuardrailAction,
+    GuardrailBlockException,
+    GuardrailExclude,
+    GuardrailExecutionStage,
+    LogAction,
+    LoggingSeverityLevel,
+    PIIDetectionEntity,
+    PIIDetectionEntityType,
+    PIIValidator,
+    PromptInjectionValidator,
+    guardrail,
+    register_guardrail_adapter,
+)
+from uipath.platform.guardrails.decorators._core import (
+    _collect_output,
+    _get_excluded_params,
+    _make_evaluator,
+    _reconstruct_output,
+    _serialize_value,
+)
+from uipath.platform.guardrails.decorators._registry import (
+    _adapters,
+)
+
+# ---------------------------------------------------------------------------
+# Shared result constants
+# ---------------------------------------------------------------------------
+
+_PASSED = GuardrailValidationResult(
+    result=GuardrailValidationResultType.PASSED,
+    reason="ok",
+)
+_FAILED = GuardrailValidationResult(
+    result=GuardrailValidationResultType.VALIDATION_FAILED,
+    reason="violation detected",
+)
+
+
+# ---------------------------------------------------------------------------
+# Registry isolation fixture
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture(autouse=True)
+def _isolate_adapter_registry():
+    """Snapshot and restore the global adapter registry around every test."""
+    snapshot = list(_adapters)
+    yield
+    _adapters.clear()
+    _adapters.extend(snapshot)
+
+
+# ---------------------------------------------------------------------------
+# Minimal fake types for adapter tests (no LangChain dependency)
+# ---------------------------------------------------------------------------
+
+
+class _DummyTarget:
+    """Minimal callable target recognised by _DummyAdapter."""
+
+    def __init__(self, return_value: Any = None) -> None:
+        self.return_value = (
+            return_value if return_value is not None else {"output": "result"}
+        )
+        self.invoke_calls: list[Any] = []
+
+    def invoke(self, args: Any) -> Any:
+        self.invoke_calls.append(args)
+        return self.return_value
+
+
+class _WrappedDummyTarget:
+    """A _DummyTarget wrapped with guardrail evaluation."""
+
+    def __init__(
+        self,
+        target: Any,
+        evaluator: Any,
+        action: GuardrailAction,
+        name: str,
+        stage: GuardrailExecutionStage,
+    ) -> None:
+        self._target = target
+        self._evaluator = evaluator
+        self._action = action
+        self._name = name
+        self._stage = stage
+
+    def invoke(self, args: Any) -> Any:
+        input_data = args if isinstance(args, dict) else {"input": args}
+        if self._stage in (
+            GuardrailExecutionStage.PRE,
+            GuardrailExecutionStage.PRE_AND_POST,
+        ):
+            result = self._evaluator(
+                input_data, GuardrailExecutionStage.PRE, input_data, None
+            )
+            if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+                self._action.handle_validation_result(result, input_data, self._name)
+        raw = self._target.invoke(args)
+        output_data = raw if isinstance(raw, dict) else {"output": raw}
+        if self._stage in (
+            GuardrailExecutionStage.POST,
+            GuardrailExecutionStage.PRE_AND_POST,
+        ):
+            result = self._evaluator(
+                output_data, GuardrailExecutionStage.POST, input_data, output_data
+            )
+            if result.result == GuardrailValidationResultType.VALIDATION_FAILED:
+                self._action.handle_validation_result(result, output_data, self._name)
+        return raw
+
+
+class _DummyAdapter:
+    """Adapter that handles _DummyTarget and _WrappedDummyTarget instances."""
+
+    def recognize(self, target: Any) -> bool:
+        return isinstance(target, (_DummyTarget, _WrappedDummyTarget))
+
+    def wrap(
+        self,
+        target: Any,
+        evaluator: Any,
+        action: GuardrailAction,
+        name: str,
+        stage: GuardrailExecutionStage,
+    ) -> Any:
+        return _WrappedDummyTarget(target, evaluator, action, name, stage)
+
+
+# ---------------------------------------------------------------------------
+# 1. PIIDetectionEntity — threshold boundary enforcement
+# ---------------------------------------------------------------------------
+
+
+class TestPIIDetectionEntity:
+    def test_threshold_below_zero_raises(self):
+        with pytest.raises(ValueError, match="0.0 and 1.0"):
+            PIIDetectionEntity(name="Email", threshold=-0.1)
+
+    def test_threshold_above_one_raises(self):
+        with pytest.raises(ValueError, match="0.0 and 1.0"):
+            PIIDetectionEntity(name="Email", threshold=1.1)
+
+
+# ---------------------------------------------------------------------------
+# 2. LogAction — does NOT stop execution; uses configured severity
+# ---------------------------------------------------------------------------
+
+
+class TestLogAction:
+    def test_violation_logs_guardrail_name_and_execution_continues(self, caplog):
+        action = LogAction()
+        with caplog.at_level(logging.WARNING):
+            result = action.handle_validation_result(_FAILED, "data", "MyGuardrail")
+        assert result is None  # execution continues
+        assert any("MyGuardrail" in r.message for r in caplog.records)
+
+    def test_pass_emits_no_log(self, caplog):
+        action = LogAction()
+        with caplog.at_level(logging.WARNING):
+            action.handle_validation_result(_PASSED, "data", "G")
+        assert not caplog.records
+
+    def test_custom_message_overrides_reason(self, caplog):
+        action = LogAction(message="custom alert")
+        with caplog.at_level(logging.WARNING):
+            action.handle_validation_result(_FAILED, "data", "G")
+        assert any("custom alert" in r.message for r in caplog.records)
+
+    def test_default_message_includes_validation_reason(self, caplog):
+        action = LogAction()
+        with caplog.at_level(logging.WARNING):
+            action.handle_validation_result(_FAILED, "data", "G")
+        assert any("violation detected" in r.message for r in caplog.records)
+
+    def test_debug_severity(self, caplog):
+        action = LogAction(severity_level=LoggingSeverityLevel.DEBUG)
+        with caplog.at_level(logging.DEBUG):
+            action.handle_validation_result(_FAILED, "data", "G")
+        debug_records = [r for r in caplog.records if r.levelno == logging.DEBUG]
+        assert debug_records
+
+
+# ---------------------------------------------------------------------------
+# 3. BlockAction — raises GuardrailBlockException on violation
+# ---------------------------------------------------------------------------
+
+
+class TestBlockAction:
+    def test_raises_on_violation(self):
+        action = BlockAction()
+        with pytest.raises(GuardrailBlockException):
+            action.handle_validation_result(_FAILED, "data", "G")
+
+    def test_no_raise_on_pass(self):
+        action = BlockAction()
+        result = action.handle_validation_result(_PASSED, "data", "G")
+        assert result is None
+
+    def test_title_and_detail_from_result(self):
+        action = BlockAction()
+        with pytest.raises(GuardrailBlockException) as exc_info:
+            action.handle_validation_result(_FAILED, "data", "MyGuardrail")
+        assert exc_info.value.title
+        assert exc_info.value.detail
+
+    def test_custom_title_and_detail(self):
+        action = BlockAction(title="Blocked", detail="Not allowed")
+        with pytest.raises(GuardrailBlockException) as exc_info:
+            action.handle_validation_result(_FAILED, "data", "G")
+        assert exc_info.value.title == "Blocked"
+        assert exc_info.value.detail == "Not allowed"
+
+
+# ---------------------------------------------------------------------------
+# 4. PIIValidator — builds correct BuiltInValidatorGuardrail
+# ---------------------------------------------------------------------------
+
+
+class TestPIIValidator:
+    def test_empty_entities_raises(self):
+        with pytest.raises(ValueError, match="non-empty"):
+            PIIValidator(entities=[])
+
+    def test_entity_names_and_thresholds_in_api_parameters(self):
+        v = PIIValidator(
+            entities=[
+                PIIDetectionEntity(PIIDetectionEntityType.EMAIL, 0.6),
+                PIIDetectionEntity(PIIDetectionEntityType.PERSON, 0.8),
+            ]
+        )
+        g = v.get_built_in_guardrail("G", None, True)
+        param_by_id = {p.id: p for p in g.validator_parameters}
+        entities_value = param_by_id["entities"].value
+        assert isinstance(entities_value, list)
+        assert "Email" in entities_value
+        assert "Person" in entities_value
+        thresholds_value = param_by_id["entityThresholds"].value
+        assert isinstance(thresholds_value, dict)
+        assert thresholds_value["Email"] == 0.6
+        assert thresholds_value["Person"] == 0.8
+
+    def test_no_scope_restriction(self):
+        v = PIIValidator(entities=[PIIDetectionEntity(PIIDetectionEntityType.EMAIL)])
+        # All stages allowed — no ValueError raised
+        v.validate_stage(GuardrailExecutionStage.PRE)
+        v.validate_stage(GuardrailExecutionStage.POST)
+
+    def test_selector_is_none(self):
+        v = PIIValidator(entities=[PIIDetectionEntity(PIIDetectionEntityType.EMAIL)])
+        g = v.get_built_in_guardrail("G", None, True)
+        assert g.selector is None
+
+
+# ---------------------------------------------------------------------------
+# 5. PromptInjectionValidator — LLM-only, PRE-only, threshold validation
+# ---------------------------------------------------------------------------
+
+
+class TestPromptInjectionValidator:
+    def test_threshold_below_zero_raises(self):
+        with pytest.raises(ValueError, match="threshold"):
+            PromptInjectionValidator(threshold=-0.1)
+
+    def test_threshold_above_one_raises(self):
+        with pytest.raises(ValueError, match="threshold"):
+            PromptInjectionValidator(threshold=1.1)
+
+    def test_restricted_to_pre_stage_only(self):
+        v = PromptInjectionValidator()
+        v.validate_stage(GuardrailExecutionStage.PRE)  # ok
+        with pytest.raises(ValueError):
+            v.validate_stage(GuardrailExecutionStage.POST)
+
+    def test_builds_prompt_injection_guardrail_with_threshold(self):
+        v = PromptInjectionValidator(threshold=0.7)
+        g = v.get_built_in_guardrail("PI", None, True)
+        assert g.validator_type == "prompt_injection"
+        threshold_param = next(p for p in g.validator_parameters if p.id == "threshold")
+        assert threshold_param.value == 0.7
+
+    def test_selector_is_none(self):
+        v = PromptInjectionValidator()
+        g = v.get_built_in_guardrail("PI", None, True)
+        assert g.selector is None
+
+
+# ---------------------------------------------------------------------------
+# 6. CustomValidator — rule routing and error handling
+# ---------------------------------------------------------------------------
+
+
+class TestCustomValidator:
+    def test_non_callable_raises(self):
+        with pytest.raises(ValueError, match="callable"):
+            CustomValidator(rule="not_a_function")  # type: ignore[arg-type]
+
+    def test_wrong_arity_raises(self):
+        with pytest.raises(ValueError, match="1 or 2"):
+            CustomValidator(rule=lambda: True)  # type: ignore[arg-type]
+        with pytest.raises(ValueError, match="1 or 2"):
+            CustomValidator(rule=lambda a, b, c: True)  # type: ignore[arg-type]
+
+    def test_one_param_pre_receives_input_data(self):
+        received: list[Any] = []
+
+        def capture_pre(args: dict[str, Any]) -> bool:
+            received.append(args)
+            return False
+
+        CustomValidator(rule=capture_pre).evaluate(
+            {}, GuardrailExecutionStage.PRE, {"a": 1}, None
+        )
+        assert received == [{"a": 1}]
+
+    def test_one_param_post_receives_output_data(self):
+        received: list[Any] = []
+
+        def capture_post(args: dict[str, Any]) -> bool:
+            received.append(args)
+            return False
+
+        CustomValidator(rule=capture_post).evaluate(
+            {}, GuardrailExecutionStage.POST, {"in": 1}, {"out": 2}
+        )
+        assert received == [{"out": 2}]
+
+    def test_two_param_post_receives_input_and_output(self):
+        received: list[Any] = []
+
+        def rule(inp: dict[str, Any], out: dict[str, Any]) -> bool:
+            received.append((inp, out))
+            return False
+
+        CustomValidator(rule=rule).evaluate(
+            {}, GuardrailExecutionStage.POST, {"in": 1}, {"out": 2}
+        )
+        assert received == [({"in": 1}, {"out": 2})]
+
+    def test_two_param_rule_skipped_when_input_missing(self):
+        result = CustomValidator(rule=lambda a, b: True).evaluate(
+            {}, GuardrailExecutionStage.POST, None, {"out": 2}
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_rule_returning_true_means_violation(self):
+        result = CustomValidator(rule=lambda args: True).evaluate(
+            {}, GuardrailExecutionStage.PRE, {"x": 1}, None
+        )
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_rule_exception_returns_passed(self):
+        def bad(args: dict[str, Any]) -> bool:
+            raise ValueError("boom")
+
+        result = CustomValidator(rule=bad).evaluate(
+            {}, GuardrailExecutionStage.PRE, {"x": 1}, None
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+
+# ---------------------------------------------------------------------------
+# 7. GuardrailExclude — parameter introspection
+# ---------------------------------------------------------------------------
+
+
+class TestGuardrailExclude:
+    def test_excluded_param_not_in_collected_input(self):
+        def func(
+            text: str,
+            config: Annotated[dict[str, Any], GuardrailExclude()],
+        ) -> str:
+            return text
+
+        excluded = _get_excluded_params(func)
+        assert "config" in excluded
+        assert "text" not in excluded
+
+    def test_multiple_excluded_params(self):
+        def func(
+            a: str,
+            b: Annotated[int, GuardrailExclude()],
+            c: Annotated[str, GuardrailExclude()],
+        ) -> str:
+            return a
+
+        excluded = _get_excluded_params(func)
+        assert excluded == {"b", "c"}
+
+    def test_no_annotations_returns_empty_set(self):
+        def func(a: str, b: int) -> str:
+            return a
+
+        assert _get_excluded_params(func) == set()
+
+
+# ---------------------------------------------------------------------------
+# 8. Serialization helpers
+# ---------------------------------------------------------------------------
+
+
+class _PydanticModel(BaseModel):
+    topic: str
+    count: int = 0
+
+
+@dataclasses.dataclass
+class _Dataclass:
+    name: str
+    value: float
+
+
+class TestSerializationHelpers:
+    def test_primitive_str_passthrough(self):
+        assert _serialize_value("hello") == "hello"
+
+    def test_primitive_int_passthrough(self):
+        assert _serialize_value(42) == 42
+
+    def test_dict_passthrough(self):
+        assert _serialize_value({"a": 1}) == {"a": 1}
+
+    def test_pydantic_model_dumps(self):
+        m = _PydanticModel(topic="test", count=3)
+        result = _serialize_value(m)
+        assert result == {"topic": "test", "count": 3}
+
+    def test_dataclass_asdict(self):
+        d = _Dataclass(name="x", value=1.5)
+        result = _serialize_value(d)
+        assert result == {"name": "x", "value": 1.5}
+
+    def test_collect_output_from_pydantic(self):
+        m = _PydanticModel(topic="joke")
+        result = _collect_output(m)
+        assert result == {"topic": "joke", "count": 0}
+
+    def test_collect_output_from_str(self):
+        result = _collect_output("hello")
+        assert result == {"return": "hello"}
+
+    def test_collect_output_from_dict(self):
+        result = _collect_output({"key": "val"})
+        assert result == {"key": "val"}
+
+    def test_reconstruct_output_pydantic(self):
+        original = _PydanticModel(topic="original")
+        modified = {"topic": "modified", "count": 5}
+        result = _reconstruct_output(original, modified)
+        assert isinstance(result, _PydanticModel)
+        assert result.topic == "modified"
+        assert result.count == 5
+
+    def test_reconstruct_output_str(self):
+        result = _reconstruct_output("original", "modified")
+        assert result == "modified"
+
+    def test_reconstruct_output_none_returns_original(self):
+        result = _reconstruct_output("original", None)
+        assert result == "original"
+
+
+# ---------------------------------------------------------------------------
+# 9. @guardrail on sync functions
+# ---------------------------------------------------------------------------
+
+
+class TestGuardrailOnSyncFunction:
+    def test_pre_fires_before_function(self):
+        calls: list[str] = []
+
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.side_effect = lambda *a, **kw: (
+            calls.append("eval") or _PASSED  # type: ignore[func-returns-value]
+        )
+
+        @guardrail(
+            validator=mock_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(text: str) -> str:
+            calls.append("fn")
+            return text
+
+        fn("hello")
+        assert calls == ["eval", "fn"]
+
+    def test_post_fires_after_function(self):
+        calls: list[str] = []
+
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.side_effect = lambda *a, **kw: (
+            calls.append("eval") or _PASSED  # type: ignore[func-returns-value]
+        )
+
+        @guardrail(
+            validator=mock_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.POST,
+        )
+        def fn(text: str) -> str:
+            calls.append("fn")
+            return text
+
+        fn("hello")
+        assert calls == ["fn", "eval"]
+
+    def test_block_action_raises_guardrail_block_exception(self):
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.return_value = _FAILED
+
+        @guardrail(
+            validator=mock_validator,
+            action=BlockAction(title="Blocked", detail="not allowed"),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(text: str) -> str:
+            return text
+
+        with pytest.raises(GuardrailBlockException):
+            fn("bad input")
+
+    def test_log_action_does_not_stop_execution(self):
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.return_value = _FAILED
+
+        result = []
+
+        @guardrail(
+            validator=mock_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(text: str) -> str:
+            result.append("called")
+            return text
+
+        fn("input")
+        assert result == ["called"]
+
+    def test_pre_input_contains_function_params(self):
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(joke: str, count: int) -> str:
+            return joke
+
+        fn("why did the chicken", 3)
+        assert captured == [{"joke": "why did the chicken", "count": 3}]
+
+    def test_excluded_param_absent_from_pre_input(self):
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(
+            joke: str,
+            config: Annotated[dict[str, Any], GuardrailExclude()],
+        ) -> str:
+            return joke
+
+        fn("why did the chicken", {"debug": True})
+        assert "config" not in captured[0]
+        assert "joke" in captured[0]
+
+    def test_pre_modification_updates_function_args(self):
+        class _ReplaceAction(GuardrailAction):
+            def handle_validation_result(self, result, data, name):
+                if isinstance(data, dict) and "joke" in data:
+                    return {"joke": data["joke"].replace("donkey", "[censored]")}
+                return data
+
+        @guardrail(
+            validator=CustomValidator(lambda args: "donkey" in args.get("joke", "")),
+            action=_ReplaceAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(joke: str) -> str:
+            return joke
+
+        result = fn("why did the donkey cross the road")
+        assert result == "why did the [censored] cross the road"
+
+    def test_post_output_contains_return_value(self):
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.POST,
+        )
+        def fn(x: int) -> dict[str, int]:
+            return {"result": x * 2}
+
+        fn(5)
+        assert captured == [{"result": 10}]
+
+    def test_post_modification_updates_return_value(self):
+        class _FixedAction(GuardrailAction):
+            def handle_validation_result(self, result, data, name):
+                return {"result": 99}
+
+        @guardrail(
+            validator=CustomValidator(lambda args: True),
+            action=_FixedAction(),
+            stage=GuardrailExecutionStage.POST,
+        )
+        def fn(x: int) -> dict[str, int]:
+            return {"result": x * 2}
+
+        assert fn(5) == {"result": 99}
+
+    def test_pre_and_post_both_fire(self):
+        calls: list[str] = []
+
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.side_effect = lambda name, desc, enabled, data, stage, *a: (
+            calls.append(stage.value) or _PASSED  # type: ignore[func-returns-value]
+        )
+
+        @guardrail(
+            validator=mock_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE_AND_POST,
+        )
+        def fn(x: int) -> int:
+            return x + 1
+
+        fn(1)
+        assert "pre" in calls
+        assert "post" in calls
+
+
+# ---------------------------------------------------------------------------
+# 10. @guardrail on async functions
+# ---------------------------------------------------------------------------
+
+
+class TestGuardrailOnAsyncFunction:
+    @pytest.mark.asyncio
+    async def test_pre_fires_before_async_function(self):
+        calls: list[str] = []
+
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.side_effect = lambda *a, **kw: (
+            calls.append("eval") or _PASSED  # type: ignore[func-returns-value]
+        )
+
+        @guardrail(
+            validator=mock_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        async def fn(text: str) -> str:
+            calls.append("fn")
+            return text
+
+        await fn("hello")
+        assert calls == ["eval", "fn"]
+
+    @pytest.mark.asyncio
+    async def test_block_action_raises_in_async(self):
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.return_value = _FAILED
+
+        @guardrail(
+            validator=mock_validator,
+            action=BlockAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        async def fn(text: str) -> str:
+            return text
+
+        with pytest.raises(GuardrailBlockException):
+            await fn("bad")
+
+    @pytest.mark.asyncio
+    async def test_post_modification_in_async(self):
+        class _FortyTwoAction(GuardrailAction):
+            def handle_validation_result(self, result, data, name):
+                return {"result": 42}
+
+        @guardrail(
+            validator=CustomValidator(lambda args: True),
+            action=_FortyTwoAction(),
+            stage=GuardrailExecutionStage.POST,
+        )
+        async def fn(x: int) -> dict[str, int]:
+            return {"result": x}
+
+        assert await fn(1) == {"result": 42}
+
+
+# ---------------------------------------------------------------------------
+# 11. Stage enforcement at decoration time
+# ---------------------------------------------------------------------------
+
+
+class TestStageEnforcement:
+    def test_prompt_injection_on_post_raises_at_decoration(self):
+        with pytest.raises(ValueError, match="stage"):
+            guardrail(
+                lambda text: text,
+                validator=PromptInjectionValidator(),
+                action=LogAction(),
+                stage=GuardrailExecutionStage.POST,
+            )
+
+    def test_prompt_injection_on_pre_and_post_raises_at_decoration(self):
+        with pytest.raises(ValueError, match="stage"):
+            guardrail(
+                lambda text: text,
+                validator=PromptInjectionValidator(),
+                action=LogAction(),
+                stage=GuardrailExecutionStage.PRE_AND_POST,
+            )
+
+    def test_prompt_injection_on_pre_ok(self):
+        # Should not raise
+        guardrail(
+            lambda text: text,
+            validator=PromptInjectionValidator(),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+
+
+# ---------------------------------------------------------------------------
+# 12. @guardrail validation (bad arguments)
+# ---------------------------------------------------------------------------
+
+
+class TestGuardrailDecorator:
+    def test_missing_action_raises(self):
+        with pytest.raises(ValueError, match="action must be provided"):
+            guardrail(
+                lambda text: text,
+                validator=CustomValidator(lambda args: False),
+                action=None,  # type: ignore[arg-type]
+            )
+
+    def test_non_action_instance_raises(self):
+        with pytest.raises(ValueError, match="GuardrailAction"):
+            guardrail(
+                lambda text: text,
+                validator=CustomValidator(lambda args: False),
+                action="bad",  # type: ignore[arg-type]
+            )
+
+    def test_invalid_enabled_for_evals_type_raises(self):
+        with pytest.raises(ValueError, match="boolean"):
+            guardrail(
+                lambda text: text,
+                validator=CustomValidator(lambda args: False),
+                action=LogAction(),
+                enabled_for_evals="yes",  # type: ignore[arg-type]
+            )
+
+
+# ---------------------------------------------------------------------------
+# 13. Stacked decorators
+# ---------------------------------------------------------------------------
+
+
+class TestStackedDecorators:
+    def test_both_decorators_fire_on_same_function(self):
+        calls: list[str] = []
+
+        def _make_mock(tag: str) -> Any:
+            m = MagicMock()
+            m.supported_stages = []
+            m.validate_stage = MagicMock()
+            m.get_built_in_guardrail.return_value = None
+            m.run.side_effect = lambda *a, **kw: calls.append(tag) or _PASSED  # type: ignore[func-returns-value]
+            return m
+
+        @guardrail(
+            validator=_make_mock("outer"),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+            name="outer",
+        )
+        @guardrail(
+            validator=_make_mock("inner"),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+            name="inner",
+        )
+        def fn(text: str) -> str:
+            return text
+
+        fn("hello")
+        assert "outer" in calls
+        assert "inner" in calls
+
+    def test_outer_block_prevents_inner_from_firing(self):
+        inner_called = []
+
+        outer_validator = MagicMock()
+        outer_validator.supported_stages = []
+        outer_validator.validate_stage = MagicMock()
+        outer_validator.get_built_in_guardrail.return_value = None
+        outer_validator.run.return_value = _FAILED
+
+        inner_validator = MagicMock()
+        inner_validator.supported_stages = []
+        inner_validator.validate_stage = MagicMock()
+        inner_validator.get_built_in_guardrail.return_value = None
+        inner_validator.run.side_effect = lambda *a, **kw: (
+            inner_called.append(True) or _PASSED  # type: ignore[func-returns-value]
+        )
+
+        @guardrail(
+            validator=outer_validator,
+            action=BlockAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        @guardrail(
+            validator=inner_validator,
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def fn(text: str) -> str:
+            return text
+
+        with pytest.raises(GuardrailBlockException):
+            fn("bad")
+
+        assert not inner_called
+
+
+# ---------------------------------------------------------------------------
+# 14. Factory function path (adapter wraps return value)
+# ---------------------------------------------------------------------------
+
+
+class TestFactoryFunctionPath:
+    def test_adapter_wraps_return_value_of_factory(self):
+        register_guardrail_adapter(_DummyAdapter())
+        target = _DummyTarget(return_value={"output": "ok"})
+
+        @guardrail(
+            validator=CustomValidator(lambda args: False),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def factory() -> _DummyTarget:
+            return target
+
+        wrapped = factory()
+        assert isinstance(wrapped, _WrappedDummyTarget)
+
+    def test_factory_pre_guardrail_fires_on_factory_params(self):
+        register_guardrail_adapter(_DummyAdapter())
+        captured: list[Any] = []
+        target = _DummyTarget()
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def factory(config: str) -> _DummyTarget:
+            return target
+
+        factory("test-config")
+        assert captured == [{"config": "test-config"}]
+
+    def test_adapter_recognizes_direct_object(self):
+        register_guardrail_adapter(_DummyAdapter())
+        target = _DummyTarget()
+
+        wrapped = guardrail(
+            target,
+            validator=CustomValidator(lambda args: False),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        assert isinstance(wrapped, _WrappedDummyTarget)
+
+    def test_stacked_guardrails_on_factory_both_wrap_return_value(self):
+        register_guardrail_adapter(_DummyAdapter())
+        target = _DummyTarget()
+        evals: list[str] = []
+
+        def _make_mock(tag: str) -> Any:
+            m = MagicMock()
+            m.supported_stages = []
+            m.validate_stage = MagicMock()
+            m.get_built_in_guardrail.return_value = None
+            m.run.side_effect = lambda *a, **kw: evals.append(tag) or _PASSED  # type: ignore[func-returns-value]
+            return m
+
+        @guardrail(
+            validator=_make_mock("outer"),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        @guardrail(
+            validator=_make_mock("inner"),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def factory() -> _DummyTarget:
+            return target
+
+        wrapped = factory()
+        wrapped.invoke({"x": 1})
+        assert "outer" in evals
+        assert "inner" in evals
+
+
+# ---------------------------------------------------------------------------
+# 15. _make_evaluator — local vs API path
+# ---------------------------------------------------------------------------
+
+
+class TestMakeEvaluator:
+    def test_custom_validator_path_delegates_to_run(self):
+        """_make_evaluator with a CustomGuardrailValidator calls validator.run()."""
+        mock_validator = MagicMock()
+        mock_validator.run.return_value = _PASSED
+        evaluator = _make_evaluator(mock_validator, "G", None, True)
+        result = evaluator({"data": 1}, GuardrailExecutionStage.PRE, {"a": 1}, None)
+        mock_validator.run.assert_called_once_with(
+            "G", None, True, {"data": 1}, GuardrailExecutionStage.PRE, {"a": 1}, None
+        )
+        assert result == _PASSED
+
+    def test_built_in_validator_path_lazy_initializes_uipath(self):
+        """BuiltInGuardrailValidator.run() lazily creates UiPath() and calls API."""
+        from uipath.platform.guardrails.decorators.validators import (
+            BuiltInGuardrailValidator,
+        )
+        from uipath.platform.guardrails.guardrails import BuiltInValidatorGuardrail
+
+        mock_built_in = MagicMock(spec=BuiltInValidatorGuardrail)
+
+        class _TestBuiltIn(BuiltInGuardrailValidator):
+            def get_built_in_guardrail(self, name, description, enabled_for_evals):
+                return mock_built_in
+
+        validator = _TestBuiltIn()
+        evaluator = _make_evaluator(validator, "G", None, True)
+
+        mock_uipath = MagicMock()
+        mock_uipath.guardrails.evaluate_guardrail.return_value = _PASSED
+        with patch("uipath.platform.UiPath", return_value=mock_uipath):
+            evaluator({"text": "hello"}, GuardrailExecutionStage.PRE, None, None)
+            evaluator({"text": "hello"}, GuardrailExecutionStage.PRE, None, None)
+
+        # UiPath() should be created only once despite two calls
+        assert mock_uipath.guardrails.evaluate_guardrail.call_count == 2
+
+
+# ---------------------------------------------------------------------------
+# 16. Joke-agent integration scenarios (plain functions)
+# ---------------------------------------------------------------------------
+
+
+class _JokeInput(BaseModel):
+    topic: str
+
+
+class _JokeOutput(BaseModel):
+    joke: str
+
+
+class TestJokeAgentScenarios:
+    """Integration tests modelled on the joke-agent-decorator sample."""
+
+    def test_pii_validator_blocks_person_name_in_topic(self):
+        """Agent-level PRE guardrail blocks person names in the input topic."""
+        calls: list[str] = []
+
+        mock_validator = MagicMock()
+        mock_validator.supported_stages = []
+        mock_validator.validate_stage = MagicMock()
+
+        mock_validator.run.return_value = _FAILED
+
+        @guardrail(
+            validator=mock_validator,
+            action=BlockAction(title="Person detected", detail="Not allowed"),
+            stage=GuardrailExecutionStage.PRE,
+            name="Agent PII",
+        )
+        async def joke_node(state: _JokeInput) -> _JokeOutput:
+            calls.append("called")
+            return _JokeOutput(joke="a joke")
+
+        import asyncio
+
+        with pytest.raises(GuardrailBlockException):
+            asyncio.run(joke_node(_JokeInput(topic="John Smith")))
+        assert not calls
+
+    def test_input_pydantic_model_serialized_for_guardrail(self):
+        """State Pydantic model is serialized to dict and sent to evaluator."""
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def process(state: _JokeInput) -> _JokeOutput:
+            return _JokeOutput(joke="a joke")
+
+        process(_JokeInput(topic="cats"))
+        assert captured == [{"state": {"topic": "cats"}}]
+
+    def test_output_pydantic_model_serialized_for_guardrail(self):
+        """Return Pydantic model is serialized to dict and sent to POST evaluator."""
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.POST,
+        )
+        def process(state: _JokeInput) -> _JokeOutput:
+            return _JokeOutput(joke="funny joke about cats")
+
+        process(_JokeInput(topic="cats"))
+        assert captured == [{"joke": "funny joke about cats"}]
+
+    def test_excluded_config_param_not_in_guardrail_input(self):
+        """RunnableConfig-style param excluded from evaluation."""
+        captured: list[Any] = []
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: captured.append(args) or False  # type: ignore[func-returns-value]
+            ),
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def process(
+            state: _JokeInput,
+            config: Annotated[dict[str, Any], GuardrailExclude()],
+        ) -> _JokeOutput:
+            return _JokeOutput(joke="joke")
+
+        process(_JokeInput(topic="dogs"), {"thread_id": "abc"})
+        assert "config" not in captured[0]
+        assert "state" in captured[0]
+
+    def test_word_filter_custom_validator_on_tool_function(self):
+        """CustomValidator on plain function replaces offensive word via action."""
+        censored: list[str] = []
+
+        class CensorAction(GuardrailAction):
+            def handle_validation_result(self, result, data, name):
+                if isinstance(data, dict) and "joke" in data:
+                    censored.append(data["joke"])
+                    return {"joke": data["joke"].replace("donkey", "[censored]")}
+                return data
+
+        @guardrail(
+            validator=CustomValidator(
+                lambda args: "donkey" in args.get("joke", "").lower()
+            ),
+            action=CensorAction(),
+            stage=GuardrailExecutionStage.PRE,
+            name="Word Filter",
+        )
+        def analyze_joke(joke: str) -> str:
+            return f"analyzed: {joke}"
+
+        result = analyze_joke(joke="why did the donkey cross the road")
+        assert "censored" in result
+        assert "donkey" not in result
+
+    def test_log_action_does_not_stop_joke_generation(self):
+        """LogAction on PII violation logs but lets execution continue."""
+
+        @guardrail(
+            validator=CustomValidator(lambda args: True),  # always violate
+            action=LogAction(),
+            stage=GuardrailExecutionStage.PRE,
+            name="Always-Log",
+        )
+        def generate_joke(topic: str) -> str:
+            return f"joke about {topic}"
+
+        result = generate_joke("cats")
+        assert result == "joke about cats"
+
+    def test_length_limiter_blocks_long_joke(self):
+        """BlockAction on length check raises for over-long content."""
+
+        @guardrail(
+            validator=CustomValidator(lambda args: len(args.get("joke", "")) > 10),
+            action=BlockAction(title="Too long", detail="Joke exceeds limit"),
+            stage=GuardrailExecutionStage.PRE,
+        )
+        def submit_joke(joke: str) -> str:
+            return joke
+
+        with pytest.raises(GuardrailBlockException, match="Too long"):
+            submit_joke(joke="a" * 20)
+
+        # Short joke passes through
+        assert submit_joke(joke="short") == "short"
diff --git a/packages/uipath-platform/tests/services/test_guardrails_service.py b/packages/uipath-platform/tests/services/test_guardrails_service.py
new file mode 100644
index 000000000..e9d73a06f
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_guardrails_service.py
@@ -0,0 +1,479 @@
+import json
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+from uipath.core.guardrails import (
+    GuardrailScope,
+    GuardrailSelector,
+    GuardrailValidationResultType,
+)
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.guardrails import (
+    BuiltInValidatorGuardrail,
+    EnumListParameterValue,
+    GuardrailsService,
+    MapEnumParameterValue,
+)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> GuardrailsService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    return GuardrailsService(config=config, execution_context=execution_context)
+
+
+class TestGuardrailsService:
+    """Test GuardrailsService functionality."""
+
+    class TestEvaluateGuardrail:
+        """Test evaluate_guardrail method."""
+
+        def test_evaluate_guardrail_validation(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            print(f"base_url: {base_url}, org: {org}, tenant: {tenant}")
+            # Mock the API response
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=200,
+                json={
+                    "result": "PASSED",
+                    "details": "Validation passed",
+                },
+            )
+
+            # Create a PII detection guardrail
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII detection guardrail",
+                description="Test PII detection",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["StringToNumber"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[
+                    EnumListParameterValue(
+                        parameter_type="enum-list",
+                        id="entities",
+                        value=["Email", "Address"],
+                    ),
+                    MapEnumParameterValue(
+                        parameter_type="map-enum",
+                        id="entityThresholds",
+                        value={"Email": 1, "Address": 0.7},
+                    ),
+                ],
+            )
+
+            test_input = "There is no email or address here."
+
+            result = service.evaluate_guardrail(test_input, pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.PASSED
+            assert result.reason == "Validation passed"
+
+        def test_evaluate_guardrail_validation_failed(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # Mock API response for failed validation
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=200,
+                json={
+                    "result": "VALIDATION_FAILED",
+                    "details": "PII detected: Email found",
+                },
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII detection guardrail",
+                description="Test PII detection",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["StringToNumber"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            test_input = "Contact me at john@example.com"
+
+            result = service.evaluate_guardrail(test_input, pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+            assert result.reason == "PII detected: Email found"
+
+        def test_evaluate_guardrail_feature_disabled_403(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # Mock API response with 403 status for FEATURE_DISABLED
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=403,
+                json={
+                    "result": "FEATURE_DISABLED",
+                    "details": "Guardrail feature is disabled",
+                },
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII detection guardrail",
+                description="Test PII detection",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["StringToNumber"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            test_input = "Contact me at john@example.com"
+
+            result = service.evaluate_guardrail(test_input, pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.FEATURE_DISABLED
+            assert result.reason == "Guardrail feature is disabled"
+
+        def test_evaluate_guardrail_entitlements_missing_403(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # Mock API response with 403 status for ENTITLEMENTS_MISSING
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=403,
+                json={
+                    "result": "ENTITLEMENTS_MISSING",
+                    "details": "Guardrail entitlement is missing",
+                },
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII detection guardrail",
+                description="Test PII detection",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["StringToNumber"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            test_input = "Contact me at john@example.com"
+
+            result = service.evaluate_guardrail(test_input, pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.ENTITLEMENTS_MISSING
+            assert result.reason == "Guardrail entitlement is missing"
+
+        def test_evaluate_guardrail_request_payload_structure(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            """Test that the request payload has the correct structure after revert."""
+            captured_request = None
+
+            def capture_request(request):
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(
+                    status_code=200,
+                    json={
+                        "result": "PASSED",
+                        "details": "Validation passed",
+                    },
+                )
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                callback=capture_request,
+            )
+
+            # Create a PII detection guardrail with parameters
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII detection guardrail",
+                description="Test PII detection",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["StringToNumber"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[
+                    EnumListParameterValue(
+                        parameter_type="enum-list",
+                        id="entities",
+                        value=["Email", "Address"],
+                    ),
+                    MapEnumParameterValue(
+                        parameter_type="map-enum",
+                        id="entityThresholds",
+                        value={"Email": 1, "Address": 0.7},
+                    ),
+                ],
+            )
+
+            test_input = "There is no email or address here."
+
+            result = service.evaluate_guardrail(test_input, pii_guardrail)
+
+            # Verify the request was captured
+            assert captured_request is not None
+
+            # Parse the request payload
+            request_payload = json.loads(captured_request.content)
+
+            # Verify the payload structure:
+            # {
+            #     "validator": guardrail.validator_type,
+            #     "input": input_data,
+            #     "parameters": parameters,
+            #     "guardrailName": guardrail.name,
+            # }
+            assert "validator" in request_payload
+            assert "input" in request_payload
+            assert "parameters" in request_payload
+            assert "guardrailName" in request_payload
+            assert request_payload["guardrailName"] == "PII detection guardrail"
+
+            # Verify validator is a string (not an object)
+            assert isinstance(request_payload["validator"], str)
+            assert request_payload["validator"] == "pii_detection"
+
+            # Verify input is a string
+            assert isinstance(request_payload["input"], str)
+            assert request_payload["input"] == "There is no email or address here."
+
+            # Verify parameters is an array
+            assert isinstance(request_payload["parameters"], list)
+            assert len(request_payload["parameters"]) == 2
+
+            # Verify parameter structure
+            entities_param = request_payload["parameters"][0]
+            assert entities_param["$parameterType"] == "enum-list"
+            assert entities_param["id"] == "entities"
+            assert entities_param["value"] == ["Email", "Address"]
+
+            thresholds_param = request_payload["parameters"][1]
+            assert thresholds_param["$parameterType"] == "map-enum"
+            assert thresholds_param["id"] == "entityThresholds"
+            assert thresholds_param["value"] == {"Email": 1, "Address": 0.7}
+
+            # Verify result fields
+            assert result.result == GuardrailValidationResultType.PASSED
+            assert result.reason == "Validation passed"
+
+        def test_evaluate_guardrail_sends_trace_context_headers(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            """Outgoing request includes trace context headers."""
+            captured_request = None
+
+            def capture_request(request):
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(
+                    status_code=200,
+                    json={
+                        "result": "PASSED",
+                        "details": "OK",
+                    },
+                )
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                callback=capture_request,
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII guardrail",
+                description="Test",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["tool1"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            service.evaluate_guardrail("test input", pii_guardrail)
+
+            assert captured_request is not None
+            # build_trace_context_headers() injects traceparent/tracestate when
+            # an active span exists; at minimum, the merge with spec.headers
+            # should not fail and the request should go through successfully.
+            # When there IS an active trace context, headers are present:
+            headers = dict(captured_request.headers)
+            # The request should have been sent (basic smoke check that
+            # header merging works even when no active span exists)
+            assert "content-type" in headers
+
+        def test_evaluate_guardrail_extracts_span_id_from_traceparent(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            """Response with x-uipath-traceparent-id header populates span_id."""
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=200,
+                json={
+                    "result": "VALIDATION_FAILED",
+                    "details": "PII detected",
+                },
+                headers={
+                    "x-uipath-traceparent-id": "00-abcdef1234567890abcdef1234567890-1234567890abcdef"
+                },
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII guardrail",
+                description="Test",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["tool1"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            result = service.evaluate_guardrail("test input", pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+            assert result.span_id == "00000000-0000-0000-1234-567890abcdef"
+
+        def test_evaluate_guardrail_no_traceparent_header_no_span_id(
+            self,
+            httpx_mock: HTTPXMock,
+            service: GuardrailsService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            """Response without x-uipath-traceparent-id header leaves span_id as None."""
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agentsruntime_/api/execution/guardrails/validate",
+                status_code=200,
+                json={
+                    "result": "PASSED",
+                    "details": "OK",
+                },
+            )
+
+            pii_guardrail = BuiltInValidatorGuardrail(
+                id="test-id",
+                name="PII guardrail",
+                description="Test",
+                enabled_for_evals=True,
+                selector=GuardrailSelector(
+                    scopes=[GuardrailScope.TOOL], match_names=["tool1"]
+                ),
+                guardrail_type="builtInValidator",
+                validator_type="pii_detection",
+                validator_parameters=[],
+            )
+
+            result = service.evaluate_guardrail("test input", pii_guardrail)
+
+            assert result.result == GuardrailValidationResultType.PASSED
+            assert result.span_id is None
+
+    class TestExtractSpanIdFromTraceparent:
+        """Tests for _extract_span_id_from_traceparent."""
+
+        def test_valid_traceparent_16_char_span_id(self) -> None:
+            result = GuardrailsService._extract_span_id_from_traceparent(
+                "00-abcdef1234567890abcdef1234567890-1234567890abcdef"
+            )
+            assert result == "00000000-0000-0000-1234-567890abcdef"
+
+        def test_valid_traceparent_32_char_span_id(self) -> None:
+            result = GuardrailsService._extract_span_id_from_traceparent(
+                "00-abcdef1234567890abcdef1234567890-0a1b2c3d4e5f67890a1b2c3d4e5f6789"
+            )
+            assert result == "0a1b2c3d-4e5f-6789-0a1b-2c3d4e5f6789"
+
+        def test_none_input(self) -> None:
+            assert GuardrailsService._extract_span_id_from_traceparent(None) is None
+
+        def test_empty_string(self) -> None:
+            assert GuardrailsService._extract_span_id_from_traceparent("") is None
+
+        def test_valid_traceparent_4_part_with_trace_flags(self) -> None:
+            result = GuardrailsService._extract_span_id_from_traceparent(
+                "00-abcdef1234567890abcdef1234567890-1234567890abcdef-01"
+            )
+            assert result == "00000000-0000-0000-1234-567890abcdef"
+
+        def test_uppercase_hex_normalized_to_lowercase(self) -> None:
+            result = GuardrailsService._extract_span_id_from_traceparent(
+                "00-ABCDEF1234567890ABCDEF1234567890-1234567890ABCDEF"
+            )
+            assert result == "00000000-0000-0000-1234-567890abcdef"
+
+        def test_invalid_span_id_length_rejected(self) -> None:
+            """Span IDs that are neither 16 nor 32 hex chars are rejected."""
+            assert (
+                GuardrailsService._extract_span_id_from_traceparent(
+                    "00-abcdef1234567890abcdef1234567890-1234abcd"
+                )
+                is None
+            )
+
+        def test_invalid_format(self) -> None:
+            assert (
+                GuardrailsService._extract_span_id_from_traceparent("not-valid") is None
+            )
diff --git a/packages/uipath-platform/tests/services/test_hitl.py b/packages/uipath-platform/tests/services/test_hitl.py
new file mode 100644
index 000000000..7395908a9
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_hitl.py
@@ -0,0 +1,2119 @@
+import json
+import uuid
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from pytest_httpx import HTTPXMock
+from uipath.core.errors import ErrorCategory, UiPathFaultedTriggerError
+from uipath.core.triggers import (
+    UiPathApiTrigger,
+    UiPathIntegrationTrigger,
+    UiPathResumeTrigger,
+    UiPathResumeTriggerName,
+    UiPathResumeTriggerType,
+)
+
+from uipath.platform.action_center import Task
+from uipath.platform.action_center.tasks import TaskStatus
+from uipath.platform.common import (
+    CreateBatchTransform,
+    CreateDeepRag,
+    CreateDeepRagRaw,
+    CreateEphemeralIndex,
+    CreateEphemeralIndexRaw,
+    CreateTask,
+    DocumentExtraction,
+    DocumentExtractionValidation,
+    InvokeProcess,
+    InvokeProcessRaw,
+    InvokeSystemAgent,
+    WaitBatchTransform,
+    WaitDeepRag,
+    WaitDeepRagRaw,
+    WaitDocumentExtractionValidation,
+    WaitEphemeralIndex,
+    WaitEphemeralIndexRaw,
+    WaitIntegrationEvent,
+    WaitJob,
+    WaitJobRaw,
+    WaitSystemAgent,
+    WaitTask,
+)
+from uipath.platform.connections import Connection
+from uipath.platform.context_grounding import (
+    BatchTransformCreationResponse,
+    BatchTransformOutputColumn,
+    Citation,
+    CitationMode,
+    DeepRagCreationResponse,
+    DeepRagStatus,
+    EphemeralIndexUsage,
+    IndexStatus,
+)
+from uipath.platform.context_grounding.context_grounding_index import (
+    ContextGroundingIndex,
+)
+from uipath.platform.documents import (
+    ExtractionResponseIXP,
+    ExtractionResult,
+    FieldGroupValueProjection,
+    FieldType,
+    FieldValueProjection,
+    ProjectType,
+    StartExtractionValidationResponse,
+    ValidateExtractionAction,
+)
+from uipath.platform.orchestrator import Job, JobErrorInfo
+from uipath.platform.orchestrator.job import JobState
+from uipath.platform.resume_triggers import (
+    PropertyName,
+    TriggerMarker,
+    UiPathResumeTriggerCreator,
+    UiPathResumeTriggerReader,
+)
+
+
+@pytest.fixture
+def base_url(mock_env_vars: dict[str, str]) -> str:
+    return mock_env_vars["UIPATH_URL"]
+
+
+@pytest.fixture
+def setup_test_env(
+    monkeypatch: pytest.MonkeyPatch, mock_env_vars: dict[str, str]
+) -> None:
+    """Setup test environment variables."""
+    for key, value in mock_env_vars.items():
+        monkeypatch.setenv(key, value)
+
+
+class TestHitlReader:
+    """Tests for the HitlReader class."""
+
+    @pytest.mark.anyio
+    async def test_read_task_trigger(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an action trigger."""
+        action_key = "test-action-key"
+        action_data = {"answer": "test-action-data"}
+
+        mock_action = Task(key=action_key, data=action_data)
+        mock_retrieve_async = AsyncMock(return_value=mock_action)
+
+        with patch(
+            "uipath.platform.action_center._tasks_service.TasksService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.TASK,
+                item_key=action_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == action_data
+            mock_retrieve_async.assert_called_once_with(
+                action_key,
+                app_folder_key="test-folder",
+                app_folder_path="test-path",
+                app_name=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_task_trigger_empty_response(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an action trigger."""
+        action_key = "test-action-key"
+        action_data: dict[str, Any] = {}
+
+        mock_task = Task(key=action_key, data=action_data, status=2)
+        mock_retrieve_async = AsyncMock(return_value=mock_task)
+
+        with patch(
+            "uipath.platform.action_center._tasks_service.TasksService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.TASK,
+                item_key=action_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == {
+                "status": TaskStatus(2).name.lower(),
+                PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+            }
+            mock_retrieve_async.assert_called_once_with(
+                action_key,
+                app_folder_key="test-folder",
+                app_folder_path="test-path",
+                app_name=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_task_trigger_deleted_raises_faulted_error(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test that deleted task raises UiPathFaultedTriggerError for TASK trigger."""
+        task_key = "test-task-key"
+
+        mock_task = Task(
+            key=task_key,
+            title="test_task",
+            data={},
+            status=TaskStatus.PENDING.value,
+            is_deleted=True,
+            organization_unit_id=12345,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_task)
+
+        with patch(
+            "uipath.platform.action_center._tasks_service.TasksService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.TASK,
+                trigger_name=UiPathResumeTriggerName.TASK,
+                item_key=task_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+
+            with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+                await reader.read_trigger(resume_trigger)
+
+            assert "was deleted" in str(exc_info.value)
+            assert exc_info.value.category == ErrorCategory.USER
+
+    @pytest.mark.anyio
+    async def test_read_task_trigger_deleted_returns_task_for_escalation(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test that deleted task returns task object for ESCALATION trigger."""
+        task_key = "test-task-key"
+
+        mock_task = Task(
+            key=task_key,
+            title="test_task",
+            data={},
+            status=TaskStatus.PENDING.value,
+            is_deleted=True,
+            organization_unit_id=12345,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_task)
+
+        with patch(
+            "uipath.platform.action_center._tasks_service.TasksService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.TASK,
+                trigger_name=UiPathResumeTriggerName.ESCALATION,
+                item_key=task_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+
+            assert result is mock_task
+            assert result.is_deleted is True
+
+    @pytest.mark.anyio
+    async def test_read_job_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful job trigger."""
+        job_key = "test-job-key"
+        job_id = 1234
+        output_args = str({"result": "success"})
+
+        mock_job = Job(
+            id=job_id,
+            key=job_key,
+            state=JobState.SUCCESSFUL.value,
+            output_arguments=output_args,
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == output_args
+            mock_retrieve_async.assert_called_once_with(
+                job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                process_name=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_job_trigger_successful_empty_output(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful job trigger with empty output returns job state."""
+        job_key = "test-job-key"
+        job_id = 1234
+        job_state = JobState.SUCCESSFUL.value
+
+        mock_job = Job(
+            id=job_id,
+            key=job_key,
+            state=job_state,
+            output_arguments="{}",
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == {
+                "state": job_state.lower(),
+                PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+            }
+            mock_retrieve_async.assert_called_once_with(
+                job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                process_name=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_job_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed job trigger."""
+        job_key = "test-job-key"
+        job_error_info = JobErrorInfo(code="error code")
+        job_id = 1234
+
+        mock_job = Job(
+            id=job_id,
+            key=job_key,
+            state="Faulted",
+            job_error=job_error_info,
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={"name": "process_name"},
+            )
+
+            with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+            assert exc_info.value.category == ErrorCategory.USER
+            mock_retrieve_async.assert_called_once_with(
+                job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                process_name="process_name",
+            )
+
+    @pytest.mark.anyio
+    async def test_read_job_raw_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending job raw trigger still raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        job_key = "test-job-key"
+        mock_job = Job(
+            id=1234,
+            key=job_key,
+            state=JobState.RUNNING.value,
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                trigger_name=UiPathResumeTriggerName.JOB_RAW,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_job_raw_trigger_faulted(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a faulted job raw trigger returns the raw job without raising."""
+        job_key = "test-job-key"
+        job_error_info = JobErrorInfo(code="error code")
+        mock_job = Job(
+            id=1234,
+            key=job_key,
+            state="Faulted",
+            job_error=job_error_info,
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                trigger_name=UiPathResumeTriggerName.JOB_RAW,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == mock_job
+
+    @pytest.mark.anyio
+    async def test_read_system_agent_job_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful system agent job trigger."""
+        job_key = "test-system-agent-job-key"
+        job_id = 1234
+        output_args = str({"result": "agent completed successfully"})
+
+        mock_job = Job(
+            id=job_id,
+            key=job_key,
+            state=JobState.SUCCESSFUL.value,
+            output_arguments=output_args,
+            folder_key="d0e09040-5997-44e1-93b7-4087689521b7",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._jobs_service.JobsService.retrieve_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.JOB,
+                item_key=job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={
+                    "agent_name": "template-filler-agent",
+                    "entrypoint": "main",
+                },
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == output_args
+            mock_retrieve_async.assert_called_once_with(
+                job_key,
+                folder_key="test-folder",
+                folder_path="test-path",
+                process_name=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_api_trigger(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an API trigger."""
+        inbox_id = str(uuid.uuid4())
+        payload_data = {"key": "value"}
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
+            status_code=200,
+            json={"payload": payload_data},
+        )
+
+        resume_trigger = UiPathResumeTrigger(
+            trigger_type=UiPathResumeTriggerType.API,
+            api_resume=UiPathApiTrigger(inbox_id=inbox_id, request="test"),
+        )
+
+        reader = UiPathResumeTriggerReader()
+        result = await reader.read_trigger(resume_trigger)
+        assert result == payload_data
+
+    @pytest.mark.anyio
+    async def test_read_api_trigger_failure(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an API trigger with a failed response."""
+        inbox_id = str(uuid.uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
+            status_code=500,
+        )
+
+        resume_trigger = UiPathResumeTrigger(
+            trigger_type=UiPathResumeTriggerType.API,
+            api_resume=UiPathApiTrigger(inbox_id=inbox_id, request="test"),
+        )
+
+        with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+            reader = UiPathResumeTriggerReader()
+            await reader.read_trigger(resume_trigger)
+        assert exc_info.value.category == ErrorCategory.SYSTEM
+
+    @pytest.mark.anyio
+    async def test_read_inbox_trigger(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an Inbox trigger fetches the IS metadata via GetPayload
+        and then enriches it via /elements_/v1/events/{processedEventId}.
+        """
+        inbox_id = str(uuid.uuid4())
+        processed_event_id = "v2::pp::1777041494382::334071::e374ecd5d0f73c21"
+        inbox_metadata = {
+            "UiPathEventConnector": "uipath-slack",
+            "UiPathEvent": "NEW_MESSAGE",
+            "UiPathEventObjectType": "Message",
+            "UiPathEventObjectId": "C123:1777041494.382",
+            "UiPathAdditionalEventData": json.dumps(
+                {"processedEventId": processed_event_id}
+            ),
+        }
+        enriched_event = {
+            "channel": "alerts",
+            "user": "U456",
+            "text": "hello from slack",
+            "ts": "1777041494.382",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
+            status_code=200,
+            json=inbox_metadata,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}/elements_/v1/events/{processed_event_id}",
+            status_code=200,
+            json=enriched_event,
+        )
+
+        resume_trigger = UiPathResumeTrigger(
+            trigger_type=UiPathResumeTriggerType.INBOX,
+            integration_resume=UiPathIntegrationTrigger(
+                connector="slack",
+                connection_id=str(uuid.uuid4()),
+                operation="OnMessage",
+                object_name="Message",
+                inbox_id=inbox_id,
+            ),
+        )
+
+        reader = UiPathResumeTriggerReader()
+        result = await reader.read_trigger(resume_trigger)
+        assert result == enriched_event
+
+    @pytest.mark.anyio
+    async def test_read_inbox_trigger_failure(
+        self,
+        httpx_mock: HTTPXMock,
+        base_url: str,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an Inbox trigger with a failed payload response."""
+        inbox_id = str(uuid.uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
+            status_code=500,
+        )
+
+        resume_trigger = UiPathResumeTrigger(
+            trigger_type=UiPathResumeTriggerType.INBOX,
+            integration_resume=UiPathIntegrationTrigger(
+                connector="slack",
+                connection_id=str(uuid.uuid4()),
+                operation="OnMessage",
+                object_name="Message",
+                inbox_id=inbox_id,
+            ),
+        )
+
+        with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+            reader = UiPathResumeTriggerReader()
+            await reader.read_trigger(resume_trigger)
+        assert exc_info.value.category == ErrorCategory.SYSTEM
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful deep rag trigger."""
+        from uipath.platform.context_grounding import DeepRagResponse
+        from uipath.platform.context_grounding.context_grounding import DeepRagContent
+
+        task_id = "test-deep-rag-id"
+        content = DeepRagContent(
+            text="test content",
+            citations=[
+                Citation(
+                    ordinal=1, page_number=1, source="source", reference="reference"
+                )
+            ],
+        )
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.SUCCESSFUL,
+            content=content,
+            failure_reason=None,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={"index_name": "test-index"},
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            expected_content = content.model_dump()
+            expected_content["deepRagId"] = task_id
+            assert result == expected_content
+            mock_retrieve_async.assert_called_once_with(
+                task_id,
+                index_name="test-index",
+            )
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending deep rag trigger raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        from uipath.platform.context_grounding import DeepRagResponse
+
+        task_id = "test-deep-rag-id"
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.QUEUED,
+            content=None,
+            failure_reason=None,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed deep rag trigger raises faulted error."""
+        from uipath.platform.context_grounding import DeepRagResponse
+
+        task_id = "test-deep-rag-id"
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.FAILED,
+            content=None,
+            failure_reason="An error ocurred during the deepRAG processing",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+
+            with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+            assert exc_info.value.category == ErrorCategory.USER
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_trigger_empty_response(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a deep rag trigger with empty content returns placeholder."""
+        from uipath.platform.context_grounding import DeepRagResponse
+
+        task_id = "test-deep-rag-id"
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.SUCCESSFUL,
+            content=None,
+            failure_reason=None,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == {
+                "status": DeepRagStatus.SUCCESSFUL.value,
+                PropertyName.INTERNAL.value: TriggerMarker.NO_CONTENT.value,
+            }
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_raw_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending deep rag raw trigger still raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        from uipath.platform.context_grounding import DeepRagResponse
+
+        task_id = "test-deep-rag-id"
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.QUEUED,
+            content=None,
+            failure_reason=None,
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                trigger_name=UiPathResumeTriggerName.DEEP_RAG_RAW,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_deep_rag_raw_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed deep rag raw trigger returns the raw response without raising."""
+        from uipath.platform.context_grounding import DeepRagResponse
+
+        task_id = "test-deep-rag-id"
+        mock_deep_rag = DeepRagResponse(
+            id=task_id,
+            name="test-deep-rag",
+            created_date="2024-01-01",
+            last_deep_rag_status=DeepRagStatus.FAILED,
+            content=None,
+            failure_reason="An error occurred during the deepRAG processing",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_deep_rag_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.DEEP_RAG,
+                trigger_name=UiPathResumeTriggerName.DEEP_RAG_RAW,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == mock_deep_rag
+
+    @pytest.mark.anyio
+    async def test_read_batch_rag_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful batch rag trigger."""
+        import os
+
+        task_id = "test-batch-rag-id"
+        destination_path = "test/output.xlsx"
+        mock_download_async = AsyncMock(return_value=None)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.download_batch_transform_result_async",
+            new=mock_download_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.BATCH_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={
+                    "index_name": "test-index",
+                    "destination_path": destination_path,
+                },
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert (
+                result
+                == f"Batch transform completed. Modified file available at {os.path.abspath(destination_path)}"
+            )
+            mock_download_async.assert_called_once_with(
+                task_id,
+                destination_path,
+                validate_status=True,
+                index_name="test-index",
+            )
+
+    @pytest.mark.anyio
+    async def test_read_batch_rag_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending batch rag trigger raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        from uipath.platform.errors import BatchTransformNotCompleteException
+
+        task_id = "test-batch-rag-id"
+        destination_path = "test/output.xlsx"
+        mock_download_async = AsyncMock(
+            side_effect=BatchTransformNotCompleteException(task_id, "InProgress")
+        )
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.download_batch_transform_result_async",
+            new=mock_download_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.BATCH_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={
+                    "index_name": "test-index",
+                    "destination_path": destination_path,
+                },
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_batch_rag_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed batch rag trigger raises faulted error."""
+        from uipath.core.errors import UiPathFaultedTriggerError
+
+        from uipath.platform.errors import BatchTransformFailedException
+
+        task_id = "test-batch-rag-id"
+        destination_path = "test/output.xlsx"
+        mock_download_async = AsyncMock(
+            side_effect=BatchTransformFailedException(task_id)
+        )
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.download_batch_transform_result_async",
+            new=mock_download_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.BATCH_RAG,
+                item_key=task_id,
+                folder_key="test-folder",
+                folder_path="test-path",
+                payload={
+                    "index_name": "test-index",
+                    "destination_path": destination_path,
+                },
+            )
+
+            with pytest.raises(UiPathFaultedTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_ephemeral_index_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful ephemeral index trigger."""
+        index_id = "test-ephemeral-index-id"
+        index_data = {
+            "id": index_id,
+            "name": "test-index",
+            "lastIngestionStatus": IndexStatus.SUCCESSFUL.value,
+        }
+
+        mock_retrieve_by_id = AsyncMock(return_value=index_data)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_by_id_async",
+            new=mock_retrieve_by_id,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.INDEX_INGESTION,
+                item_key=index_id,
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+
+            assert isinstance(result, dict)
+            assert result["id"] == index_id
+            mock_retrieve_by_id.assert_called_once_with(index_id)
+
+    @pytest.mark.anyio
+    async def test_read_ephemeral_index_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending ephemeral index trigger raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        index_id = "test-ephemeral-index-id"
+        index_data = {
+            "id": index_id,
+            "name": "test-index",
+            "lastIngestionStatus": IndexStatus.IN_PROGRESS.value,
+        }
+
+        mock_retrieve_by_id = AsyncMock(return_value=index_data)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_by_id_async",
+            new=mock_retrieve_by_id,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.INDEX_INGESTION,
+                item_key=index_id,
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_ephemeral_index_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed ephemeral index trigger raises faulted error."""
+        index_id = "test-ephemeral-index-id"
+        index_data = {
+            "id": index_id,
+            "name": "test-index",
+            "lastIngestionStatus": IndexStatus.FAILED.value,
+        }
+
+        mock_retrieve_by_id = AsyncMock(return_value=index_data)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_by_id_async",
+            new=mock_retrieve_by_id,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.INDEX_INGESTION,
+                item_key=index_id,
+            )
+
+            with pytest.raises(UiPathFaultedTriggerError) as exc_info:
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+            assert exc_info.value.category == ErrorCategory.USER
+
+    @pytest.mark.anyio
+    async def test_read_ephemeral_index_raw_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending ephemeral index raw trigger still raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        index_id = "test-ephemeral-index-id"
+        index_data = {
+            "id": index_id,
+            "name": "test-index",
+            "lastIngestionStatus": IndexStatus.IN_PROGRESS.value,
+        }
+
+        mock_retrieve_by_id = AsyncMock(return_value=index_data)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_by_id_async",
+            new=mock_retrieve_by_id,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.INDEX_INGESTION,
+                trigger_name=UiPathResumeTriggerName.INDEX_INGESTION_RAW,
+                item_key=index_id,
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_ephemeral_index_raw_trigger_failed(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a failed ephemeral index raw trigger returns the raw response without raising."""
+        from uipath.platform.context_grounding.context_grounding_index import (
+            ContextGroundingIndex,
+        )
+
+        index_id = "test-ephemeral-index-id"
+        index_data = {
+            "id": index_id,
+            "name": "test-index",
+            "lastIngestionStatus": IndexStatus.FAILED.value,
+        }
+
+        mock_retrieve_by_id = AsyncMock(return_value=index_data)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.retrieve_by_id_async",
+            new=mock_retrieve_by_id,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.INDEX_INGESTION,
+                trigger_name=UiPathResumeTriggerName.INDEX_INGESTION_RAW,
+                item_key=index_id,
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert isinstance(result, ContextGroundingIndex)
+            assert result.last_ingestion_status == IndexStatus.FAILED
+
+    @pytest.mark.anyio
+    async def test_read_ixp_vs_escalation_trigger_successful(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a successful IXP VS escalation trigger."""
+        operation_id = "test-escalation-id"
+        project_id = "test-project-id"
+        tag = "test-tag"
+        action_data = {
+            "status": TaskStatus.COMPLETED.name.lower(),
+            "data": {"field": "value"},
+        }
+
+        mock_escalation = ValidateExtractionAction(
+            action_data=action_data,
+            action_status=TaskStatus.COMPLETED.name,
+            project_id=project_id,
+            project_type=ProjectType.IXP,
+            extractor_id=None,
+            tag=tag,
+            operation_id=operation_id,
+            document_type_id="test-doc-type",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_escalation)
+
+        with patch(
+            "uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_validation_result_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.IXP_VS_ESCALATION,
+                item_key=operation_id,
+                payload={"project_id": project_id, "tag": tag},
+            )
+            reader = UiPathResumeTriggerReader()
+            result = await reader.read_trigger(resume_trigger)
+            assert result == mock_escalation.model_dump()
+            mock_retrieve_async.assert_called_once_with(
+                project_id,
+                tag,
+                operation_id,
+            )
+
+    @pytest.mark.anyio
+    async def test_read_ixp_vs_escalation_trigger_pending(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading a pending IXP VS escalation trigger raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        operation_id = "test-escalation-id"
+        project_id = "test-project-id"
+        tag = "test-tag"
+        action_data = {
+            "status": TaskStatus.PENDING.name.lower(),
+            "data": {"field": "value"},
+        }
+
+        mock_escalation = ValidateExtractionAction(
+            action_data=action_data,
+            action_status=TaskStatus.PENDING.name,
+            project_id=project_id,
+            project_type=ProjectType.IXP,
+            extractor_id=None,
+            tag=tag,
+            operation_id=operation_id,
+            document_type_id="test-doc-type",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_escalation)
+
+        with patch(
+            "uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_validation_result_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.IXP_VS_ESCALATION,
+                item_key=operation_id,
+                payload={"project_id": project_id, "tag": tag},
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+    @pytest.mark.anyio
+    async def test_read_ixp_vs_escalation_trigger_unassigned(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test reading an unassigned IXP VS escalation trigger raises pending error."""
+        from uipath.core.errors import UiPathPendingTriggerError
+
+        operation_id = "test-escalation-id"
+        project_id = "test-project-id"
+        tag = "test-tag"
+        action_data = {
+            "status": TaskStatus.UNASSIGNED.name.lower(),
+            "data": {"field": "value"},
+        }
+
+        mock_escalation = ValidateExtractionAction(
+            action_data=action_data,
+            action_status=TaskStatus.UNASSIGNED.name,
+            project_id=project_id,
+            project_type=ProjectType.IXP,
+            extractor_id=None,
+            tag=tag,
+            operation_id=operation_id,
+            document_type_id="test-doc-type",
+        )
+        mock_retrieve_async = AsyncMock(return_value=mock_escalation)
+
+        with patch(
+            "uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_validation_result_async",
+            new=mock_retrieve_async,
+        ):
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=UiPathResumeTriggerType.IXP_VS_ESCALATION,
+                item_key=operation_id,
+                payload={"project_id": project_id, "tag": tag},
+            )
+
+            with pytest.raises(UiPathPendingTriggerError):
+                reader = UiPathResumeTriggerReader()
+                await reader.read_trigger(resume_trigger)
+
+
+class TestHitlProcessor:
+    """Tests for the HitlProcessor class."""
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_task(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateTask."""
+        action_key = "test-action-key"
+        create_action = CreateTask(
+            title="Test Action",
+            app_name="TestApp",
+            app_folder_path="/test/path",
+            data={"input": "test-input"},
+        )
+
+        mock_action = Task(key=action_key)
+        mock_create_async = AsyncMock(return_value=mock_action)
+
+        with patch(
+            "uipath.platform.action_center._tasks_service.TasksService.create_async",
+            new=mock_create_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_action)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.TASK
+            assert resume_trigger.item_key == action_key
+            assert resume_trigger.folder_path == create_action.app_folder_path
+            mock_create_async.assert_called_once_with(
+                title=create_action.title,
+                app_name=create_action.app_name,
+                app_folder_path=create_action.app_folder_path,
+                app_folder_key=None,
+                app_key="",
+                assignee="",
+                recipient="",
+                data=create_action.data,
+                priority=None,
+                labels=None,
+                is_actionable_message_enabled=None,
+                actionable_message_metadata=None,
+                source_name="Agent",
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_task(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitTask."""
+        action_key = "test-action-key"
+        action = Task(key=action_key)
+        wait_action = WaitTask(action=action, app_folder_path="/test/path")
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_action)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.TASK
+        assert resume_trigger.item_key == action_key
+        assert resume_trigger.folder_path == wait_action.app_folder_path
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_invoke_process(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for InvokeProcess."""
+        job_key = "test-job-key"
+        invoke_process = InvokeProcess(
+            name="TestProcess",
+            process_folder_path="/test/path",
+            input_arguments={"key": "value"},
+        )
+
+        mock_job = Job(
+            id=1234, key=job_key, folder_key="d0e09040-5997-44e1-93b7-4087689521b7"
+        )
+        mock_invoke = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._processes_service.ProcessesService.invoke_async",
+            new=mock_invoke,
+        ) as mock_process_invoke_async:
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(invoke_process)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+            assert resume_trigger.item_key == job_key
+            assert resume_trigger.folder_path == invoke_process.process_folder_path
+            mock_process_invoke_async.assert_called_once_with(
+                name=invoke_process.name,
+                input_arguments=invoke_process.input_arguments,
+                attachments=None,
+                folder_path=invoke_process.process_folder_path,
+                folder_key=None,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_job(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitJob."""
+        job_key = "test-job-key"
+        job = Job(
+            id=1234, key=job_key, folder_key="d0e09040-5997-44e1-93b7-4087689521b7"
+        )
+        wait_job = WaitJob(job=job, process_folder_path="/test/path")
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_job)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+        assert resume_trigger.item_key == job_key
+        assert resume_trigger.folder_path == wait_job.process_folder_path
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_invoke_process_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for InvokeProcessRaw sets the raw trigger name."""
+        job_key = "test-job-key"
+        invoke_process_raw = InvokeProcessRaw(
+            name="TestProcess",
+            process_folder_path="/test/path",
+            input_arguments={"key": "value"},
+        )
+
+        mock_job = Job(
+            id=1234, key=job_key, folder_key="d0e09040-5997-44e1-93b7-4087689521b7"
+        )
+        mock_invoke = AsyncMock(return_value=mock_job)
+
+        with patch(
+            "uipath.platform.orchestrator._processes_service.ProcessesService.invoke_async",
+            new=mock_invoke,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(invoke_process_raw)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+            assert resume_trigger.trigger_name == UiPathResumeTriggerName.JOB_RAW
+            assert resume_trigger.item_key == job_key
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_job_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitJobRaw sets the raw trigger name."""
+        job_key = "test-job-key"
+        job = Job(
+            id=1234, key=job_key, folder_key="d0e09040-5997-44e1-93b7-4087689521b7"
+        )
+        wait_job_raw = WaitJobRaw(job=job, process_folder_path="/test/path")
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_job_raw)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+        assert resume_trigger.trigger_name == UiPathResumeTriggerName.JOB_RAW
+        assert resume_trigger.item_key == job_key
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_invoke_system_agent(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for InvokeSystemAgent."""
+        job_key = "test-system-agent-job-key"
+        invoke_system_agent = InvokeSystemAgent(
+            agent_name="template-filler-agent",
+            entrypoint="main",
+            folder_path="/test/path",
+            folder_key="test-folder-key",
+            input_arguments={"metadata_id": "123", "template_id": "456"},
+        )
+
+        mock_invoke_system_agent = AsyncMock(return_value=job_key)
+
+        with patch(
+            "uipath.platform.agenthub._agenthub_service.AgentHubService.invoke_system_agent_async",
+            new=mock_invoke_system_agent,
+        ) as mock_agent_invoke:
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(invoke_system_agent)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+            assert resume_trigger.item_key == job_key
+            assert resume_trigger.folder_path == invoke_system_agent.folder_path
+            assert resume_trigger.folder_key == invoke_system_agent.folder_key
+            mock_agent_invoke.assert_called_once_with(
+                agent_name=invoke_system_agent.agent_name,
+                entrypoint=invoke_system_agent.entrypoint,
+                input_arguments=invoke_system_agent.input_arguments,
+                folder_path=invoke_system_agent.folder_path,
+                folder_key=invoke_system_agent.folder_key,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_system_agent(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitSystemAgent."""
+        job_key = "1234"
+        wait_system_agent = WaitSystemAgent(
+            job_key="1234",
+            process_folder_path="/test/path",
+            process_folder_key="test-folder-key",
+        )
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_system_agent)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
+        assert resume_trigger.item_key == job_key
+        assert resume_trigger.folder_path == wait_system_agent.process_folder_path
+        assert resume_trigger.folder_key == wait_system_agent.process_folder_key
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_api(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for API type."""
+        api_input = "payload"
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(api_input)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.API
+        assert resume_trigger.api_resume is not None
+        assert isinstance(resume_trigger.api_resume.inbox_id, str)
+        assert resume_trigger.api_resume.request == api_input
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_integration_event(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitIntegrationEvent."""
+        connection_id = str(uuid.uuid4())
+        mock_connection = Connection(
+            id=connection_id, name="Slack-Alerts", element_instance_id=1
+        )
+        mock_list_async = AsyncMock(return_value=[mock_connection])
+
+        wait_event = WaitIntegrationEvent(
+            connector="slack",
+            connection_name="Slack-Alerts",
+            connection_folder_path="Shared",
+            operation="OnMessage",
+            object_name="Message",
+            filter_expression="channel == 'alerts'",
+            parameters={"channel_id": "C123"},
+        )
+
+        with patch(
+            "uipath.platform.connections._connections_service.ConnectionsService.list_async",
+            new=mock_list_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(wait_event)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.INBOX
+        assert resume_trigger.trigger_name == UiPathResumeTriggerName.INBOX
+        assert resume_trigger.api_resume is None
+        assert resume_trigger.integration_resume is not None
+        assert resume_trigger.integration_resume.connector == "slack"
+        assert resume_trigger.integration_resume.connection_id == connection_id
+        assert resume_trigger.integration_resume.operation == "OnMessage"
+        assert resume_trigger.integration_resume.object_name == "Message"
+        assert (
+            resume_trigger.integration_resume.filter_expression == "channel == 'alerts'"
+        )
+        assert resume_trigger.integration_resume.parameters == {"channel_id": "C123"}
+        assert isinstance(resume_trigger.integration_resume.inbox_id, str)
+        uuid.UUID(resume_trigger.integration_resume.inbox_id)
+        mock_list_async.assert_called_once_with(
+            name="Slack-Alerts", folder_path="Shared", connector_key="slack"
+        )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_integration_event_optional_fields_omitted(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test that filter_expression, parameters, and folder_path are optional."""
+        mock_connection = Connection(
+            id=str(uuid.uuid4()), name="Teams-Default", element_instance_id=2
+        )
+        mock_list_async = AsyncMock(return_value=[mock_connection])
+
+        wait_event = WaitIntegrationEvent(
+            connector="teams",
+            connection_name="Teams-Default",
+            operation="OnReply",
+            object_name="Reply",
+        )
+
+        with patch(
+            "uipath.platform.connections._connections_service.ConnectionsService.list_async",
+            new=mock_list_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(wait_event)
+
+        assert resume_trigger.integration_resume is not None
+        assert resume_trigger.integration_resume.filter_expression is None
+        assert resume_trigger.integration_resume.parameters is None
+        mock_list_async.assert_called_once_with(
+            name="Teams-Default", folder_path=None, connector_key="teams"
+        )
+
+    @pytest.mark.anyio
+    async def test_wait_integration_event_serializes_with_camelcase_aliases(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Wire shape: UiPathResumeTrigger.integration_resume must serialize
+        with the field names Orchestrator's ResumeTriggerDto/IntegrationResumeDto
+        expect (PascalCase-ish camelCase).
+        """
+        connection_id = str(uuid.uuid4())
+        mock_connection = Connection(
+            id=connection_id, name="Slack-Alerts", element_instance_id=3
+        )
+        mock_list_async = AsyncMock(return_value=[mock_connection])
+
+        wait_event = WaitIntegrationEvent(
+            connector="slack",
+            connection_name="Slack-Alerts",
+            operation="OnMessage",
+            object_name="Message",
+        )
+
+        with patch(
+            "uipath.platform.connections._connections_service.ConnectionsService.list_async",
+            new=mock_list_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(wait_event)
+
+        dumped = resume_trigger.model_dump(by_alias=True, exclude_none=True)
+
+        assert dumped["triggerType"] == UiPathResumeTriggerType.INBOX
+        assert "integrationResume" in dumped
+        integration = dumped["integrationResume"]
+        assert integration["connector"] == "slack"
+        assert integration["connectionId"] == connection_id
+        assert integration["operation"] == "OnMessage"
+        assert integration["objectName"] == "Message"
+        assert "inboxId" in integration
+        uuid.UUID(integration["inboxId"])
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_integration_event_no_match(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Listing returns no exact-name match -> creator raises."""
+        mock_list_async = AsyncMock(return_value=[])
+
+        wait_event = WaitIntegrationEvent(
+            connector="slack",
+            connection_name="Missing-Connection",
+            operation="OnMessage",
+            object_name="Message",
+        )
+
+        with patch(
+            "uipath.platform.connections._connections_service.ConnectionsService.list_async",
+            new=mock_list_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            with pytest.raises(UiPathFaultedTriggerError):
+                await processor.create_trigger(wait_event)
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_integration_event_filters_to_exact_match(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """list_async partial-matches; creator must pick the exact-name entry."""
+        target_id = str(uuid.uuid4())
+        # list_async partial-matches; simulate prefix-matching returning extras
+        mock_list_async = AsyncMock(
+            return_value=[
+                Connection(
+                    id=str(uuid.uuid4()),
+                    name="Slack-Alerts-Old",
+                    element_instance_id=4,
+                ),
+                Connection(id=target_id, name="Slack-Alerts", element_instance_id=5),
+            ]
+        )
+
+        wait_event = WaitIntegrationEvent(
+            connector="slack",
+            connection_name="Slack-Alerts",
+            operation="OnMessage",
+            object_name="Message",
+        )
+
+        with patch(
+            "uipath.platform.connections._connections_service.ConnectionsService.list_async",
+            new=mock_list_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(wait_event)
+
+        assert resume_trigger.integration_resume is not None
+        assert resume_trigger.integration_resume.connection_id == target_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_deep_rag(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateDeepRag."""
+        deep_rag_id = "test-deep-rag-id"
+        create_deep_rag = CreateDeepRag(
+            name="test-deep-rag",
+            index_name="test-index",
+            prompt="test prompt",
+            glob_pattern="**/*.pdf",
+            citation_mode=CitationMode.INLINE,
+            index_folder_path="/test/path",
+        )
+
+        mock_deep_rag = DeepRagCreationResponse(
+            id=deep_rag_id,
+            last_deep_rag_status=DeepRagStatus.QUEUED,
+            created_date="2024-01-01",
+        )
+        mock_start_deep_rag_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.start_deep_rag_async",
+            new=mock_start_deep_rag_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_deep_rag)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.DEEP_RAG
+            assert resume_trigger.item_key == deep_rag_id
+            mock_start_deep_rag_async.assert_called_once_with(
+                name=create_deep_rag.name,
+                index_name=create_deep_rag.index_name,
+                index_id=None,
+                prompt=create_deep_rag.prompt,
+                glob_pattern=create_deep_rag.glob_pattern,
+                citation_mode=create_deep_rag.citation_mode,
+                folder_path=create_deep_rag.index_folder_path,
+                folder_key=create_deep_rag.index_folder_key,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_deep_rag(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitDeepRag."""
+        deep_rag_id = "test-deep-rag-id"
+        deep_rag = DeepRagCreationResponse(
+            id=deep_rag_id,
+            last_deep_rag_status=DeepRagStatus.IN_PROGRESS,
+            created_date="2024-01-01",
+        )
+        wait_deep_rag = WaitDeepRag(deep_rag=deep_rag, index_folder_path="/test/path")
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_deep_rag)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.DEEP_RAG
+        assert resume_trigger.item_key == deep_rag_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_deep_rag_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateDeepRagRaw sets the raw trigger name."""
+        deep_rag_id = "test-deep-rag-id"
+        create_deep_rag_raw = CreateDeepRagRaw(
+            name="test-deep-rag",
+            index_name="test-index",
+            prompt="test prompt",
+            glob_pattern="**/*.pdf",
+            citation_mode=CitationMode.INLINE,
+            index_folder_path="/test/path",
+        )
+
+        mock_deep_rag = DeepRagCreationResponse(
+            id=deep_rag_id,
+            last_deep_rag_status=DeepRagStatus.QUEUED,
+            created_date="2024-01-01",
+        )
+        mock_start_deep_rag_async = AsyncMock(return_value=mock_deep_rag)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.start_deep_rag_async",
+            new=mock_start_deep_rag_async,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_deep_rag_raw)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.DEEP_RAG
+            assert resume_trigger.trigger_name == UiPathResumeTriggerName.DEEP_RAG_RAW
+            assert resume_trigger.item_key == deep_rag_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_deep_rag_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitDeepRagRaw sets the raw trigger name."""
+        deep_rag_id = "test-deep-rag-id"
+        deep_rag = DeepRagCreationResponse(
+            id=deep_rag_id,
+            last_deep_rag_status=DeepRagStatus.IN_PROGRESS,
+            created_date="2024-01-01",
+        )
+        wait_deep_rag_raw = WaitDeepRagRaw(
+            deep_rag=deep_rag, index_folder_path="/test/path"
+        )
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_deep_rag_raw)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.DEEP_RAG
+        assert resume_trigger.trigger_name == UiPathResumeTriggerName.DEEP_RAG_RAW
+        assert resume_trigger.item_key == deep_rag_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_batch_transform(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateBatchTransform."""
+        batch_transform_id = "test-batch-transform-id"
+        output_columns = [
+            BatchTransformOutputColumn(name="column1", description="desc1"),
+        ]
+        create_batch_transform = CreateBatchTransform(
+            name="test-batch-transform",
+            index_name="test-index",
+            prompt="test prompt",
+            output_columns=output_columns,
+            destination_path="/output/path.xlsx",
+            index_folder_path="/test/path",
+        )
+
+        mock_batch_transform = BatchTransformCreationResponse(
+            id=batch_transform_id,
+            last_batch_rag_status=DeepRagStatus.QUEUED,
+        )
+        mock_start_batch_transform = AsyncMock(return_value=mock_batch_transform)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.start_batch_transform_async",
+            new=mock_start_batch_transform,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_batch_transform)
+
+            assert resume_trigger is not None
+            assert resume_trigger.trigger_type == UiPathResumeTriggerType.BATCH_RAG
+            assert resume_trigger.item_key == batch_transform_id
+            mock_start_batch_transform.assert_called_once_with(
+                name=create_batch_transform.name,
+                index_name=create_batch_transform.index_name,
+                index_id=None,
+                prompt=create_batch_transform.prompt,
+                output_columns=create_batch_transform.output_columns,
+                storage_bucket_folder_path_prefix=create_batch_transform.storage_bucket_folder_path_prefix,
+                enable_web_search_grounding=create_batch_transform.enable_web_search_grounding,
+                folder_path=create_batch_transform.index_folder_path,
+                folder_key=create_batch_transform.index_folder_key,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_batch_transform(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitBatchTransform."""
+        batch_transform_id = "test-batch-transform-id"
+        batch_transform = BatchTransformCreationResponse(
+            id=batch_transform_id,
+            last_batch_rag_status=DeepRagStatus.IN_PROGRESS,
+        )
+        wait_batch_transform = WaitBatchTransform(
+            batch_transform=batch_transform, index_folder_path="/test/path"
+        )
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_batch_transform)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.BATCH_RAG
+        assert resume_trigger.item_key == batch_transform_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_ephemeral_index(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateEphemeralIndex."""
+        index_id = "test-ephemeral-index-id"
+        attachments = ["attachment-uuid-1", "attachment-uuid-2"]
+        create_ephemeral_index = CreateEphemeralIndex(
+            usage=EphemeralIndexUsage.DEEP_RAG,
+            attachments=attachments,
+        )
+
+        mock_index = ContextGroundingIndex(
+            id=index_id,
+            name="ephemeral-index",
+            last_ingestion_status=IndexStatus.QUEUED.value,
+        )
+        mock_create_ephemeral_index = AsyncMock(return_value=mock_index)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.create_ephemeral_index_async",
+            new=mock_create_ephemeral_index,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_ephemeral_index)
+
+            assert resume_trigger is not None
+            assert (
+                resume_trigger.trigger_type == UiPathResumeTriggerType.INDEX_INGESTION
+            )
+            assert resume_trigger.item_key == index_id
+            mock_create_ephemeral_index.assert_called_once_with(
+                usage=create_ephemeral_index.usage,
+                attachments=create_ephemeral_index.attachments,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_ephemeral_index(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitEphemeralIndex."""
+        index_id = "test-ephemeral-index-id"
+        ephemeral_index = ContextGroundingIndex(
+            id=index_id,
+            name="ephemeral-index",
+            last_ingestion_status=IndexStatus.IN_PROGRESS.value,
+        )
+        wait_ephemeral_index = WaitEphemeralIndex(index=ephemeral_index)
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_ephemeral_index)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.INDEX_INGESTION
+        assert resume_trigger.item_key == index_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_create_ephemeral_index_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for CreateEphemeralIndexRaw sets the raw trigger name."""
+        index_id = "test-ephemeral-index-id"
+        attachments = ["attachment-uuid-1", "attachment-uuid-2"]
+        create_ephemeral_index_raw = CreateEphemeralIndexRaw(
+            usage=EphemeralIndexUsage.DEEP_RAG,
+            attachments=attachments,
+        )
+
+        mock_index = ContextGroundingIndex(
+            id=index_id,
+            name="ephemeral-index",
+            last_ingestion_status=IndexStatus.QUEUED.value,
+        )
+        mock_create_ephemeral_index = AsyncMock(return_value=mock_index)
+
+        with patch(
+            "uipath.platform.context_grounding._context_grounding_service.ContextGroundingService.create_ephemeral_index_async",
+            new=mock_create_ephemeral_index,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(create_ephemeral_index_raw)
+
+            assert resume_trigger is not None
+            assert (
+                resume_trigger.trigger_type == UiPathResumeTriggerType.INDEX_INGESTION
+            )
+            assert (
+                resume_trigger.trigger_name
+                == UiPathResumeTriggerName.INDEX_INGESTION_RAW
+            )
+            assert resume_trigger.item_key == index_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_ephemeral_index_raw(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitEphemeralIndexRaw sets the raw trigger name."""
+        index_id = "test-ephemeral-index-id"
+        ephemeral_index = ContextGroundingIndex(
+            id=index_id,
+            name="ephemeral-index",
+            last_ingestion_status=IndexStatus.IN_PROGRESS.value,
+        )
+        wait_ephemeral_index_raw = WaitEphemeralIndexRaw(index=ephemeral_index)
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_ephemeral_index_raw)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.INDEX_INGESTION
+        assert (
+            resume_trigger.trigger_name == UiPathResumeTriggerName.INDEX_INGESTION_RAW
+        )
+        assert resume_trigger.item_key == index_id
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_document_extraction_validation(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for DocumentExtractionValidation."""
+        operation_id = "test-validation-operation-id"
+        project_id = "test-project-id"
+        tag = "test-tag"
+
+        # Create a mock extraction response
+        extraction_result = ExtractionResult(
+            document_id="doc-123",
+            results_version=1,
+            results_document={},
+        )
+        mock_extraction_response = ExtractionResponseIXP(
+            extraction_result=extraction_result,
+            project_id=project_id,
+            project_type=ProjectType.IXP,
+            extractor_id=None,
+            tag=tag,
+            document_type_id="doc-type-123",
+            data_projection=[
+                FieldGroupValueProjection(
+                    field_group_name="test_group",
+                    field_values=[
+                        FieldValueProjection(
+                            id="field-1",
+                            name="test_field",
+                            value="test_value",
+                            unformatted_value="test_value",
+                            confidence=0.95,
+                            ocr_confidence=0.98,
+                            type=FieldType.TEXT,
+                        )
+                    ],
+                )
+            ],
+        )
+
+        document_extraction_validation = DocumentExtractionValidation(
+            extraction_response=mock_extraction_response,
+            action_title="Test Validation",
+        )
+
+        mock_validation_response = StartExtractionValidationResponse(
+            operation_id=operation_id,
+            document_id="doc-123",
+            project_id=project_id,
+            tag=tag,
+        )
+        mock_start_validation = AsyncMock(return_value=mock_validation_response)
+
+        with patch(
+            "uipath.platform.documents._documents_service.DocumentsService.start_ixp_extraction_validation_async",
+            new=mock_start_validation,
+        ):
+            processor = UiPathResumeTriggerCreator()
+            resume_trigger = await processor.create_trigger(
+                document_extraction_validation
+            )
+
+            assert resume_trigger is not None
+            assert (
+                resume_trigger.trigger_type == UiPathResumeTriggerType.IXP_VS_ESCALATION
+            )
+            assert resume_trigger.item_key == operation_id
+            # Verify the payload contains project_id and tag
+            assert isinstance(resume_trigger.payload, dict)
+            assert resume_trigger.payload.get("project_id") == project_id
+            assert resume_trigger.payload.get("tag") == tag
+            mock_start_validation.assert_called_once_with(
+                extraction_response=document_extraction_validation.extraction_response,
+                action_title=document_extraction_validation.action_title,
+                action_priority=document_extraction_validation.action_priority,
+                action_folder=document_extraction_validation.action_folder,
+                storage_bucket_name=document_extraction_validation.storage_bucket_name,
+                storage_bucket_directory_path=document_extraction_validation.storage_bucket_directory_path,
+            )
+
+    @pytest.mark.anyio
+    async def test_create_resume_trigger_wait_document_extraction_validation(
+        self,
+        setup_test_env: None,
+    ) -> None:
+        """Test creating a resume trigger for WaitDocumentExtractionValidation."""
+        operation_id = "test-validation-operation-id"
+        project_id = "test-project-id"
+        tag = "test-tag"
+
+        validation_response = StartExtractionValidationResponse(
+            operation_id=operation_id,
+            document_id="doc-123",
+            project_id=project_id,
+            tag=tag,
+        )
+        wait_validation = WaitDocumentExtractionValidation(
+            extraction_validation=validation_response
+        )
+
+        processor = UiPathResumeTriggerCreator()
+        resume_trigger = await processor.create_trigger(wait_validation)
+
+        assert resume_trigger is not None
+        assert resume_trigger.trigger_type == UiPathResumeTriggerType.IXP_VS_ESCALATION
+        assert resume_trigger.item_key == operation_id
+
+
+class TestDocumentExtractionModels:
+    """Tests for document extraction models."""
+
+    def test_create_document_extraction_with_file(self) -> None:
+        """Test DocumentExtraction with file provided."""
+        file_content = b"test content"
+        extraction = DocumentExtraction(
+            project_name="test_project",
+            tag="test_tag",
+            file=file_content,
+        )
+
+        assert extraction.project_name == "test_project"
+        assert extraction.tag == "test_tag"
+        assert extraction.file == file_content
+        assert extraction.file_path is None
+
+    def test_create_document_extraction_with_file_path(self) -> None:
+        """Test DocumentExtraction with file_path provided."""
+        extraction = DocumentExtraction(
+            project_name="test_project",
+            tag="test_tag",
+            file_path="/path/to/file.pdf",
+        )
+
+        assert extraction.project_name == "test_project"
+        assert extraction.tag == "test_tag"
+        assert extraction.file is None
+        assert extraction.file_path == "/path/to/file.pdf"
+
+    def test_create_document_extraction_with_both_raises_error(self) -> None:
+        """Test DocumentExtraction with both file and file_path raises ValueError."""
+        file_content = b"test content"
+
+        with pytest.raises(ValueError) as exc_info:
+            DocumentExtraction(
+                project_name="test_project",
+                tag="test_tag",
+                file=file_content,
+                file_path="/path/to/file.pdf",
+            )
+
+        assert "not both or neither" in str(exc_info.value)
+
+    def test_create_document_extraction_with_neither_raises_error(self) -> None:
+        """Test DocumentExtraction with neither file nor file_path raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            DocumentExtraction(
+                project_name="test_project",
+                tag="test_tag",
+            )
+
+        assert "not both or neither" in str(exc_info.value)
diff --git a/packages/uipath-platform/tests/services/test_http_config.py b/packages/uipath-platform/tests/services/test_http_config.py
new file mode 100644
index 000000000..628d69a59
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_http_config.py
@@ -0,0 +1,100 @@
+from unittest.mock import PropertyMock, patch
+
+import pytest
+
+from uipath.platform.common._config import ConfigurationManager
+from uipath.platform.common._http_config import get_httpx_client_kwargs
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Ensure licensing-related env vars are clean for every test."""
+    monkeypatch.delenv("UIPATH_DISABLE_SSL_VERIFY", raising=False)
+
+
+class TestGetHttpxClientKwargsHeaders:
+    """Tests for header merging in get_httpx_client_kwargs()."""
+
+    def test_no_licensing_no_caller_headers(self) -> None:
+        """No headers key when neither licensing nor caller headers are provided."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value=None,
+        ):
+            result = get_httpx_client_kwargs()
+        assert "headers" not in result
+
+    def test_licensing_context_only(self) -> None:
+        """Licensing header included when licensing_context is set."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value="test-license-ctx",
+        ):
+            result = get_httpx_client_kwargs()
+        assert result["headers"] == {"x-uipath-licensing-context": "test-license-ctx"}
+
+    def test_caller_headers_only(self) -> None:
+        """Caller headers included when no licensing_context is set."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value=None,
+        ):
+            result = get_httpx_client_kwargs(headers={"Authorization": "Bearer tok"})
+        assert result["headers"] == {"Authorization": "Bearer tok"}
+
+    def test_licensing_and_caller_headers_merged(self) -> None:
+        """Both licensing and caller headers present in result."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value="lic-ctx",
+        ):
+            result = get_httpx_client_kwargs(headers={"Authorization": "Bearer tok"})
+        assert result["headers"] == {
+            "x-uipath-licensing-context": "lic-ctx",
+            "Authorization": "Bearer tok",
+        }
+
+    def test_caller_headers_win_on_conflict(self) -> None:
+        """Caller headers override licensing headers on same key."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value="lic-ctx",
+        ):
+            result = get_httpx_client_kwargs(
+                headers={"x-uipath-licensing-context": "caller-override"}
+            )
+        assert result["headers"] == {"x-uipath-licensing-context": "caller-override"}
+
+    def test_result_always_contains_base_config(self) -> None:
+        """SSL, timeout, and redirect config always present regardless of headers."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value="lic",
+        ):
+            result = get_httpx_client_kwargs(headers={"Authorization": "Bearer x"})
+        assert result["follow_redirects"] is True
+        assert result["timeout"] == 30.0
+        assert "verify" in result
+
+    def test_no_headers_key_when_empty(self) -> None:
+        """Empty caller headers dict with no licensing does not add headers key."""
+        with patch.object(
+            ConfigurationManager,
+            "licensing_context",
+            new_callable=PropertyMock,
+            return_value=None,
+        ):
+            result = get_httpx_client_kwargs(headers={})
+        assert "headers" not in result
diff --git a/packages/uipath-platform/tests/services/test_identity_service.py b/packages/uipath-platform/tests/services/test_identity_service.py
new file mode 100644
index 000000000..2ebbc09c9
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_identity_service.py
@@ -0,0 +1,100 @@
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform.identity import IdentityService
+
+
+class TestIdentityServiceRefreshAccessToken:
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_refresh_success(self, httpx_mock: HTTPXMock, use_async: bool):
+        domain = "https://cloud.uipath.com"
+        httpx_mock.add_response(
+            url=f"{domain}/identity_/connect/token",
+            method="POST",
+            status_code=200,
+            json={
+                "access_token": "new-access-token",
+                "refresh_token": "new-refresh-token",
+                "expires_in": 3600,
+                "token_type": "Bearer",
+            },
+        )
+
+        service = IdentityService(domain)
+        if use_async:
+            token = await service.refresh_access_token_async(
+                refresh_token="old-refresh-token",
+                client_id="my-client-id",
+            )
+        else:
+            token = service.refresh_access_token(
+                refresh_token="old-refresh-token",
+                client_id="my-client-id",
+            )
+
+        assert token.access_token == "new-access-token"
+        assert token.refresh_token == "new-refresh-token"
+        assert token.expires_in == 3600
+        assert token.token_type == "Bearer"
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_refresh_401_raises(self, httpx_mock: HTTPXMock, use_async: bool):
+        domain = "https://cloud.uipath.com"
+        httpx_mock.add_response(
+            url=f"{domain}/identity_/connect/token",
+            method="POST",
+            status_code=401,
+            json={"error": "invalid_grant"},
+        )
+
+        service = IdentityService(domain)
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            if use_async:
+                await service.refresh_access_token_async(
+                    refresh_token="expired-token",
+                    client_id="my-client-id",
+                )
+            else:
+                service.refresh_access_token(
+                    refresh_token="expired-token",
+                    client_id="my-client-id",
+                )
+
+        assert exc_info.value.response.status_code == 401
+
+
+class TestIdentityServiceGetClientCredentialsToken:
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_client_credentials_success(
+        self, httpx_mock: HTTPXMock, use_async: bool
+    ):
+        domain = "https://cloud.uipath.com"
+        httpx_mock.add_response(
+            url=f"{domain}/identity_/connect/token",
+            method="POST",
+            status_code=200,
+            json={
+                "access_token": "cc-access-token",
+                "expires_in": 7200,
+                "token_type": "Bearer",
+                "scope": "OR.Execution",
+            },
+        )
+
+        service = IdentityService(domain)
+        if use_async:
+            token = await service.get_client_credentials_token_async(
+                client_id="app-client-id",
+                client_secret="app-client-secret",
+                scope="OR.Execution",
+            )
+        else:
+            token = service.get_client_credentials_token(
+                client_id="app-client-id",
+                client_secret="app-client-secret",
+                scope="OR.Execution",
+            )
+
+        assert token.access_token == "cc-access-token"
+        assert token.scope == "OR.Execution"
diff --git a/tests/sdk/services/test_jobs_service.py b/packages/uipath-platform/tests/services/test_jobs_service.py
similarity index 63%
rename from tests/sdk/services/test_jobs_service.py
rename to packages/uipath-platform/tests/services/test_jobs_service.py
index 5c799a221..e0321717e 100644
--- a/tests/sdk/services/test_jobs_service.py
+++ b/packages/uipath-platform/tests/services/test_jobs_service.py
@@ -8,11 +8,10 @@
 from pytest_httpx import HTTPXMock
 from pytest_mock import MockerFixture
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.jobs_service import JobsService
-from uipath._utils.constants import HEADER_USER_AGENT, TEMP_ATTACHMENTS_FOLDER
-from uipath.models.job import Job
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_USER_AGENT, TEMP_ATTACHMENTS_FOLDER
+from uipath.platform.orchestrator import Job
+from uipath.platform.orchestrator._jobs_service import JobsService
 
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch
@@ -20,8 +19,8 @@
 
 @pytest.fixture
 def service(
-    config: Config,
-    execution_context: ExecutionContext,
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
     monkeypatch: pytest.MonkeyPatch,
 ) -> JobsService:
     monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
@@ -120,6 +119,7 @@ def test_retrieve(
                 "State": "Running",
                 "StartTime": "2024-01-01T00:00:00Z",
                 "Id": 123,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
             },
         )
 
@@ -130,6 +130,7 @@ def test_retrieve(
         assert job.state == "Running"
         assert job.start_time == "2024-01-01T00:00:00Z"
         assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
 
         sent_request = httpx_mock.get_request()
         assert sent_request is not None
@@ -164,6 +165,7 @@ async def test_retrieve_async(
                 "State": "Running",
                 "StartTime": "2024-01-01T00:00:00Z",
                 "Id": 123,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
             },
         )
 
@@ -174,6 +176,7 @@ async def test_retrieve_async(
         assert job.state == "Running"
         assert job.start_time == "2024-01-01T00:00:00Z"
         assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
 
         sent_request = httpx_mock.get_request()
         assert sent_request is not None
@@ -214,7 +217,8 @@ def test_resume_with_inbox_id(
             sent_request.url
             == f"{base_url}{org}{tenant}/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
         )
-        assert json.loads(sent_request.content) == {"payload": payload}
+
+        assert json.loads(sent_request.content.decode()) == {"payload": payload}
 
         assert HEADER_USER_AGENT in sent_request.headers
         assert (
@@ -255,7 +259,8 @@ def test_resume_with_job_id(
             sent_requests[1].url
             == f"{base_url}{org}{tenant}/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
         )
-        assert json.loads(sent_requests[1].content) == {"payload": payload}
+
+        assert json.loads(sent_requests[1].content.decode()) == {"payload": payload}
 
         assert HEADER_USER_AGENT in sent_requests[1].headers
         assert (
@@ -289,7 +294,8 @@ async def test_resume_async_with_inbox_id(
             sent_request.url
             == f"{base_url}{org}{tenant}/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
         )
-        assert json.loads(sent_request.content) == {"payload": payload}
+
+        assert json.loads(sent_request.content.decode()) == {"payload": payload}
 
         assert HEADER_USER_AGENT in sent_request.headers
         assert (
@@ -331,7 +337,8 @@ async def test_resume_async_with_job_id(
             sent_requests[1].url
             == f"{base_url}{org}{tenant}/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
         )
-        assert json.loads(sent_requests[1].content) == {"payload": payload}
+
+        assert json.loads(sent_requests[1].content.decode()) == {"payload": payload}
 
         assert HEADER_USER_AGENT in sent_requests[1].headers
         assert (
@@ -557,8 +564,8 @@ def test_create_job_attachment_with_job(
 
     def test_create_job_attachment_with_job_context(
         self,
-        config: Config,
-        execution_context: ExecutionContext,
+        config: UiPathApiConfig,
+        execution_context: UiPathExecutionContext,
         monkeypatch: "MonkeyPatch",
         mocker: MockerFixture,
     ) -> None:
@@ -568,8 +575,8 @@ def test_create_job_attachment_with_job_context(
         when a job key is available in the execution context.
 
         Args:
-            config: Config fixture.
-            execution_context: ExecutionContext fixture.
+            config: UiPathApiConfig fixture.
+            execution_context: UiPathExecutionContext fixture.
             monkeypatch: MonkeyPatch fixture.
             mocker: MockerFixture for mocking dependencies.
         """
@@ -584,7 +591,7 @@ def test_create_job_attachment_with_job_context(
         monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
 
         # Create fresh execution context after setting environment variables
-        fresh_execution_context = ExecutionContext()
+        fresh_execution_context = UiPathExecutionContext()
         service = JobsService(config=config, execution_context=fresh_execution_context)
 
         # Mock the attachment service's upload method
@@ -680,6 +687,463 @@ def test_create_job_attachment_from_file(
         with open(expected_path, "r") as f:
             assert f.read() == source_content
 
+    def test_extract_output_with_inline_arguments(
+        self,
+        service: JobsService,
+    ) -> None:
+        """Test extracting job output when output is stored inline (small output)."""
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": '{"result": "small output data", "status": "completed"}',
+            "OutputFile": None,
+        }
+        job = Job.model_validate(job_data)
+
+        result = service.extract_output(job)
+
+        assert result == '{"result": "small output data", "status": "completed"}'
+
+    def test_extract_output_with_attachment(
+        self,
+        httpx_mock: HTTPXMock,
+        service: JobsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        temp_attachments_dir: str,
+    ) -> None:
+        """Test extracting job output when output is stored as attachment (large output)."""
+
+        service._temp_dir = temp_attachments_dir
+        attachment_id = str(uuid.uuid4())
+        large_output = '{"result": "' + "x" * 10001 + '", "status": "completed"}'
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": None,
+            "OutputFile": attachment_id,
+        }
+        job = Job.model_validate(job_data)
+
+        blob_uri = "https://test-storage.com/test-container/test-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_id})",
+            method="GET",
+            status_code=200,
+            json={
+                "Id": attachment_id,
+                "Name": "output.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["Content-Type"],
+                        "Values": ["application/json"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="GET",
+            status_code=200,
+            content=large_output.encode("utf-8"),
+        )
+
+        result = service.extract_output(job)
+
+        assert result == large_output
+
+    @pytest.mark.asyncio
+    async def test_extract_output_async_with_inline_arguments(
+        self,
+        service: JobsService,
+    ) -> None:
+        """Test extracting job output asynchronously when output is stored inline."""
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": '{"result": "small output data", "status": "completed"}',
+            "OutputFile": None,
+        }
+        job = Job.model_validate(job_data)
+
+        result = await service.extract_output_async(job)
+
+        assert result == '{"result": "small output data", "status": "completed"}'
+
+    @pytest.mark.asyncio
+    async def test_extract_output_async_with_attachment(
+        self,
+        httpx_mock: HTTPXMock,
+        service: JobsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        temp_attachments_dir: str,
+    ) -> None:
+        """Test extracting job output asynchronously when output is stored as attachment."""
+
+        service._temp_dir = temp_attachments_dir
+        attachment_id = str(uuid.uuid4())
+        large_output = '{"result": "' + "y" * 10001 + '", "status": "completed"}'
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": None,
+            "OutputFile": attachment_id,
+        }
+        job = Job.model_validate(job_data)
+
+        blob_uri = "https://test-storage.com/test-container/test-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_id})",
+            method="GET",
+            status_code=200,
+            json={
+                "Id": attachment_id,
+                "Name": "output.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["Content-Type"],
+                        "Values": ["application/json"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="GET",
+            status_code=200,
+            content=large_output.encode("utf-8"),
+        )
+
+        result = await service.extract_output_async(job)
+
+        assert result == large_output
+
+    def test_extract_output_no_output(
+        self,
+        service: JobsService,
+    ) -> None:
+        """Test extracting job output when no output is available."""
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": None,
+            "OutputFile": None,
+        }
+        job = Job.model_validate(job_data)
+
+        result = service.extract_output(job)
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_extract_output_async_no_output(
+        self,
+        service: JobsService,
+    ) -> None:
+        """Test extracting job output asynchronously when no output is available."""
+
+        job_data = {
+            "Key": "test-job-key",
+            "State": "Successful",
+            "StartTime": "2024-01-01T00:00:00Z",
+            "Id": 123,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "OutputArguments": None,
+            "OutputFile": None,
+        }
+        job = Job.model_validate(job_data)
+
+        result = await service.extract_output_async(job)
+
+        assert result is None
+
+    def test_retrieve_job_with_large_output_integration(
+        self,
+        httpx_mock: HTTPXMock,
+        service: JobsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        temp_attachments_dir: str,
+    ) -> None:
+        """Retrieve job with large output stored as attachment and extract it.
+
+        This test verifies the complete flow:
+        1. Job retrieval returns a job with OutputFile (not OutputArguments)
+        2. Extract output correctly downloads from the attachment
+        3. The attachment ID matches between job and download
+        """
+        # Arrange
+        service._temp_dir = temp_attachments_dir
+        job_key = "test-job-key-with-large-output"
+        attachment_id = str(uuid.uuid4())
+        large_output_content = (
+            '{"result": "'
+            + "z" * 10001
+            + '", "status": "completed", "metadata": {"size": "large"}}'
+        )
+
+        # job has OutputFile instead of OutputArguments for large output
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={job_key})",
+            method="GET",
+            status_code=200,
+            json={
+                "Key": job_key,
+                "State": "Successful",
+                "StartTime": "2024-01-01T00:00:00Z",
+                "EndTime": "2024-01-01T00:05:00Z",
+                "Id": 456,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                "OutputArguments": None,  # large output is NOT stored inline
+                "OutputFile": attachment_id,  # large output IS stored as attachment
+                "InputArguments": '{"input": "test"}',  # small input stored inline
+                "InputFile": None,
+            },
+        )
+
+        blob_uri = "https://test-storage.com/large-output-container/output-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_id})",
+            method="GET",
+            status_code=200,
+            json={
+                "Id": attachment_id,
+                "Name": "large_output.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["Content-Type", "x-ms-blob-type"],
+                        "Values": ["application/json", "BlockBlob"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="GET",
+            status_code=200,
+            content=large_output_content.encode("utf-8"),
+        )
+
+        job = service.retrieve(job_key)
+
+        # job structure is correct for large output
+        assert job.key == job_key
+        assert job.state == "Successful"
+        assert job.output_arguments is None  # large output not stored inline
+        assert job.output_file == attachment_id  # large output stored as attachment
+        assert job.input_arguments == '{"input": "test"}'  # small input stored inline
+        assert job.input_file is None
+
+        extracted_output = service.extract_output(job)
+
+        assert extracted_output == large_output_content
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 3
+
+        job_request = requests[0]
+        assert job_request.method == "GET"
+        assert job_key in str(job_request.url)
+
+        attachment_request = requests[1]
+        assert attachment_request.method == "GET"
+        assert attachment_id in str(attachment_request.url)
+        assert "Attachments" in str(attachment_request.url)
+
+        blob_request = requests[2]
+        assert blob_request.method == "GET"
+        assert blob_request.url == blob_uri
+
+    @pytest.mark.asyncio
+    async def test_retrieve_job_with_large_output_integration_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: JobsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        temp_attachments_dir: str,
+    ) -> None:
+        """Async integration test: Retrieve job with large output and extract it."""
+        service._temp_dir = temp_attachments_dir
+        job_key = "test-job-key-async-large-output"
+        attachment_id = str(uuid.uuid4())
+        large_output_content = (
+            '{"result": "'
+            + "w" * 10001
+            + '", "status": "completed", "metadata": {"async": true}}'
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={job_key})",
+            method="GET",
+            status_code=200,
+            json={
+                "Key": job_key,
+                "State": "Successful",
+                "StartTime": "2024-01-01T00:00:00Z",
+                "EndTime": "2024-01-01T00:10:00Z",
+                "Id": 789,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                "OutputArguments": None,
+                "OutputFile": attachment_id,
+                "InputArguments": None,
+                "InputFile": None,
+            },
+        )
+
+        blob_uri = "https://test-storage.com/async-output-container/output-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments({attachment_id})",
+            method="GET",
+            status_code=200,
+            json={
+                "Id": attachment_id,
+                "Name": "async_large_output.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["Content-Type"],
+                        "Values": ["application/json"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="GET",
+            status_code=200,
+            content=large_output_content.encode("utf-8"),
+        )
+
+        job = await service.retrieve_async(job_key)
+
+        assert job.key == job_key
+        assert job.state == "Successful"
+        assert job.output_arguments is None
+        assert job.output_file == attachment_id
+
+        extracted_output = await service.extract_output_async(job)
+
+        assert extracted_output == large_output_content
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 3
+
+        job_request = requests[0]
+        attachment_request = requests[1]
+        blob_request = requests[2]
+
+        assert job_key in str(job_request.url)
+        assert attachment_id in str(attachment_request.url)
+        assert blob_request.url == blob_uri
+
+    def test_retrieve_job_with_small_output_vs_large_output(
+        self,
+        httpx_mock: HTTPXMock,
+        service: JobsService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        """Test that demonstrates the difference between small and large output handling."""
+
+        small_job_key = "job-with-small-output"
+        small_output = '{"result": "small", "status": "ok"}'
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={small_job_key})",
+            method="GET",
+            status_code=200,
+            json={
+                "Key": small_job_key,
+                "State": "Successful",
+                "StartTime": "2024-01-01T00:00:00Z",
+                "Id": 100,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                "OutputArguments": small_output,  # small output stored inline
+                "OutputFile": None,  # no attachment needed
+                "InputArguments": '{"input": "test"}',
+                "InputFile": None,
+            },
+        )
+
+        large_job_key = "job-with-large-output"
+        large_attachment_id = str(uuid.uuid4())
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={large_job_key})",
+            method="GET",
+            status_code=200,
+            json={
+                "Key": large_job_key,
+                "State": "Successful",
+                "StartTime": "2024-01-01T00:00:00Z",
+                "Id": 200,
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                "OutputArguments": None,  # large output NOT stored inline
+                "OutputFile": large_attachment_id,  # large output stored as attachment
+                "InputArguments": '{"input": "test"}',
+                "InputFile": None,
+            },
+        )
+
+        small_job = service.retrieve(small_job_key)
+        large_job = service.retrieve(large_job_key)
+
+        assert small_job.output_arguments == small_output
+        assert small_job.output_file is None
+
+        assert large_job.output_arguments is None
+        assert large_job.output_file == large_attachment_id
+
+        assert small_job.input_arguments == '{"input": "test"}'
+        assert small_job.input_file is None
+        assert large_job.input_arguments == '{"input": "test"}'
+        assert large_job.input_file is None
+
+        small_extracted = service.extract_output(small_job)
+        assert small_extracted == small_output
+
+        # only 2 requests made (job retrievals, no attachment downloads)
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
     def test_create_job_attachment_validation_errors(
         self,
         service: JobsService,
diff --git a/packages/uipath-platform/tests/services/test_jobs_service_bulk_operations.py b/packages/uipath-platform/tests/services/test_jobs_service_bulk_operations.py
new file mode 100644
index 000000000..ce2f48b28
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_jobs_service_bulk_operations.py
@@ -0,0 +1,213 @@
+"""Tests for bulk job operations and N+1 fix."""
+
+import pytest
+
+# Test UUIDs
+KEY1 = "11111111-1111-1111-1111-111111111111"
+KEY2 = "22222222-2222-2222-2222-222222222222"
+KEY3 = "33333333-3333-3333-3333-333333333333"
+
+
+class TestResolveJobIdentifiers:
+    """Test _resolve_job_identifiers() bulk query."""
+
+    def test_resolve_single_key(self, jobs_service, httpx_mock, base_url, org, tenant):
+        """Test resolving single job key to ID."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=Key+in+%28%27{KEY1}%27%29&%24select=Id%2CKey&%24top=1",
+            json={"value": [{"Key": KEY1, "Id": 100}]},
+        )
+
+        ids = jobs_service._resolve_job_identifiers(job_keys=[KEY1])
+
+        assert ids == [100]
+        assert len(httpx_mock.get_requests()) == 1
+
+    def test_resolve_multiple_keys_single_query(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test resolving multiple job keys in single query (N+1 fix verification)."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=Key+in+%28%27{KEY1}%27%2C%27{KEY2}%27%2C%27{KEY3}%27%29&%24select=Id%2CKey&%24top=3",
+            json={
+                "value": [
+                    {"Key": KEY1, "Id": 100},
+                    {"Key": KEY2, "Id": 101},
+                    {"Key": KEY3, "Id": 102},
+                ]
+            },
+        )
+
+        ids = jobs_service._resolve_job_identifiers(job_keys=[KEY1, KEY2, KEY3])
+
+        assert ids == [100, 101, 102]
+        assert len(httpx_mock.get_requests()) == 1  # Only 1 API call!
+
+    def test_resolve_preserves_order(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that returned IDs maintain input key order."""
+        # API may return in different order
+        httpx_mock.add_response(
+            json={
+                "value": [
+                    {"Key": KEY3, "Id": 102},
+                    {"Key": KEY1, "Id": 100},
+                    {"Key": KEY2, "Id": 101},
+                ]
+            },
+        )
+
+        ids = jobs_service._resolve_job_identifiers(job_keys=[KEY1, KEY2, KEY3])
+
+        assert ids == [100, 101, 102]  # Correct order preserved
+
+    def test_resolve_missing_key(self, jobs_service, httpx_mock, base_url, org, tenant):
+        """Test error when some keys not found."""
+        httpx_mock.add_response(
+            json={
+                "value": [
+                    {"Key": KEY1, "Id": 100},
+                    # KEY2 missing
+                    {"Key": KEY3, "Id": 102},
+                ]
+            },
+        )
+
+        with pytest.raises(LookupError, match=f"Jobs not found for keys: {KEY2}"):
+            jobs_service._resolve_job_identifiers(job_keys=[KEY1, KEY2, KEY3])
+
+    def test_resolve_empty_list(self, jobs_service):
+        """Test handling of empty key list."""
+        ids = jobs_service._resolve_job_identifiers(job_keys=[])
+        assert ids == []
+
+    def test_resolve_duplicate_keys(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that duplicate keys are handled correctly."""
+        httpx_mock.add_response(
+            json={
+                "value": [
+                    {"Key": KEY1, "Id": 100},
+                    {"Key": KEY2, "Id": 101},
+                ]
+            },
+        )
+
+        # Request with duplicates
+        ids = jobs_service._resolve_job_identifiers(job_keys=[KEY1, KEY2, KEY1])
+
+        # Should return corresponding IDs maintaining order (including duplicates)
+        assert ids == [100, 101, 100]
+        assert len(httpx_mock.get_requests()) == 1  # Only 1 query despite duplicates
+
+    def test_resolve_invalid_uuid(self, jobs_service):
+        """Test that invalid UUID keys raise ValueError."""
+        with pytest.raises(ValueError, match="Invalid job key format: not-a-uuid"):
+            jobs_service._resolve_job_identifiers(job_keys=["not-a-uuid"])
+
+    def test_resolve_large_batch_chunks(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that large batches are chunked (50 keys per request)."""
+        # Create 100 test keys (should result in 2 chunks)
+        test_keys = [f"{i:08x}-0000-0000-0000-000000000000" for i in range(100)]
+
+        # Mock first chunk (keys 0-49)
+        chunk1_keys = test_keys[:50]
+        chunk1_filter = "%27%2C%27".join(chunk1_keys)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=Key+in+%28%27{chunk1_filter}%27%29&%24select=Id%2CKey&%24top=50",
+            json={"value": [{"Key": k, "Id": i} for i, k in enumerate(chunk1_keys)]},
+        )
+
+        # Mock second chunk (keys 50-99)
+        chunk2_keys = test_keys[50:]
+        chunk2_filter = "%27%2C%27".join(chunk2_keys)
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=Key+in+%28%27{chunk2_filter}%27%29&%24select=Id%2CKey&%24top=50",
+            json={
+                "value": [{"Key": k, "Id": i + 50} for i, k in enumerate(chunk2_keys)]
+            },
+        )
+
+        ids = jobs_service._resolve_job_identifiers(job_keys=test_keys)
+
+        assert len(ids) == 100
+        assert len(httpx_mock.get_requests()) == 2  # 2 chunks = 2 API calls
+
+
+class TestStopWithBulkResolution:
+    """Test stop() uses bulk resolution and pure spec pattern."""
+
+    def test_stop_multiple_jobs_only_two_calls(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test stopping multiple jobs makes only 2 API calls (resolve + stop)."""
+        # Mock bulk resolution
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=Key+in+%28%27{KEY1}%27%2C%27{KEY2}%27%29&%24select=Id%2CKey&%24top=2",
+            json={"value": [{"Key": KEY1, "Id": 100}, {"Key": KEY2, "Id": 101}]},
+        )
+
+        # Mock stop request
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StopJobs",
+            method="POST",
+            json={},
+        )
+
+        jobs_service.stop(job_keys=[KEY1, KEY2], strategy="SoftStop")
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2  # Not N+1!
+
+        # Verify stop request body matches Swagger schema
+        import json
+
+        stop_request = requests[-1]
+        body = json.loads(stop_request.content)
+        assert body == {"jobIds": [100, 101], "strategy": "SoftStop"}
+        assert all(isinstance(id, int) for id in body["jobIds"])  # int64 validation
+
+    def test_stop_single_job(self, jobs_service, httpx_mock, base_url, org, tenant):
+        """Test stopping single job."""
+        # Mock bulk resolution
+        httpx_mock.add_response(
+            json={"value": [{"Key": KEY1, "Id": 100}]},
+        )
+
+        # Mock stop request
+        httpx_mock.add_response(
+            method="POST",
+            json={},
+        )
+
+        jobs_service.stop(job_keys=[KEY1], strategy="Kill")
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+    def test_stop_invalid_uuid_raises_error(self, jobs_service):
+        """Test that invalid UUID in stop() raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid job key format"):
+            jobs_service.stop(job_keys=["invalid-uuid"])
+
+    @pytest.mark.asyncio
+    async def test_stop_async_uses_async_resolution(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test stop_async uses async bulk resolution."""
+        httpx_mock.add_response(
+            json={"value": [{"Key": KEY1, "Id": 100}]},
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            json={},
+        )
+
+        await jobs_service.stop_async(job_keys=[KEY1])
+
+        assert len(httpx_mock.get_requests()) == 2
diff --git a/packages/uipath-platform/tests/services/test_jobs_service_pagination.py b/packages/uipath-platform/tests/services/test_jobs_service_pagination.py
new file mode 100644
index 000000000..f135c3c15
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_jobs_service_pagination.py
@@ -0,0 +1,221 @@
+"""Tests for JobsService PagedResult pagination."""
+
+import pytest
+
+from uipath.platform.common.paging import PagedResult
+from uipath.platform.orchestrator.job import Job
+
+
+class TestJobsListPagination:
+    """Test list() pagination with PagedResult."""
+
+    def test_list_returns_paged_result(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that list() returns PagedResult[Job]."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=100",
+            json={
+                "value": [
+                    {
+                        "Key": "job-1",
+                        "Id": 1,
+                        "State": "Successful",
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        result = jobs_service.list()
+
+        assert isinstance(result, PagedResult)
+        assert len(result.items) == 1
+        assert isinstance(result.items[0], Job)
+        assert result.skip == 0
+        assert result.top == 100
+
+    def test_list_has_more_true_when_full_page(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test has_more=True when page is full."""
+        jobs = [
+            {
+                "Key": f"job-{i}",
+                "Id": i,
+                "State": "Successful",
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            }
+            for i in range(100)
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=100",
+            json={"value": jobs},
+        )
+
+        result = jobs_service.list(top=100)
+
+        assert result.has_more is True
+        assert len(result.items) == 100
+
+    def test_list_has_more_false_when_partial_page(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test has_more=False when page is partial."""
+        jobs = [
+            {
+                "Key": f"job-{i}",
+                "Id": i,
+                "State": "Successful",
+                "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            }
+            for i in range(50)
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=100",
+            json={"value": jobs},
+        )
+
+        result = jobs_service.list(top=100)
+
+        assert result.has_more is False
+        assert len(result.items) == 50
+
+    def test_list_with_filter(self, jobs_service, httpx_mock, base_url, org, tenant):
+        """Test list with OData filter."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24filter=State+eq+%27Successful%27&%24skip=0&%24top=100",
+            json={
+                "value": [
+                    {
+                        "Key": "job-1",
+                        "Id": 1,
+                        "State": "Successful",
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        result = jobs_service.list(filter="State eq 'Successful'")
+
+        assert len(result.items) == 1
+        assert result.items[0].state == "Successful"
+
+    def test_list_manual_pagination(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test manual pagination across multiple pages."""
+        # First page
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=10",
+            json={
+                "value": [
+                    {
+                        "Key": f"job-{i}",
+                        "Id": i,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                    for i in range(10)
+                ]
+            },
+        )
+        # Second page
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=10&%24top=10",
+            json={
+                "value": [
+                    {
+                        "Key": f"job-{i}",
+                        "Id": i,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                    for i in range(10, 15)
+                ]
+            },
+        )
+
+        # Fetch first page
+        page1 = jobs_service.list(skip=0, top=10)
+        assert len(page1.items) == 10
+        assert page1.has_more is True
+
+        # Fetch second page
+        page2 = jobs_service.list(skip=10, top=10)
+        assert len(page2.items) == 5
+        assert page2.has_more is False
+
+
+class TestJobsListValidation:
+    """Test parameter validation for list()."""
+
+    def test_list_skip_exceeds_maximum(self, jobs_service):
+        """Test error when skip > MAX_SKIP_OFFSET."""
+        with pytest.raises(
+            ValueError, match=r"skip must be <= 10000.*requested: 10001"
+        ):
+            jobs_service.list(skip=10001)
+
+    def test_list_top_exceeds_maximum(self, jobs_service):
+        """Test error when top > MAX_PAGE_SIZE."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000.*requested: 1001"):
+            jobs_service.list(top=1001)
+
+    def test_list_uses_shared_validation(self, jobs_service):
+        """Test that list() uses shared validation utility."""
+        with pytest.raises(ValueError, match="skip must be >= 0"):
+            jobs_service.list(skip=-1)
+
+        with pytest.raises(ValueError, match="top must be >= 1"):
+            jobs_service.list(top=0)
+
+    def test_list_skip_at_boundary(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that skip=10000 is allowed."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=10000&%24top=100",
+            json={"value": []},
+        )
+
+        result = jobs_service.list(skip=10000)
+        assert result is not None
+
+    def test_list_top_at_boundary(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that top=1000 is allowed."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=1000",
+            json={"value": []},
+        )
+
+        result = jobs_service.list(top=1000)
+        assert result is not None
+
+
+class TestJobsListAsync:
+    """Test async version of list()."""
+
+    @pytest.mark.asyncio
+    async def test_list_async_returns_paged_result(
+        self, jobs_service, httpx_mock, base_url, org, tenant
+    ):
+        """Test that list_async() returns PagedResult[Job]."""
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs?%24skip=0&%24top=100",
+            json={
+                "value": [
+                    {
+                        "Key": "job-1",
+                        "Id": 1,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        result = await jobs_service.list_async()
+
+        assert isinstance(result, PagedResult)
+        assert len(result.items) == 1
diff --git a/tests/sdk/services/test_llm_integration.py b/packages/uipath-platform/tests/services/test_llm_integration.py
similarity index 92%
rename from tests/sdk/services/test_llm_integration.py
rename to packages/uipath-platform/tests/services/test_llm_integration.py
index 940f23fde..e1c3a549f 100644
--- a/tests/sdk/services/test_llm_integration.py
+++ b/packages/uipath-platform/tests/services/test_llm_integration.py
@@ -3,13 +3,13 @@
 import httpx
 import pytest
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.llm_gateway_service import (
+from uipath.platform import UiPathExecutionContext
+from uipath.platform.chat import (
     ChatModels,
     EmbeddingModels,
     UiPathOpenAIService,
 )
+from uipath.platform.common import UiPathApiConfig
 
 
 def get_env_var(name: str) -> str:
@@ -52,8 +52,8 @@ def llm_service(self):
         base_url = get_env_var("UIPATH_URL")
         api_key = get_access_token()
 
-        config = Config(base_url=base_url, secret=api_key)
-        execution_context = ExecutionContext()
+        config = UiPathApiConfig(base_url=base_url, secret=api_key)
+        execution_context = UiPathExecutionContext()
         return UiPathOpenAIService(config=config, execution_context=execution_context)
 
     @pytest.mark.asyncio
@@ -85,7 +85,7 @@ async def test_chat_completions_real(self, llm_service):
         # Make the actual API call
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=50,
             temperature=0.7,
         )
diff --git a/packages/uipath-platform/tests/services/test_llm_schema_cleanup.py b/packages/uipath-platform/tests/services/test_llm_schema_cleanup.py
new file mode 100644
index 000000000..5cddddbc0
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_llm_schema_cleanup.py
@@ -0,0 +1,229 @@
+"""Tests for the _cleanup_schema function in LLM Gateway Service."""
+
+from pydantic import BaseModel
+
+from uipath.platform.chat._llm_gateway_service import _cleanup_schema
+
+
+# Simple test models
+class SimpleModel(BaseModel):
+    name: str
+    age: int
+    active: bool
+
+
+class ModelWithList(BaseModel):
+    names: list[str]
+    numbers: list[int]
+
+
+class ModelWithOptional(BaseModel):
+    required_field: str
+    optional_field: str | None = None
+
+
+# Complex nested models for comprehensive testing
+class Task(BaseModel):
+    task_id: int
+    description: str
+    completed: bool
+
+
+class Project(BaseModel):
+    project_id: int
+    name: str
+    tasks: list[Task]
+
+
+class Team(BaseModel):
+    team_id: int
+    team_name: str
+    members: list[str]
+    projects: list[Project]
+
+
+class Department(BaseModel):
+    department_id: int
+    department_name: str
+    teams: list[Team]
+
+
+class Company(BaseModel):
+    company_id: int
+    company_name: str
+    departments: list[Department]
+
+
+class TestCleanupSchema:
+    """Test cases for the _cleanup_schema function."""
+
+    def test_simple_model_cleanup(self):
+        """Test cleanup of a simple model without nested structures."""
+        schema = _cleanup_schema(SimpleModel.model_json_schema())
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+        assert "required" in schema
+        assert set(schema["required"]) == {"name", "age", "active"}
+
+        # Check properties are cleaned (no titles)
+        properties = schema["properties"]
+        assert "name" in properties
+        assert "age" in properties
+        assert "active" in properties
+
+        # Ensure no 'title' fields are present
+        for _prop_name, prop_def in properties.items():
+            assert "title" not in prop_def
+
+    def test_model_with_list_cleanup(self):
+        """Test cleanup of a model with list fields."""
+        schema = _cleanup_schema(ModelWithList.model_json_schema())
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+
+        # Check list properties
+        names_prop = schema["properties"]["names"]
+        assert names_prop["type"] == "array"
+        assert "items" in names_prop
+        assert names_prop["items"]["type"] == "string"
+        # Ensure no 'title' in items
+        assert "title" not in names_prop["items"]
+
+        numbers_prop = schema["properties"]["numbers"]
+        assert numbers_prop["type"] == "array"
+        assert "items" in numbers_prop
+        assert numbers_prop["items"]["type"] == "integer"
+        assert "title" not in numbers_prop["items"]
+
+    def test_model_with_optional_cleanup(self):
+        """Test cleanup of a model with optional fields."""
+        schema = _cleanup_schema(ModelWithOptional.model_json_schema())
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+
+        # Only required_field should be in required array
+        assert schema["required"] == ["required_field", "optional_field"]
+
+        # Both fields should be in properties
+        assert "required_field" in schema["properties"]
+        assert "optional_field" in schema["properties"]
+
+    def test_complex_nested_model_cleanup(self):
+        """Test cleanup of the complex nested Company model."""
+        schema = _cleanup_schema(Company.model_json_schema())
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+        assert set(schema["required"]) == {"company_id", "company_name", "departments"}
+
+        # Check top-level properties
+        properties = schema["properties"]
+        assert "company_id" in properties
+        assert "company_name" in properties
+        assert "departments" in properties
+
+        # Check departments is array of objects
+        departments_prop = properties["departments"]
+        assert departments_prop["type"] == "array"
+        assert "items" in departments_prop
+        assert "title" not in departments_prop["items"]
+
+        # Verify no 'title' fields exist anywhere in the schema
+        self._assert_no_titles_recursive(schema)
+
+    def test_schema_structure_integrity(self):
+        """Test that the cleaned schema maintains proper JSON Schema structure."""
+        schema = _cleanup_schema(Company.model_json_schema())
+
+        # Must have these top-level keys
+        required_keys = {"type", "properties", "required", "additionalProperties"}
+        assert all(key in schema for key in required_keys)
+
+        # Type must be object
+        assert schema["type"] == "object"
+
+        # additionalProperties must be False
+        assert schema["additionalProperties"] is False
+
+        # Properties must be a dict
+        assert isinstance(schema["properties"], dict)
+
+        # Required must be a list
+        assert isinstance(schema["required"], list)
+
+    def test_email_field_handling(self):
+        """Test that EmailStr fields are properly handled."""
+        schema = _cleanup_schema(Team.model_json_schema())
+
+        members_prop = schema["properties"]["members"]
+        assert members_prop["type"] == "array"
+
+        # EmailStr should be treated as string with format
+        items = members_prop["items"]
+        assert items["type"] == "string"
+        # Email format might be present
+        if "format" in items:
+            assert items["format"] == "email"
+
+    def test_nested_objects_cleanup(self):
+        """Test that nested objects are properly cleaned."""
+        schema = _cleanup_schema(Department.model_json_schema())
+
+        # Check teams property (array of Team objects)
+        teams_prop = schema["properties"]["teams"]
+        assert teams_prop["type"] == "array"
+        assert "items" in teams_prop
+
+        # The items should not have title
+        team_items = teams_prop["items"]
+        assert "title" not in team_items
+
+        # If it's a nested object, check its properties
+        if "properties" in team_items:
+            for _prop_name, prop_def in team_items["properties"].items():
+                assert "title" not in prop_def
+
+    def _assert_no_titles_recursive(self, obj):
+        """Recursively assert that no 'title' fields exist in the schema."""
+        if isinstance(obj, dict):
+            assert "title" not in obj, f"Found 'title' field in: {obj}"
+            for value in obj.values():
+                self._assert_no_titles_recursive(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                self._assert_no_titles_recursive(item)
+
+    def test_function_returns_dict(self):
+        """Test that the function returns a dictionary."""
+        result = _cleanup_schema(SimpleModel.model_json_schema())
+        assert isinstance(result, dict)
+
+    def test_function_with_inheritance(self):
+        """Test cleanup with model inheritance."""
+
+        class BaseEntity(BaseModel):
+            id: int
+            created_at: str
+
+        class ExtendedEntity(BaseEntity):
+            name: str
+            description: str | None = None
+
+        schema = _cleanup_schema(ExtendedEntity.model_json_schema())
+
+        # Should include fields from both base and derived class
+        properties = schema["properties"]
+        assert "id" in properties
+        assert "created_at" in properties
+        assert "name" in properties
+        assert "description" in properties
+
+        # Required fields from both classes
+        required_fields = set(schema["required"])
+        assert "id" in required_fields
+        assert "created_at" in required_fields
+        assert "name" in required_fields
+        assert "description" in required_fields
diff --git a/packages/uipath-platform/tests/services/test_llm_service.py b/packages/uipath-platform/tests/services/test_llm_service.py
new file mode 100644
index 000000000..e1ab8299b
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_llm_service.py
@@ -0,0 +1,545 @@
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pydantic import BaseModel
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import (
+    ChatModels,
+    EmbeddingModels,
+    TextEmbedding,
+    UiPathOpenAIService,
+)
+
+
+class TestOpenAIService:
+    @pytest.fixture
+    def config(self):
+        return UiPathApiConfig(base_url="https://example.com", secret="test_secret")
+
+    @pytest.fixture
+    def execution_context(self):
+        return UiPathExecutionContext()
+
+    @pytest.fixture
+    def openai_service(self, config, execution_context):
+        return UiPathOpenAIService(config=config, execution_context=execution_context)
+
+    @pytest.fixture
+    def llm_service(self, config, execution_context):
+        return UiPathOpenAIService(config=config, execution_context=execution_context)
+
+    def test_init(self, config, execution_context):
+        service = UiPathOpenAIService(
+            config=config, execution_context=execution_context
+        )
+        assert service._config == config
+        assert service._execution_context == execution_context
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_embeddings(self, mock_request, openai_service):
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "data": [{"embedding": [0.1, 0.2, 0.3], "index": 0, "object": "embedding"}],
+            "model": "text-embedding-ada-002",
+            "object": "list",
+            "usage": {"prompt_tokens": 4, "total_tokens": 4},
+        }
+        mock_request.return_value = mock_response
+
+        # Call the method
+        result = await openai_service.embeddings(input="Test input")
+
+        # Assertions
+        mock_request.assert_called_once()
+        assert isinstance(result, TextEmbedding)
+        assert result.data[0].embedding == [0.1, 0.2, 0.3]
+        assert result.model == "text-embedding-ada-002"
+        assert result.usage.prompt_tokens == 4
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_embeddings_with_custom_model(self, mock_request, openai_service):
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "data": [{"embedding": [0.1, 0.2, 0.3], "index": 0, "object": "embedding"}],
+            "model": "text-embedding-3-large",
+            "object": "list",
+            "usage": {"prompt_tokens": 4, "total_tokens": 4},
+        }
+        mock_request.return_value = mock_response
+
+        # Call the method with custom model
+        result = await openai_service.embeddings(
+            input="Test input", embedding_model=EmbeddingModels.text_embedding_3_large
+        )
+
+        # Assertions for the result
+        mock_request.assert_called_once()
+        assert result.model == "text-embedding-3-large"
+        assert len(result.data) == 1
+        assert result.data[0].embedding == [0.1, 0.2, 0.3]
+        assert result.data[0].index == 0
+        assert result.object == "list"
+        assert result.usage.prompt_tokens == 4
+        assert result.usage.total_tokens == 4
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_complex_company_pydantic_model(self, mock_request, llm_service):
+        """Test using complex Company Pydantic model as response_format."""
+
+        # Define the complex nested models
+        class Task(BaseModel):
+            task_id: int
+            description: str
+            completed: bool
+
+        class Project(BaseModel):
+            project_id: int
+            name: str
+            tasks: list[Task]
+
+        class Team(BaseModel):
+            team_id: int
+            team_name: str
+            members: list[str]
+            projects: list[Project]
+
+        class Department(BaseModel):
+            department_id: int
+            department_name: str
+            teams: list[Team]
+
+        class Company(BaseModel):
+            company_id: int
+            company_name: str
+            departments: list[Department]
+
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "id": "chatcmpl-test123",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "gpt-4o-mini-2024-07-18",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": json.dumps(
+                            {
+                                "company_id": 1,
+                                "company_name": "FutureTech Ltd",
+                                "departments": [
+                                    {
+                                        "department_id": 1,
+                                        "department_name": "Engineering",
+                                        "teams": [
+                                            {
+                                                "team_id": 1,
+                                                "team_name": "Backend Team",
+                                                "members": [
+                                                    "john@futuretech.com",
+                                                    "jane@futuretech.com",
+                                                ],
+                                                "projects": [
+                                                    {
+                                                        "project_id": 1,
+                                                        "name": "API Development",
+                                                        "tasks": [
+                                                            {
+                                                                "task_id": 1,
+                                                                "description": "Design REST endpoints",
+                                                                "completed": True,
+                                                            },
+                                                            {
+                                                                "task_id": 2,
+                                                                "description": "Implement authentication",
+                                                                "completed": False,
+                                                            },
+                                                        ],
+                                                    }
+                                                ],
+                                            }
+                                        ],
+                                    },
+                                    {
+                                        "department_id": 2,
+                                        "department_name": "Marketing",
+                                        "teams": [
+                                            {
+                                                "team_id": 2,
+                                                "team_name": "Digital Marketing",
+                                                "members": ["sarah@futuretech.com"],
+                                                "projects": [
+                                                    {
+                                                        "project_id": 2,
+                                                        "name": "Social Media Campaign",
+                                                        "tasks": [
+                                                            {
+                                                                "task_id": 3,
+                                                                "description": "Create content calendar",
+                                                                "completed": True,
+                                                            }
+                                                        ],
+                                                    }
+                                                ],
+                                            }
+                                        ],
+                                    },
+                                ],
+                            }
+                        ),
+                    },
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 150,
+                "completion_tokens": 300,
+                "total_tokens": 450,
+            },
+        }
+        mock_request.return_value = mock_response
+
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "You are a helpful assistant. Respond with structured JSON according to this schema:\n"
+                    "Company -> departments -> teams -> projects -> tasks.\n"
+                    "Each company has a company_id and company_name.\n"
+                    "Each department has a department_id and department_name.\n"
+                    "Each team has a team_id, team_name, members (email addresses), and projects.\n"
+                    "Each project has a project_id, name, and tasks.\n"
+                    "Each task has a task_id, description, and completed status."
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    "Give me an example of a software company called 'FutureTech Ltd' with two departments: "
+                    "Engineering and Marketing. Each department should have at least one team, with projects and tasks."
+                ),
+            },
+        ]
+
+        result = await llm_service.chat_completions(
+            messages=messages,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
+            response_format=Company,  # Pass BaseModel directly instead of dict
+            max_tokens=2000,
+            temperature=0,
+        )
+
+        # Validate the response
+        assert result is not None
+        assert len(result.choices) > 0
+        assert result.choices[0].message.content is not None
+
+        # Parse and validate the JSON response
+        response_json = json.loads(result.choices[0].message.content)
+
+        # Validate the structure matches our Company model
+        assert "company_id" in response_json
+        assert "company_name" in response_json
+        assert "departments" in response_json
+        assert response_json["company_name"] == "FutureTech Ltd"
+        assert len(response_json["departments"]) >= 2
+
+        # Check for Engineering and Marketing departments
+        dept_names = [dept["department_name"] for dept in response_json["departments"]]
+        assert "Engineering" in dept_names
+        assert "Marketing" in dept_names
+
+        # Validate that each department has teams with proper structure
+        for department in response_json["departments"]:
+            assert "teams" in department
+            assert len(department["teams"]) >= 1
+
+            # Validate team structure
+            for team in department["teams"]:
+                assert "team_id" in team
+                assert "team_name" in team
+                assert "members" in team
+                assert "projects" in team
+
+                # Validate projects and tasks
+                for project in team["projects"]:
+                    assert "project_id" in project
+                    assert "name" in project
+                    assert "tasks" in project
+
+                    for task in project["tasks"]:
+                        assert "task_id" in task
+                        assert "description" in task
+                        assert "completed" in task
+
+        # Try to parse it with our Pydantic model to ensure it's completely valid
+        company_instance = Company.model_validate(response_json)
+        assert company_instance.company_name == "FutureTech Ltd"
+        assert len(company_instance.departments) >= 2
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_optional_request_format_model(self, mock_request, llm_service):
+        """Test using complex Company Pydantic model as response_format."""
+
+        class Article(BaseModel):
+            title: str | None = None
+
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "id": "chatcmpl-test123",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "gpt-4o-mini-2024-07-18",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "{}",
+                    },
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 150,
+                "completion_tokens": 300,
+                "total_tokens": 450,
+            },
+        }
+        mock_request.return_value = mock_response
+
+        messages = [
+            {
+                "role": "system",
+                "content": "system-content",
+            },
+            {
+                "role": "user",
+                "content": "user-content",
+            },
+        ]
+
+        result = await llm_service.chat_completions(
+            messages=messages,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
+            response_format=Article,  # Pass BaseModel directly instead of dict
+            max_tokens=2000,
+            temperature=0,
+        )
+        captured_request = mock_request.call_args[1]["json"]
+        expected_request = {
+            "messages": [
+                {"role": "system", "content": "system-content"},
+                {"role": "user", "content": "user-content"},
+            ],
+            "max_tokens": 2000,
+            "temperature": 0,
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "article",
+                    "strict": True,
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": False,
+                        "properties": {
+                            "title": {
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                                "default": None,
+                            }
+                        },
+                        "required": ["title"],
+                    },
+                },
+            },
+        }
+
+        # validate the request to LLM gateway
+        assert expected_request == captured_request
+
+        # Validate the response
+        assert result is not None
+        assert len(result.choices) > 0
+        assert result.choices[0].message.content is not None
+
+        # Parse and validate the JSON response
+        response_json = json.loads(result.choices[0].message.content)
+
+        # Validate the structure matches our Company model
+        assert response_json == {}
+
+        # Try to parse it with our Pydantic model to ensure it's completely valid
+        article_instance = Article.model_validate(response_json)
+        assert article_instance.title is None
+
+
+class TestNormalizedLlmServiceClaudeFiltering:
+    """Test that Claude models correctly filter out OpenAI-specific parameters.
+
+    The UiPath Normalized API gateway passes parameters through to the underlying
+    provider. Claude/Anthropic models do NOT support n, frequency_penalty,
+    presence_penalty, or top_p, and sending them causes 400 errors.
+    """
+
+    @pytest.fixture
+    def config(self):
+        return UiPathApiConfig(base_url="https://example.com", secret="test_secret")
+
+    @pytest.fixture
+    def execution_context(self):
+        return UiPathExecutionContext()
+
+    @pytest.fixture
+    def llm_service(self, config, execution_context):
+        from uipath.platform.chat._llm_gateway_service import UiPathLlmChatService
+
+        return UiPathLlmChatService(config=config, execution_context=execution_context)
+
+    @patch(
+        "uipath.platform.chat._llm_gateway_service.UiPathLlmChatService.request_async"
+    )
+    @pytest.mark.asyncio
+    async def test_claude_model_excludes_openai_params(self, mock_request, llm_service):
+        """Test that Claude models do not include n, frequency_penalty, presence_penalty, top_p."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "id": "chatcmpl-test",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "anthropic.claude-haiku-4-5-20251001-v1:0",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "Hello"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+        }
+        mock_request.return_value = mock_response
+
+        await llm_service.chat_completions(
+            messages=[{"role": "user", "content": "Hello"}],
+            model="anthropic.claude-haiku-4-5-20251001-v1:0",
+            max_tokens=1000,
+            temperature=0,
+        )
+
+        # Get the request body and headers
+        call_kwargs = mock_request.call_args[1]
+        request_body = call_kwargs["json"]
+        headers = call_kwargs["headers"]
+
+        # Claude models should NOT have these OpenAI-specific params
+        assert "n" not in request_body, "Claude request must not include 'n'"
+        assert "frequency_penalty" not in request_body, (
+            "Claude request must not include 'frequency_penalty'"
+        )
+        assert "presence_penalty" not in request_body, (
+            "Claude request must not include 'presence_penalty'"
+        )
+        assert "top_p" not in request_body, "Claude request must not include 'top_p'"
+
+        # Model is sent in headers, not body (Normalized API pattern)
+        assert (
+            headers["X-UiPath-LlmGateway-NormalizedApi-ModelName"]
+            == "anthropic.claude-haiku-4-5-20251001-v1:0"
+        )
+        # Basic params should still be in the body
+        assert request_body["max_tokens"] == 1000
+        assert request_body["temperature"] == 0
+
+    @patch(
+        "uipath.platform.chat._llm_gateway_service.UiPathLlmChatService.request_async"
+    )
+    @pytest.mark.asyncio
+    async def test_openai_model_includes_all_params(self, mock_request, llm_service):
+        """Test that OpenAI models DO include n, frequency_penalty, presence_penalty."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "id": "chatcmpl-test",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "gpt-4o-mini-2024-07-18",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "Hello"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+        }
+        mock_request.return_value = mock_response
+
+        await llm_service.chat_completions(
+            messages=[{"role": "user", "content": "Hello"}],
+            model="gpt-4o-mini-2024-07-18",
+            max_tokens=1000,
+            temperature=0,
+        )
+
+        call_kwargs = mock_request.call_args[1]
+        request_body = call_kwargs["json"]
+
+        # OpenAI models should have all params
+        assert "n" in request_body, "OpenAI request must include 'n'"
+        assert "frequency_penalty" in request_body, (
+            "OpenAI request must include 'frequency_penalty'"
+        )
+        assert "presence_penalty" in request_body, (
+            "OpenAI request must include 'presence_penalty'"
+        )
+
+    @patch(
+        "uipath.platform.chat._llm_gateway_service.UiPathLlmChatService.request_async"
+    )
+    @pytest.mark.asyncio
+    async def test_claude_sonnet_45_excluded_params(self, mock_request, llm_service):
+        """Test Claude Sonnet 4.5 specifically, since it was failing in production."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "id": "chatcmpl-test",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "Hello"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+        }
+        mock_request.return_value = mock_response
+
+        await llm_service.chat_completions(
+            messages=[{"role": "user", "content": "Hello"}],
+            model="anthropic.claude-sonnet-4-5-20250929-v1:0",
+            max_tokens=8000,
+            temperature=0,
+        )
+
+        call_kwargs = mock_request.call_args[1]
+        request_body = call_kwargs["json"]
+
+        assert "n" not in request_body
+        assert "frequency_penalty" not in request_body
+        assert "presence_penalty" not in request_body
+        assert "top_p" not in request_body
+        assert request_body["max_tokens"] == 8000
diff --git a/packages/uipath-platform/tests/services/test_llm_throttle.py b/packages/uipath-platform/tests/services/test_llm_throttle.py
new file mode 100644
index 000000000..733cc9275
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_llm_throttle.py
@@ -0,0 +1,429 @@
+"""Tests for LLM request throttling functionality."""
+
+import asyncio
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import UiPathLlmChatService, UiPathOpenAIService
+from uipath.platform.chat.llm_throttle import (
+    DEFAULT_LLM_CONCURRENCY,
+    get_llm_semaphore,
+    set_llm_concurrency,
+)
+
+
+class TestLLMThrottling:
+    """Tests for LLM throttling mechanism."""
+
+    @pytest.fixture(autouse=True)
+    def reset_semaphore(self):
+        """Reset the global semaphore and limit before each test."""
+        import uipath.platform.chat.llm_throttle as module
+
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+        yield
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+
+    @pytest.fixture
+    def config(self):
+        """Create a test config."""
+        return UiPathApiConfig(base_url="https://example.com", secret="test_secret")
+
+    @pytest.fixture
+    def execution_context(self):
+        """Create a test execution context."""
+        return UiPathExecutionContext()
+
+    @pytest.fixture
+    def openai_service(self, config, execution_context):
+        """Create an OpenAI service instance."""
+        return UiPathOpenAIService(config=config, execution_context=execution_context)
+
+    @pytest.fixture
+    def llm_service(self, config, execution_context):
+        """Create an LLM chat service instance."""
+        return UiPathLlmChatService(config=config, execution_context=execution_context)
+
+    def test_default_concurrency_constant(self):
+        """Test that DEFAULT_LLM_CONCURRENCY is set correctly."""
+        assert DEFAULT_LLM_CONCURRENCY == 20
+
+    @pytest.mark.asyncio
+    async def testget_llm_semaphore_creates_semaphore(self):
+        """Test that get_llm_semaphore creates a semaphore with default limit."""
+        semaphore = get_llm_semaphore()
+        assert isinstance(semaphore, asyncio.Semaphore)
+        # Semaphore should allow DEFAULT_LLM_CONCURRENCY concurrent acquisitions
+        assert semaphore._value == DEFAULT_LLM_CONCURRENCY
+
+    @pytest.mark.asyncio
+    async def testget_llm_semaphore_returns_same_instance(self):
+        """Test that get_llm_semaphore returns the same semaphore instance."""
+        semaphore1 = get_llm_semaphore()
+        semaphore2 = get_llm_semaphore()
+        assert semaphore1 is semaphore2
+
+    @pytest.mark.asyncio
+    async def test_set_llm_concurrency_changes_limit(self):
+        """Test that set_llm_concurrency sets a custom limit."""
+        set_llm_concurrency(5)
+        semaphore = get_llm_semaphore()
+        assert semaphore._value == 5
+
+    @pytest.mark.asyncio
+    async def test_throttle_limits_concurrency(self):
+        """Test that throttling actually limits concurrent operations."""
+        set_llm_concurrency(2)
+
+        concurrent_count = 0
+        max_concurrent = 0
+
+        async def task():
+            nonlocal concurrent_count, max_concurrent
+            async with get_llm_semaphore():
+                concurrent_count += 1
+                max_concurrent = max(max_concurrent, concurrent_count)
+                await asyncio.sleep(0.05)
+                concurrent_count -= 1
+
+        # Run 10 tasks with concurrency limit of 2
+        await asyncio.gather(*[task() for _ in range(10)])
+
+        assert max_concurrent == 2
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_openai_service_uses_throttle(self, mock_request, openai_service):
+        """Test that OpenAI service chat_completions uses throttling."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "id": "test",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "gpt-4o-mini",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "Hello"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+        }
+        mock_request.return_value = mock_response
+
+        set_llm_concurrency(1)
+        semaphore = get_llm_semaphore()
+
+        # Verify semaphore is used during the call
+        initial_value = semaphore._value
+
+        await openai_service.chat_completions(
+            messages=[{"role": "user", "content": "Hi"}]
+        )
+
+        # After the call, semaphore should be back to initial value
+        assert semaphore._value == initial_value
+
+    @patch.object(UiPathLlmChatService, "request_async")
+    @pytest.mark.asyncio
+    async def test_llm_service_uses_throttle(self, mock_request, llm_service):
+        """Test that LLM chat service chat_completions uses throttling."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "id": "test",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "gpt-4o-mini",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "Hello"},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+        }
+        mock_request.return_value = mock_response
+
+        set_llm_concurrency(1)
+        semaphore = get_llm_semaphore()
+
+        initial_value = semaphore._value
+
+        await llm_service.chat_completions(messages=[{"role": "user", "content": "Hi"}])
+
+        assert semaphore._value == initial_value
+
+    @patch.object(UiPathOpenAIService, "request_async")
+    @pytest.mark.asyncio
+    async def test_embeddings_uses_throttle(self, mock_request, openai_service):
+        """Test that embeddings endpoint uses throttling."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "data": [{"embedding": [0.1, 0.2, 0.3], "index": 0, "object": "embedding"}],
+            "model": "text-embedding-ada-002",
+            "object": "list",
+            "usage": {"prompt_tokens": 4, "total_tokens": 4},
+        }
+        mock_request.return_value = mock_response
+
+        set_llm_concurrency(1)
+        semaphore = get_llm_semaphore()
+
+        initial_value = semaphore._value
+
+        await openai_service.embeddings(input="Test input")
+
+        assert semaphore._value == initial_value
+
+
+class TestEventLoopBug:
+    """Tests for the event loop binding bug.
+
+    The bug: If set_llm_concurrency() creates the semaphore before asyncio.run(),
+    the semaphore is bound to the wrong event loop and will fail with:
+    RuntimeError: Semaphore object is bound to a different event loop
+
+    The fix: set_llm_concurrency() only stores the limit, doesn't create semaphore.
+    """
+
+    @pytest.fixture(autouse=True)
+    def reset_semaphore(self):
+        """Reset the global semaphore and limit before each test."""
+        import uipath.platform.chat.llm_throttle as module
+
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+        yield
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+
+    def test_set_llm_concurrency_before_asyncio_run(self):
+        """Test that set_llm_concurrency called before asyncio.run causes issues.
+
+        This test reproduces the bug where the semaphore is created in one
+        event loop context but used in another (created by asyncio.run).
+        """
+        # This simulates what happens in cli_eval.py:
+        # 1. set_llm_concurrency() is called (creates semaphore)
+        # 2. asyncio.run() starts a NEW event loop
+        # 3. Code tries to use the semaphore in the new loop
+
+        # Step 1: Call set_llm_concurrency outside any event loop
+        # (simulating CLI code before asyncio.run)
+        set_llm_concurrency(5)
+
+        # Step 2 & 3: Run async code in a new event loop
+        async def use_semaphore():
+            semaphore = get_llm_semaphore()
+            async with semaphore:
+                pass
+
+        # This should raise RuntimeError if the bug exists
+        # because the semaphore was created in a different loop context
+        try:
+            asyncio.run(use_semaphore())
+            # If we get here, either:
+            # a) The bug is fixed (semaphore created lazily in correct loop)
+            # b) Python version handles this gracefully
+            bug_exists = False
+        except RuntimeError as e:
+            if "different event loop" in str(
+                e
+            ) or "attached to a different loop" in str(e):
+                bug_exists = True
+            else:
+                raise
+
+        # This assertion documents expected behavior:
+        # - If bug_exists is True, the fix is needed
+        # - If bug_exists is False, the fix has been applied or Python handles it
+        # Currently we expect the bug to exist (test should fail after fix is applied)
+        assert not bug_exists, (
+            "Event loop bug detected! The semaphore was created outside the running "
+            "event loop. Fix: set_llm_concurrency should only store the limit, not "
+            "create the semaphore."
+        )
+
+    def test_lazy_semaphore_creation_in_correct_loop(self):
+        """Test that semaphore created inside asyncio.run works correctly.
+
+        This is the expected behavior after the fix is applied.
+        """
+        import uipath.platform.chat.llm_throttle as module
+
+        # Ensure semaphore is None (not pre-created)
+        module._llm_semaphore = None
+
+        async def use_semaphore():
+            # Semaphore should be created here, inside the running loop
+            semaphore = get_llm_semaphore()
+            async with semaphore:
+                return True
+
+        # This should work because semaphore is created in the correct loop
+        result = asyncio.run(use_semaphore())
+        assert result is True
+
+    def test_set_llm_concurrency_does_not_create_semaphore(self):
+        """Test that set_llm_concurrency only stores limit, doesn't create semaphore.
+
+        This is the key fix - the semaphore should be created lazily inside
+        the running event loop, not when set_llm_concurrency is called.
+        """
+        import uipath.platform.chat.llm_throttle as module
+
+        # Ensure semaphore is None initially
+        module._llm_semaphore = None
+
+        # Call set_llm_concurrency
+        set_llm_concurrency(5)
+
+        # Verify semaphore is still None (not created yet)
+        assert module._llm_semaphore is None
+
+        # Verify limit was stored
+        assert module._llm_concurrency_limit == 5
+
+        # Now when we get the semaphore, it should be created with the stored limit
+        async def get_sem():
+            return get_llm_semaphore()
+
+        semaphore = asyncio.run(get_sem())
+        assert semaphore._value == 5
+
+
+class TestMultipleEventLoops:
+    """Tests for semaphore behavior across multiple event loops.
+
+    This tests the scenario where:
+    1. First asyncio.run() creates semaphore bound to loop A
+    2. Loop A closes
+    3. Second asyncio.run() creates loop B
+    4. Code tries to use semaphore still bound to dead loop A
+    5. Should NOT crash - semaphore should be recreated for loop B
+    """
+
+    @pytest.fixture(autouse=True)
+    def reset_semaphore(self):
+        """Reset the global semaphore before each test."""
+        import uipath.platform.chat.llm_throttle as module
+
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+        yield
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+
+    def test_semaphore_works_across_multiple_asyncio_runs(self):
+        """Test that semaphore works correctly across multiple asyncio.run() calls.
+
+        This is the key test for the event-loop binding bug. Without the fix,
+        this test will fail with:
+        RuntimeError: Semaphore object is bound to a different event loop
+
+        NOTE: The bug only triggers when there's CONTENTION on the semaphore
+        (multiple tasks competing). Without contention, _get_loop() is not
+        called and the semaphore doesn't bind to the event loop.
+        """
+        # Use a limit of 1 to force contention
+        set_llm_concurrency(1)
+
+        async def use_semaphore_with_contention():
+            """Use the semaphore with contention to trigger loop binding."""
+            semaphore = get_llm_semaphore()
+
+            async def contender():
+                async with semaphore:
+                    await asyncio.sleep(0.001)
+
+            # Hold the semaphore while another task tries to acquire it
+            async with semaphore:
+                # Create a contending task - this forces _get_loop() to be called
+                task = asyncio.create_task(contender())
+                await asyncio.sleep(0.001)
+
+            await task
+            return True
+
+        # First run - creates semaphore and binds to loop A due to contention
+        result1 = asyncio.run(use_semaphore_with_contention())
+        assert result1 is True
+
+        # Second run - loop A is closed, loop B is created
+        # Without fix: crashes because semaphore is still bound to loop A
+        # With fix: should work because semaphore is recreated for loop B
+        result2 = asyncio.run(use_semaphore_with_contention())
+        assert result2 is True
+
+        # Third run - just to be sure
+        result3 = asyncio.run(use_semaphore_with_contention())
+        assert result3 is True
+
+    def test_semaphore_limit_preserved_across_loops(self):
+        """Test that concurrency limit is preserved when semaphore is recreated."""
+        set_llm_concurrency(3)
+
+        async def get_semaphore_value():
+            semaphore = get_llm_semaphore()
+            return semaphore._value
+
+        # First run
+        value1 = asyncio.run(get_semaphore_value())
+        assert value1 == 3
+
+        # Second run - should still have limit of 3
+        value2 = asyncio.run(get_semaphore_value())
+        assert value2 == 3
+
+
+class TestConcurrencyValidation:
+    """Tests for input validation of concurrency settings."""
+
+    @pytest.fixture(autouse=True)
+    def reset_semaphore(self):
+        """Reset the global semaphore before each test."""
+        import uipath.platform.chat.llm_throttle as module
+
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+        yield
+        module._llm_semaphore = None
+        module._llm_semaphore_loop = None
+        module._llm_concurrency_limit = module.DEFAULT_LLM_CONCURRENCY
+
+    def test_set_llm_concurrency_zero_raises_error(self):
+        """Test that setting concurrency to 0 raises ValueError.
+
+        A semaphore with value 0 would deadlock all requests.
+        """
+        with pytest.raises(ValueError, match="must be at least 1"):
+            set_llm_concurrency(0)
+
+    def test_set_llm_concurrency_negative_raises_error(self):
+        """Test that setting negative concurrency raises ValueError."""
+        with pytest.raises(ValueError, match="must be at least 1"):
+            set_llm_concurrency(-1)
+
+    def test_set_llm_concurrency_one_is_valid(self):
+        """Test that setting concurrency to 1 (minimum valid) works."""
+        set_llm_concurrency(1)
+
+        async def check_semaphore():
+            semaphore = get_llm_semaphore()
+            return semaphore._value
+
+        value = asyncio.run(check_semaphore())
+        assert value == 1
diff --git a/packages/uipath-platform/tests/services/test_llm_trace_context.py b/packages/uipath-platform/tests/services/test_llm_trace_context.py
new file mode 100644
index 000000000..2b078cd62
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_llm_trace_context.py
@@ -0,0 +1,222 @@
+"""Tests for build_trace_context_headers."""
+
+import os
+from unittest.mock import patch
+
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
+from uipath.core.feature_flags import FeatureFlags
+
+from uipath.platform.chat.llm_trace_context import build_trace_context_headers
+from uipath.platform.common.constants import ENV_PROJECT_KEY
+
+FEATURE_FLAG = "EnableTraceContextHeaders"
+
+
+def _make_span():
+    """Create a real OTEL span for testing."""
+    provider = TracerProvider()
+    tracer = provider.get_tracer("test")
+    return tracer.start_span("test-span")
+
+
+class TestFeatureFlagDisabled:
+    """When the feature flag is off, no headers are returned."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+
+    def test_returns_empty_dict_by_default(self) -> None:
+        assert build_trace_context_headers() == {}
+
+    def test_returns_empty_dict_when_explicitly_disabled(self) -> None:
+        FeatureFlags.configure_flags({FEATURE_FLAG: False})
+        assert build_trace_context_headers() == {}
+
+
+class TestTraceparentHeader:
+    """When enabled, x-uipath-traceparent-id is populated from config + span."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+        FeatureFlags.configure_flags({FEATURE_FLAG: True})
+
+    def test_traceparent_from_config_and_span(self) -> None:
+        span = _make_span()
+        ctx = span.get_span_context()
+        expected_span_id = format(ctx.span_id, "032x")
+        config_trace = "abcdef1234567890abcdef1234567890"
+        env = {"UIPATH_TRACE_ID": config_trace}
+        with (
+            patch.dict(os.environ, env),
+            patch(
+                "uipath.platform.chat.llm_trace_context.trace.get_current_span",
+                return_value=span,
+            ),
+        ):
+            headers = build_trace_context_headers()
+
+        assert "x-uipath-traceparent-id" in headers
+        value = headers["x-uipath-traceparent-id"]
+        assert value == f"00-{config_trace}-{expected_span_id}"
+        parts = value.split("-")
+        assert len(parts) == 3
+        assert parts[0] == "00"
+        assert len(parts[1]) == 32
+        assert len(parts[2]) == 32
+
+    def test_no_traceparent_without_config_trace_id(self) -> None:
+        headers = build_trace_context_headers()
+        assert "x-uipath-traceparent-id" not in headers
+
+    def test_traceparent_strips_dashes_from_config_trace_id(self) -> None:
+        span = _make_span()
+        uuid_trace = "abcdef12-3456-7890-abcd-ef1234567890"
+        env = {"UIPATH_TRACE_ID": uuid_trace}
+        with (
+            patch.dict(os.environ, env),
+            patch(
+                "uipath.platform.chat.llm_trace_context.trace.get_current_span",
+                return_value=span,
+            ),
+        ):
+            headers = build_trace_context_headers()
+
+        value = headers["x-uipath-traceparent-id"]
+        parts = value.split("-")
+        assert parts[1] == "abcdef1234567890abcdef1234567890"
+
+    def test_no_traceparent_with_invalid_span(self) -> None:
+        ctx = SpanContext(
+            trace_id=0,
+            span_id=0,
+            is_remote=False,
+            trace_flags=TraceFlags(0),
+        )
+        span = NonRecordingSpan(ctx)
+        env = {"UIPATH_TRACE_ID": "abcdef1234567890abcdef1234567890"}
+        with (
+            patch.dict(os.environ, env),
+            patch(
+                "uipath.platform.chat.llm_trace_context.trace.get_current_span",
+                return_value=span,
+            ),
+        ):
+            headers = build_trace_context_headers()
+
+        assert "x-uipath-traceparent-id" not in headers
+
+
+class TestBaggageHeader:
+    """When enabled, x-uipath-tracebaggage is populated from UiPathConfig."""
+
+    def setup_method(self) -> None:
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+        FeatureFlags.reset_flags()
+        FeatureFlags.configure_flags({FEATURE_FLAG: True})
+
+    def test_all_env_vars_present(self) -> None:
+        env = {
+            "UIPATH_FOLDER_KEY": "folder-abc",
+            ENV_PROJECT_KEY: "agent-123",
+            "UIPATH_PROCESS_KEY": "process-789",
+        }
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers()
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert "folderKey=folder-abc" in baggage
+        assert "agentId=agent-123" in baggage
+        assert "processKey=process-789" in baggage
+
+    def test_partial_env_vars(self) -> None:
+        env = {"UIPATH_FOLDER_KEY": "folder-only"}
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers()
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert "folderKey=folder-only" in baggage
+
+    def test_agent_id_from_project_key_env(self) -> None:
+        env = {ENV_PROJECT_KEY: "real-agent-id"}
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers()
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert "agentId=real-agent-id" in baggage
+
+    def test_no_agent_id_without_env_vars(self) -> None:
+        env = {"UIPATH_FOLDER_KEY": "f1"}
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers()
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert "agentId" not in baggage
+        assert "folderKey=f1" in baggage
+
+    def test_no_baggage_without_env_vars(self) -> None:
+        with patch.dict(os.environ, {}, clear=True):
+            headers = build_trace_context_headers()
+
+        assert "x-uipath-tracebaggage" not in headers
+
+    def test_baggage_comma_separated(self) -> None:
+        env = {
+            "UIPATH_FOLDER_KEY": "f1",
+            ENV_PROJECT_KEY: "a1",
+        }
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers()
+
+        baggage = headers["x-uipath-tracebaggage"]
+        parts = baggage.split(",")
+        assert len(parts) == 2  # folderKey + agentId
+
+    def test_extra_baggage_included(self) -> None:
+        env = {"UIPATH_FOLDER_KEY": "f1"}
+        with patch.dict(os.environ, env, clear=True):
+            headers = build_trace_context_headers(extra_baggage=["source=agents"])
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert "source=agents" in baggage
+        assert "folderKey=f1" in baggage
+
+    def test_extra_baggage_only(self) -> None:
+        with patch.dict(os.environ, {}, clear=True):
+            headers = build_trace_context_headers(
+                extra_baggage=["source=agents", "custom=value"]
+            )
+
+        baggage = headers["x-uipath-tracebaggage"]
+        assert baggage == "source=agents,custom=value"
+
+
+class TestBothHeaders:
+    """When enabled with an active span and env vars, both headers are present."""
+
+    def setup_method(self) -> None:
+        FeatureFlags.reset_flags()
+        FeatureFlags.configure_flags({FEATURE_FLAG: True})
+
+    def test_both_headers_present(self) -> None:
+        span = _make_span()
+        env = {
+            "UIPATH_FOLDER_KEY": "folder-abc",
+            "UIPATH_TRACE_ID": "abcdef1234567890abcdef1234567890",
+        }
+        with (
+            patch.dict(os.environ, env, clear=True),
+            patch(
+                "uipath.platform.chat.llm_trace_context.trace.get_current_span",
+                return_value=span,
+            ),
+        ):
+            headers = build_trace_context_headers()
+
+        assert "x-uipath-traceparent-id" in headers
+        assert headers["x-uipath-traceparent-id"].startswith(
+            "00-abcdef1234567890abcdef1234567890-"
+        )
+        assert "x-uipath-tracebaggage" in headers
diff --git a/packages/uipath-platform/tests/services/test_mcp_service.py b/packages/uipath-platform/tests/services/test_mcp_service.py
new file mode 100644
index 000000000..fdc5d8ee1
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_mcp_service.py
@@ -0,0 +1,553 @@
+from unittest.mock import Mock, patch
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_FOLDER_KEY, HEADER_USER_AGENT
+from uipath.platform.orchestrator import McpService
+from uipath.platform.orchestrator._folder_service import FolderService
+from uipath.platform.orchestrator.mcp import McpServer
+
+
+@pytest.fixture
+def folders_service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> FolderService:
+    monkeypatch.setenv("UIPATH_FOLDER_KEY", "test-folder-key")
+    return FolderService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    folders_service: FolderService,
+    monkeypatch: pytest.MonkeyPatch,
+) -> McpService:
+    monkeypatch.setenv("UIPATH_FOLDER_KEY", "test-folder-key")
+    return McpService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folders_service,
+    )
+
+
+class TestMcpService:
+    class TestListServers:
+        def test_list_with_folder_path(
+            self,
+            httpx_mock: HTTPXMock,
+            service: McpService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test listing MCP servers with a folder_path parameter that gets resolved."""
+            mock_servers = [
+                {
+                    "id": "server-id-1",
+                    "name": "Test MCP Server",
+                    "slug": "test-mcp-server",
+                    "description": "Test description",
+                    "version": "1.0.0",
+                    "createdAt": "2025-07-24T11:30:52.031427",
+                    "updatedAt": "2025-07-24T12:29:53.4765887",
+                    "isActive": True,
+                    "type": 2,
+                    "status": 1,
+                    "command": "",
+                    "arguments": "",
+                    "environmentVariables": "",
+                    "processKey": "test-process-key",
+                    "folderKey": "test-folder-key",
+                    "runtimesCount": 0,
+                    "mcpUrl": "https://test.com/mcp/test-mcp-server",
+                }
+            ]
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+                status_code=200,
+                json={
+                    "PageItems": [
+                        {
+                            "Key": "resolved-folder-key",
+                            "FullyQualifiedName": "test-folder-path",
+                        }
+                    ],
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/servers",
+                status_code=200,
+                json=mock_servers,
+            )
+
+            servers = service.list(folder_path="test-folder-path")
+
+            assert len(servers) == 1
+            assert isinstance(servers[0], McpServer)
+            assert servers[0].name == "Test MCP Server"
+
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 2
+
+            servers_request = requests[1]
+            assert servers_request.method == "GET"
+            assert (
+                servers_request.url == f"{base_url}{org}{tenant}/agenthub_/api/servers"
+            )
+            assert HEADER_FOLDER_KEY in servers_request.headers
+            assert servers_request.headers[HEADER_FOLDER_KEY] == "resolved-folder-key"
+
+        def test_list_without_folder_path_falls_back_to_folder_key(
+            self,
+            httpx_mock: HTTPXMock,
+            config: UiPathApiConfig,
+            execution_context: UiPathExecutionContext,
+            base_url: str,
+            org: str,
+            tenant: str,
+            monkeypatch: pytest.MonkeyPatch,
+        ) -> None:
+            """Test that listing servers without folder_path falls back to folder_key from FolderContext."""
+            monkeypatch.setenv("UIPATH_FOLDER_KEY", "fallback-folder-key")
+            monkeypatch.delenv("UIPATH_FOLDER_PATH", raising=False)
+
+            folders_service = FolderService(
+                config=config, execution_context=execution_context
+            )
+            service = McpService(
+                config=config,
+                execution_context=execution_context,
+                folders_service=folders_service,
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/servers",
+                status_code=200,
+                json=[],
+            )
+
+            servers = service.list()
+
+            assert servers == []
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 1
+            assert HEADER_FOLDER_KEY in requests[0].headers
+            assert requests[0].headers[HEADER_FOLDER_KEY] == "fallback-folder-key"
+
+        @pytest.mark.anyio
+        async def test_list_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: McpService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test asynchronously listing MCP servers."""
+            mock_servers = [
+                {
+                    "id": "server-id-1",
+                    "name": "Async Test Server",
+                    "slug": "async-test-server",
+                    "description": "Async test description",
+                    "version": "1.0.0",
+                    "createdAt": "2025-07-24T11:30:52.031427",
+                    "updatedAt": "2025-07-24T12:29:53.4765887",
+                    "isActive": True,
+                    "type": 2,
+                    "status": 1,
+                    "command": "",
+                    "arguments": "",
+                    "environmentVariables": "",
+                    "processKey": "test-process-key",
+                    "folderKey": "test-folder-key",
+                    "runtimesCount": 0,
+                    "mcpUrl": "https://test.com/mcp/async-test-server",
+                }
+            ]
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+                status_code=200,
+                json={
+                    "PageItems": [
+                        {
+                            "Key": "test-folder-key",
+                            "FullyQualifiedName": "test-folder-path",
+                        }
+                    ],
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/servers",
+                status_code=200,
+                json=mock_servers,
+            )
+
+            servers = await service.list_async(folder_path="test-folder-path")
+
+            assert len(servers) == 1
+            assert isinstance(servers[0], McpServer)
+            assert servers[0].name == "Async Test Server"
+
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 2
+
+            servers_request = requests[1]
+            assert servers_request.method == "GET"
+            assert (
+                servers_request.url == f"{base_url}{org}{tenant}/agenthub_/api/servers"
+            )
+            assert HEADER_FOLDER_KEY in servers_request.headers
+            assert servers_request.headers[HEADER_FOLDER_KEY] == "test-folder-key"
+            assert HEADER_USER_AGENT in servers_request.headers
+            assert (
+                servers_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.McpService.list_async/{version}"
+            )
+
+    class TestRetrieveServer:
+        def test_retrieve_server_with_folder_path(
+            self,
+            httpx_mock: HTTPXMock,
+            service: McpService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test retrieving a specific MCP server by slug with folder_path."""
+            mock_server = {
+                "id": "server-id-1",
+                "name": "Test MCP Server",
+                "slug": "test-mcp-server",
+                "description": "A test server",
+                "version": "1.0.0",
+                "createdAt": "2025-07-24T11:30:52.031427",
+                "updatedAt": "2025-07-24T12:29:53.4765887",
+                "isActive": True,
+                "type": 2,
+                "status": 1,
+                "command": "",
+                "arguments": "",
+                "environmentVariables": "",
+                "processKey": "test-process-key",
+                "folderKey": "test-folder-key",
+                "runtimesCount": 0,
+                "mcpUrl": "https://test.com/mcp/test-mcp-server",
+            }
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+                status_code=200,
+                json={
+                    "PageItems": [
+                        {
+                            "Key": "test-folder-key",
+                            "FullyQualifiedName": "test-folder-path",
+                        }
+                    ],
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/servers/test-mcp-server",
+                status_code=200,
+                json=mock_server,
+            )
+
+            server = service.retrieve("test-mcp-server", folder_path="test-folder-path")
+
+            assert isinstance(server, McpServer)
+            assert server.name == "Test MCP Server"
+            assert server.slug == "test-mcp-server"
+
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 2
+
+            retrieve_request = requests[1]
+            assert retrieve_request.method == "GET"
+            assert (
+                retrieve_request.url
+                == f"{base_url}{org}{tenant}/agenthub_/api/servers/test-mcp-server"
+            )
+            assert HEADER_FOLDER_KEY in retrieve_request.headers
+            assert retrieve_request.headers[HEADER_FOLDER_KEY] == "test-folder-key"
+            assert HEADER_USER_AGENT in retrieve_request.headers
+            assert (
+                retrieve_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.McpService.retrieve/{version}"
+            )
+
+        @pytest.mark.anyio
+        async def test_retrieve_server_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: McpService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            """Test asynchronously retrieving a specific MCP server."""
+            mock_server = {
+                "id": "server-id-1",
+                "name": "Async Test Server",
+                "slug": "async-test-server",
+                "description": "Async test server",
+                "version": "1.0.0",
+                "createdAt": "2025-07-24T11:30:52.031427",
+                "updatedAt": "2025-07-24T12:29:53.4765887",
+                "isActive": True,
+                "type": 2,
+                "status": 1,
+                "command": "",
+                "arguments": "",
+                "environmentVariables": "",
+                "processKey": "test-process-key",
+                "folderKey": "test-folder-key",
+                "runtimesCount": 0,
+                "mcpUrl": "https://test.com/mcp/async-test-server",
+            }
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
+                status_code=200,
+                json={
+                    "PageItems": [
+                        {
+                            "Key": "test-folder-key",
+                            "FullyQualifiedName": "test-folder-path",
+                        }
+                    ],
+                },
+            )
+
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/agenthub_/api/servers/async-test-server",
+                status_code=200,
+                json=mock_server,
+            )
+
+            server = await service.retrieve_async(
+                "async-test-server", folder_path="test-folder-path"
+            )
+
+            assert isinstance(server, McpServer)
+            assert server.name == "Async Test Server"
+
+            requests = httpx_mock.get_requests()
+            assert len(requests) == 2
+
+            retrieve_request = requests[1]
+            assert retrieve_request.method == "GET"
+            assert (
+                retrieve_request.url
+                == f"{base_url}{org}{tenant}/agenthub_/api/servers/async-test-server"
+            )
+            assert HEADER_FOLDER_KEY in retrieve_request.headers
+            assert retrieve_request.headers[HEADER_FOLDER_KEY] == "test-folder-key"
+            assert HEADER_USER_AGENT in retrieve_request.headers
+            assert (
+                retrieve_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.McpService.retrieve_async/{version}"
+            )
+
+    class TestRequestKwargs:
+        """Test that all methods pass the correct kwargs to request/request_async."""
+
+        def test_list_passes_all_kwargs(self, service: McpService) -> None:
+            """Test that list passes all kwargs to request."""
+            mock_response = Mock()
+            mock_response.json.return_value = [
+                {
+                    "id": "test-id",
+                    "name": "Test Server",
+                    "slug": "test-server",
+                    "description": "Test",
+                    "version": "1.0.0",
+                    "createdAt": "2025-07-24T11:30:52.031427",
+                    "updatedAt": "2025-07-24T12:29:53.4765887",
+                    "isActive": True,
+                    "type": 2,
+                    "status": 1,
+                    "processKey": "test-process-key",
+                    "folderKey": "test-folder-key",
+                    "mcpUrl": "https://test.com/mcp/test",
+                }
+            ]
+
+            with patch.object(
+                service._folders_service,
+                "retrieve_folder_key",
+                return_value="test-folder-key",
+            ):
+                with patch.object(
+                    service, "request", return_value=mock_response
+                ) as mock_request:
+                    service.list(folder_path="test-folder-path")
+
+                    mock_request.assert_called_once()
+                    call_kwargs = mock_request.call_args
+
+                    assert "url" in call_kwargs.kwargs
+                    assert "params" in call_kwargs.kwargs
+                    assert "headers" in call_kwargs.kwargs
+
+                    assert call_kwargs.args[0] == "GET"
+
+                    assert HEADER_FOLDER_KEY in call_kwargs.kwargs["headers"]
+                    assert (
+                        call_kwargs.kwargs["headers"][HEADER_FOLDER_KEY]
+                        == "test-folder-key"
+                    )
+
+        @pytest.mark.anyio
+        async def test_list_async_passes_all_kwargs(self, service: McpService) -> None:
+            """Test that list_async passes all kwargs to request_async."""
+            mock_response = Mock()
+            mock_response.json.return_value = [
+                {
+                    "id": "test-id",
+                    "name": "Test Server",
+                    "slug": "test-server",
+                    "description": "Test",
+                    "version": "1.0.0",
+                    "createdAt": "2025-07-24T11:30:52.031427",
+                    "updatedAt": "2025-07-24T12:29:53.4765887",
+                    "isActive": True,
+                    "type": 2,
+                    "status": 1,
+                    "processKey": "test-process-key",
+                    "folderKey": "test-folder-key",
+                    "mcpUrl": "https://test.com/mcp/test",
+                }
+            ]
+
+            with patch.object(
+                service._folders_service,
+                "retrieve_folder_key",
+                return_value="test-folder-key",
+            ):
+                with patch.object(
+                    service, "request_async", return_value=mock_response
+                ) as mock_request:
+                    await service.list_async(folder_path="test-folder-path")
+
+                    mock_request.assert_called_once()
+                    call_kwargs = mock_request.call_args
+
+                    assert "url" in call_kwargs.kwargs
+                    assert "params" in call_kwargs.kwargs
+                    assert "headers" in call_kwargs.kwargs
+
+                    assert call_kwargs.args[0] == "GET"
+
+                    assert HEADER_FOLDER_KEY in call_kwargs.kwargs["headers"]
+                    assert (
+                        call_kwargs.kwargs["headers"][HEADER_FOLDER_KEY]
+                        == "test-folder-key"
+                    )
+
+        def test_retrieve_passes_all_kwargs(self, service: McpService) -> None:
+            """Test that retrieve passes all kwargs to request."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": "test-id",
+                "name": "Test Server",
+                "slug": "test-server",
+                "description": "Test",
+                "version": "1.0.0",
+                "createdAt": "2025-07-24T11:30:52.031427",
+                "updatedAt": "2025-07-24T12:29:53.4765887",
+                "isActive": True,
+                "type": 2,
+                "status": 1,
+                "processKey": "test-process-key",
+                "folderKey": "test-folder-key",
+                "mcpUrl": "https://test.com/mcp/test",
+            }
+
+            with patch.object(
+                service._folders_service,
+                "retrieve_folder_key",
+                return_value="test-folder-key",
+            ):
+                with patch.object(
+                    service, "request", return_value=mock_response
+                ) as mock_request:
+                    service.retrieve("test-server", folder_path="test-folder-path")
+
+                    mock_request.assert_called_once()
+                    call_kwargs = mock_request.call_args
+
+                    assert "url" in call_kwargs.kwargs
+                    assert "params" in call_kwargs.kwargs
+                    assert "headers" in call_kwargs.kwargs
+
+                    assert call_kwargs.args[0] == "GET"
+
+                    assert HEADER_FOLDER_KEY in call_kwargs.kwargs["headers"]
+                    assert (
+                        call_kwargs.kwargs["headers"][HEADER_FOLDER_KEY]
+                        == "test-folder-key"
+                    )
+
+        @pytest.mark.anyio
+        async def test_retrieve_async_passes_all_kwargs(
+            self, service: McpService
+        ) -> None:
+            """Test that retrieve_async passes all kwargs to request_async."""
+            mock_response = Mock()
+            mock_response.json.return_value = {
+                "id": "test-id",
+                "name": "Test Server",
+                "slug": "test-server",
+                "description": "Test",
+                "version": "1.0.0",
+                "createdAt": "2025-07-24T11:30:52.031427",
+                "updatedAt": "2025-07-24T12:29:53.4765887",
+                "isActive": True,
+                "type": 2,
+                "status": 1,
+                "processKey": "test-process-key",
+                "folderKey": "test-folder-key",
+                "mcpUrl": "https://test.com/mcp/test",
+            }
+
+            with patch.object(
+                service._folders_service,
+                "retrieve_folder_key",
+                return_value="test-folder-key",
+            ):
+                with patch.object(
+                    service, "request_async", return_value=mock_response
+                ) as mock_request:
+                    await service.retrieve_async(
+                        "test-server", folder_path="test-folder-path"
+                    )
+
+                    mock_request.assert_called_once()
+                    call_kwargs = mock_request.call_args
+
+                    assert "url" in call_kwargs.kwargs
+                    assert "params" in call_kwargs.kwargs
+                    assert "headers" in call_kwargs.kwargs
+
+                    assert call_kwargs.args[0] == "GET"
+
+                    assert HEADER_FOLDER_KEY in call_kwargs.kwargs["headers"]
+                    assert (
+                        call_kwargs.kwargs["headers"][HEADER_FOLDER_KEY]
+                        == "test-folder-key"
+                    )
diff --git a/packages/uipath-platform/tests/services/test_memory_service.py b/packages/uipath-platform/tests/services/test_memory_service.py
new file mode 100644
index 000000000..716e3438c
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_memory_service.py
@@ -0,0 +1,504 @@
+"""Unit tests for MemoryService with HTTP mocking."""
+
+import json
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.memory import (
+    EscalationMemoryIngestRequest,
+    EscalationMemorySearchResponse,
+    MemoryMatch,
+    MemoryMatchField,
+    MemorySearchRequest,
+    MemorySearchResponse,
+    MemorySpace,
+    MemorySpaceListResponse,
+    SearchField,
+    SearchMode,
+    SearchSettings,
+)
+from uipath.platform.memory._memory_service import MemoryService
+from uipath.platform.orchestrator._folder_service import FolderService
+
+
+@pytest.fixture
+def folder_service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+) -> FolderService:
+    return FolderService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    folder_service: FolderService,
+    monkeypatch: pytest.MonkeyPatch,
+) -> MemoryService:
+    monkeypatch.setenv("UIPATH_FOLDER_KEY", "test-folder-key")
+    return MemoryService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folder_service,
+    )
+
+
+# ── Sample response payloads ──────────────────────────────────────────
+
+SAMPLE_INDEX = {
+    "id": "aaaa-bbbb-cccc-dddd",
+    "name": "test-memory-space",
+    "description": "A test memory space",
+    "lastQueried": "2026-03-30T00:00:00Z",
+    "memoriesCount": 5,
+    "folderKey": "test-folder-key",
+    "createdByUserId": "user-123",
+    "isEncrypted": False,
+}
+
+SAMPLE_LIST_RESPONSE = {"value": [SAMPLE_INDEX]}
+
+SAMPLE_SEARCH_RESPONSE = {
+    "results": [
+        {
+            "memoryItemId": "item-001",
+            "score": 0.95,
+            "semanticScore": 0.92,
+            "weightedScore": 0.93,
+            "fields": [
+                {
+                    "keyPath": ["input"],
+                    "value": "What is the capital of France?",
+                    "weight": 1.0,
+                    "score": 0.95,
+                    "weightedScore": 0.95,
+                }
+            ],
+            "span": None,
+            "feedback": None,
+        }
+    ],
+    "metadata": {"queryTime": "12ms"},
+    "systemPromptInjection": "Based on past interactions: Paris is the capital.",
+}
+
+SAMPLE_ESCALATION_SEARCH_RESPONSE = {
+    "results": [
+        {
+            "answer": {
+                "output": {"action": "approve", "reason": "meets criteria"},
+                "outcome": "approved",
+            }
+        }
+    ],
+}
+
+
+class TestMemoryService:
+    """Unit tests for MemoryService."""
+
+    class TestCreate:
+        def test_create_memory_space(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories/create",
+                status_code=200,
+                json=SAMPLE_INDEX,
+            )
+
+            result = service.create(
+                name="test-memory-space",
+                description="A test memory space",
+            )
+
+            assert isinstance(result, MemorySpace)
+            assert result.id == "aaaa-bbbb-cccc-dddd"
+            assert result.name == "test-memory-space"
+            assert result.memories_count == 5
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.method == "POST"
+            body = json.loads(sent.content)
+            assert body["name"] == "test-memory-space"
+            assert body["description"] == "A test memory space"
+
+        def test_create_sends_folder_header(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories/create",
+                status_code=200,
+                json=SAMPLE_INDEX,
+            )
+
+            service.create(name="test", folder_key="custom-folder-key")
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.headers.get("x-uipath-folderkey") == "custom-folder-key"
+
+        def test_create_with_encryption(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories/create",
+                status_code=200,
+                json={**SAMPLE_INDEX, "isEncrypted": True},
+            )
+
+            result = service.create(
+                name="encrypted-space",
+                is_encrypted=True,
+            )
+
+            assert result.is_encrypted is True
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            body = json.loads(sent.content)
+            assert body["isEncrypted"] is True
+
+    class TestList:
+        def test_list_memory_spaces(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories",
+                status_code=200,
+                json=SAMPLE_LIST_RESPONSE,
+            )
+
+            result = service.list()
+
+            assert isinstance(result, MemorySpaceListResponse)
+            assert len(result.value) == 1
+            assert result.value[0].name == "test-memory-space"
+
+        def test_list_with_odata_params(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories?%24filter=Name+eq+%27test%27&%24orderby=Name+asc&%24top=10&%24skip=5",
+                status_code=200,
+                json=SAMPLE_LIST_RESPONSE,
+            )
+
+            result = service.list(
+                filter="Name eq 'test'",
+                orderby="Name asc",
+                top=10,
+                skip=5,
+            )
+
+            assert isinstance(result, MemorySpaceListResponse)
+
+        def test_list_empty(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/ecs_/v2/episodicmemories",
+                status_code=200,
+                json={"value": []},
+            )
+
+            result = service.list()
+
+            assert isinstance(result, MemorySpaceListResponse)
+            assert len(result.value) == 0
+
+    class TestSearch:
+        def test_search_memory(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/search",
+                status_code=200,
+                json=SAMPLE_SEARCH_RESPONSE,
+            )
+
+            request = MemorySearchRequest(
+                fields=[
+                    SearchField(
+                        key_path=["input"],
+                        value="What is the capital of France?",
+                    )
+                ],
+                settings=SearchSettings(
+                    threshold=0.0,
+                    result_count=5,
+                    search_mode=SearchMode.Hybrid,
+                ),
+                definition_system_prompt="You are a helpful assistant.",
+            )
+
+            result = service.search(
+                memory_space_id=memory_space_id,
+                request=request,
+            )
+
+            assert isinstance(result, MemorySearchResponse)
+            assert len(result.results) == 1
+            assert isinstance(result.results[0], MemoryMatch)
+            assert result.results[0].memory_item_id == "item-001"
+            assert result.results[0].score == 0.95
+            assert isinstance(result.results[0].fields[0], MemoryMatchField)
+            assert (
+                result.system_prompt_injection
+                == "Based on past interactions: Paris is the capital."
+            )
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.method == "POST"
+            body = json.loads(sent.content)
+            assert body["fields"][0]["keyPath"] == ["input"]
+            assert body["settings"]["searchMode"] == "Hybrid"
+            assert body["definitionSystemPrompt"] == "You are a helpful assistant."
+
+        def test_search_sends_folder_header(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/search",
+                status_code=200,
+                json=SAMPLE_SEARCH_RESPONSE,
+            )
+
+            request = MemorySearchRequest(
+                fields=[SearchField(key_path=["input"], value="test")],
+                settings=SearchSettings(
+                    threshold=0.0,
+                    result_count=1,
+                    search_mode=SearchMode.Semantic,
+                ),
+            )
+
+            service.search(
+                memory_space_id=memory_space_id,
+                request=request,
+                folder_key="custom-folder",
+            )
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.headers.get("x-uipath-folderkey") == "custom-folder"
+
+    class TestEscalationSearch:
+        def test_escalation_search(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/escalation/search",
+                status_code=200,
+                json=SAMPLE_ESCALATION_SEARCH_RESPONSE,
+            )
+
+            request = MemorySearchRequest(
+                fields=[SearchField(key_path=["input"], value="approval request")],
+                settings=SearchSettings(
+                    threshold=0.0,
+                    result_count=5,
+                    search_mode=SearchMode.Hybrid,
+                ),
+            )
+
+            result = service.escalation_search(
+                memory_space_id=memory_space_id,
+                request=request,
+            )
+
+            assert isinstance(result, EscalationMemorySearchResponse)
+            assert result.results is not None
+            assert len(result.results) == 1
+            assert result.results[0].answer is not None
+            assert result.results[0].answer.outcome == "approved"
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.method == "POST"
+            assert "/escalation/search" in str(sent.url)
+
+        def test_escalation_search_empty_results(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/escalation/search",
+                status_code=200,
+                json={"results": None},
+            )
+
+            request = MemorySearchRequest(
+                fields=[SearchField(key_path=["input"], value="no match")],
+                settings=SearchSettings(
+                    threshold=0.0,
+                    result_count=1,
+                    search_mode=SearchMode.Hybrid,
+                ),
+            )
+
+            result = service.escalation_search(
+                memory_space_id=memory_space_id,
+                request=request,
+            )
+
+            assert isinstance(result, EscalationMemorySearchResponse)
+            assert result.results is None
+
+    class TestEscalationIngest:
+        def test_escalation_ingest(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/escalation/ingest",
+                status_code=200,
+            )
+
+            request = EscalationMemoryIngestRequest(
+                span_id="span-123",
+                trace_id="trace-456",
+                answer='{"action": "approve"}',
+                attributes='{"input": "approve this?"}',
+                user_id="user-789",
+            )
+
+            service.escalation_ingest(
+                memory_space_id=memory_space_id,
+                request=request,
+            )
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.method == "POST"
+            assert "/escalation/ingest" in str(sent.url)
+            body = json.loads(sent.content)
+            assert body["spanId"] == "span-123"
+            assert body["traceId"] == "trace-456"
+            assert body["answer"] == '{"action": "approve"}'
+            assert body["attributes"] == '{"input": "approve this?"}'
+            assert body["userId"] == "user-789"
+
+        def test_escalation_ingest_sends_folder_header(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/escalation/ingest",
+                status_code=200,
+            )
+
+            request = EscalationMemoryIngestRequest(
+                span_id="s1",
+                trace_id="t1",
+                answer="yes",
+                attributes="{}",
+            )
+
+            service.escalation_ingest(
+                memory_space_id=memory_space_id,
+                request=request,
+                folder_key="my-folder",
+            )
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            assert sent.headers.get("x-uipath-folderkey") == "my-folder"
+
+        def test_escalation_ingest_excludes_none_user_id(
+            self,
+            httpx_mock: HTTPXMock,
+            service: MemoryService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            memory_space_id = "aaaa-bbbb-cccc-dddd"
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/Agent/memory/{memory_space_id}/escalation/ingest",
+                status_code=200,
+            )
+
+            request = EscalationMemoryIngestRequest(
+                span_id="s1",
+                trace_id="t1",
+                answer="yes",
+                attributes="{}",
+            )
+
+            service.escalation_ingest(
+                memory_space_id=memory_space_id,
+                request=request,
+            )
+
+            sent = httpx_mock.get_request()
+            assert sent is not None
+            body = json.loads(sent.content)
+            assert "userId" not in body
diff --git a/packages/uipath-platform/tests/services/test_memory_service_e2e.py b/packages/uipath-platform/tests/services/test_memory_service_e2e.py
new file mode 100644
index 000000000..6c7866611
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_memory_service_e2e.py
@@ -0,0 +1,164 @@
+"""E2E tests for MemoryService against real ECS + LLMOps endpoints.
+
+Prerequisites:
+    uipath auth --alpha          # sets UIPATH_URL + UIPATH_ACCESS_TOKEN
+    export UIPATH_FOLDER_KEY=... # folder GUID with agent memory enabled
+
+Run:
+    cd packages/uipath-platform
+    uv run pytest tests/services/test_memory_service_e2e.py -m e2e -v
+"""
+
+import os
+import uuid
+
+import pytest
+
+from uipath.platform import UiPath
+from uipath.platform.memory import (
+    EscalationMemorySearchResponse,
+    MemorySearchRequest,
+    MemorySearchResponse,
+    MemorySpace,
+    MemorySpaceListResponse,
+    SearchField,
+    SearchMode,
+    SearchSettings,
+)
+
+pytestmark = pytest.mark.e2e
+
+
+def _require_env(name: str) -> str:
+    value = os.environ.get(name)
+    if not value:
+        pytest.skip(f"Environment variable {name} is not set")
+    return value
+
+
+@pytest.fixture(scope="module")
+def sdk() -> UiPath:
+    """Create a real UiPath client from env vars.
+
+    Supports two auth modes:
+    - Token-based: UIPATH_URL + UIPATH_ACCESS_TOKEN (from `uipath auth`)
+    - Client credentials: UIPATH_URL + UIPATH_CLIENT_ID + UIPATH_CLIENT_SECRET (CI)
+    """
+    _require_env("UIPATH_URL")
+    client_id = os.environ.get("UIPATH_CLIENT_ID")
+    client_secret = os.environ.get("UIPATH_CLIENT_SECRET")
+    if client_id and client_secret:
+        return UiPath(client_id=client_id, client_secret=client_secret)
+    _require_env("UIPATH_ACCESS_TOKEN")
+    return UiPath()
+
+
+@pytest.fixture(scope="module")
+def folder_key() -> str:
+    return _require_env("UIPATH_FOLDER_KEY")
+
+
+@pytest.fixture(scope="module")
+def memory_index(sdk: UiPath, folder_key: str):  # noqa: ANN201
+    """Create a test memory index and clean it up after all tests."""
+    unique_name = f"sdk-e2e-test-{uuid.uuid4().hex[:8]}"
+    index = sdk.memory.create(
+        name=unique_name,
+        description="Created by E2E test — safe to delete",
+        folder_key=folder_key,
+    )
+    yield index
+
+
+class TestMemoryServiceE2E:
+    """E2E tests for MemoryService lifecycle.
+
+    Requires: UIPATH_URL, UIPATH_ACCESS_TOKEN, UIPATH_FOLDER_KEY
+    """
+
+    # ── Index CRUD (ECS) ──────────────────────────────────────────
+
+    def test_create_index(self, memory_index: MemorySpace) -> None:
+        """Verify index creation returns a well-formed MemorySpace."""
+        assert memory_index.id, "Index ID should be set"
+        assert memory_index.name.startswith("sdk-e2e-test-")
+        assert memory_index.folder_key, "Folder key should be populated"
+        assert memory_index.memories_count == 0
+
+    def test_list_indexes(
+        self,
+        sdk: UiPath,
+        memory_index: MemorySpace,
+        folder_key: str,
+    ) -> None:
+        """Verify list with OData filter returns our index."""
+        result = sdk.memory.list(
+            filter=f"Name eq '{memory_index.name}'",
+            folder_key=folder_key,
+        )
+        assert isinstance(result, MemorySpaceListResponse)
+        names = [idx.name for idx in result.value]
+        assert memory_index.name in names
+
+    # ── Search (LLMOps) ──────────────────────────────────────────
+
+    def test_search_empty_index(
+        self,
+        sdk: UiPath,
+        memory_index: MemorySpace,
+        folder_key: str,
+    ) -> None:
+        """Search an empty index — should return empty results and systemPromptInjection."""
+        request = MemorySearchRequest(
+            fields=[
+                SearchField(
+                    key_path=["input"],
+                    value="test query",
+                )
+            ],
+            settings=SearchSettings(
+                threshold=0.0,
+                result_count=5,
+                search_mode=SearchMode.Hybrid,
+            ),
+            definition_system_prompt="You are a helpful assistant.",
+        )
+        result = sdk.memory.search(
+            memory_space_id=memory_index.id,
+            request=request,
+            folder_key=folder_key,
+        )
+        assert isinstance(result, MemorySearchResponse)
+        assert isinstance(result.results, list)
+        assert isinstance(result.metadata, dict)
+        assert isinstance(result.system_prompt_injection, str)
+
+    # ── Escalation search (LLMOps) ────────────────────────────────
+
+    def test_escalation_search_empty_index(
+        self,
+        sdk: UiPath,
+        memory_index: MemorySpace,
+        folder_key: str,
+    ) -> None:
+        """Search escalation memory on empty index — should return valid response."""
+        request = MemorySearchRequest(
+            fields=[
+                SearchField(
+                    key_path=["input"],
+                    value="test escalation query",
+                )
+            ],
+            settings=SearchSettings(
+                threshold=0.0,
+                result_count=5,
+                search_mode=SearchMode.Hybrid,
+            ),
+            definition_system_prompt="You are a helpful assistant.",
+        )
+        result = sdk.memory.escalation_search(
+            memory_space_id=memory_index.id,
+            request=request,
+            folder_key=folder_key,
+        )
+        assert isinstance(result, EscalationMemorySearchResponse)
diff --git a/packages/uipath-platform/tests/services/test_orchestrator_setup_service.py b/packages/uipath-platform/tests/services/test_orchestrator_setup_service.py
new file mode 100644
index 000000000..773971d15
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_orchestrator_setup_service.py
@@ -0,0 +1,100 @@
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.orchestrator import OrchestratorSetupService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+) -> OrchestratorSetupService:
+    return OrchestratorSetupService(config=config, execution_context=execution_context)
+
+
+class TestOrchestratorSetupServiceEnableFirstRun:
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_enable_first_run_success(
+        self,
+        httpx_mock: HTTPXMock,
+        service: OrchestratorSetupService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        use_async: bool,
+    ):
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/TryEnableFirstRun",
+            method="POST",
+            status_code=200,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/AcquireLicense",
+            method="POST",
+            status_code=200,
+        )
+
+        if use_async:
+            await service.enable_first_run_async()
+        else:
+            service.enable_first_run()
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 2
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_enable_first_run_error_does_not_raise(
+        self,
+        httpx_mock: HTTPXMock,
+        service: OrchestratorSetupService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        use_async: bool,
+    ):
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/TryEnableFirstRun",
+            method="POST",
+            status_code=400,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/AcquireLicense",
+            method="POST",
+            status_code=400,
+        )
+
+        if use_async:
+            await service.enable_first_run_async()
+        else:
+            service.enable_first_run()
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_enable_first_run_sends_bearer_token(
+        self,
+        httpx_mock: HTTPXMock,
+        service: OrchestratorSetupService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        secret: str,
+        use_async: bool,
+    ):
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/TryEnableFirstRun",
+            method="POST",
+            status_code=200,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/api/StudioWeb/AcquireLicense",
+            method="POST",
+            status_code=200,
+        )
+
+        if use_async:
+            await service.enable_first_run_async()
+        else:
+            service.enable_first_run()
+
+        for req in httpx_mock.get_requests():
+            assert req.headers["Authorization"] == f"Bearer {secret}"
diff --git a/packages/uipath-platform/tests/services/test_pii_detection_service.py b/packages/uipath-platform/tests/services/test_pii_detection_service.py
new file mode 100644
index 000000000..2bb424607
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_pii_detection_service.py
@@ -0,0 +1,264 @@
+"""Tests for PiiDetectionService."""
+
+import json
+from typing import Any
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.pii_detection import (
+    PiiDetectionRequest,
+    PiiDetectionResponse,
+    PiiDetectionService,
+    PiiDocument,
+    PiiEntityThreshold,
+    PiiFile,
+)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+) -> PiiDetectionService:
+    return PiiDetectionService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def sample_response_json() -> dict[str, Any]:
+    return {
+        "response": [
+            {
+                "id": "user-prompt",
+                "role": "user",
+                "maskedDocument": "Contact [Person-1]",
+                "initialDocument": "Contact Alison",
+                "piiEntities": [
+                    {
+                        "piiText": "Alison",
+                        "replacementText": "[Person-1]",
+                        "piiType": "Person",
+                        "offset": 8,
+                        "confidenceScore": 0.99,
+                    }
+                ],
+            }
+        ],
+        "files": [
+            {
+                "fileName": "doc.pdf",
+                "fileUrl": "https://blob.example.com/redacted/doc.pdf",
+                "piiEntities": [
+                    {
+                        "piiText": "alice@example.com",
+                        "replacementText": "[Email-1]",
+                        "piiType": "Email",
+                        "offset": 100,
+                        "confidenceScore": 0.88,
+                    }
+                ],
+            }
+        ],
+    }
+
+
+class TestPiiDetectionService:
+    """Test PiiDetectionService functionality."""
+
+    class TestDetectPii:
+        """Test detect_pii (sync)."""
+
+        def test_returns_typed_response(
+            self,
+            httpx_mock: HTTPXMock,
+            service: PiiDetectionService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/pii-detection",
+                status_code=200,
+                json=sample_response_json,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[
+                    PiiDocument(
+                        id="user-prompt", role="user", document="Contact Alison"
+                    )
+                ]
+            )
+            result = service.detect_pii(request)
+
+            assert isinstance(result, PiiDetectionResponse)
+            assert len(result.response) == 1
+            assert result.response[0].masked_document == "Contact [Person-1]"
+            assert len(result.files) == 1
+            assert result.files[0].file_name == "doc.pdf"
+            assert result.files[0].pii_entities[0].replacement_text == "[Email-1]"
+
+    class TestDetectPiiAsync:
+        """Test detect_pii_async."""
+
+        async def test_returns_typed_response(
+            self,
+            httpx_mock: HTTPXMock,
+            service: PiiDetectionService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/pii-detection",
+                status_code=200,
+                json=sample_response_json,
+            )
+
+            request = PiiDetectionRequest(
+                files=[
+                    PiiFile(
+                        file_name="doc.pdf",
+                        file_url="https://input.example.com/doc.pdf",
+                        file_type="pdf",
+                    )
+                ]
+            )
+            result = await service.detect_pii_async(request)
+
+            assert isinstance(result, PiiDetectionResponse)
+            assert (
+                result.files[0].file_url == "https://blob.example.com/redacted/doc.pdf"
+            )
+
+        async def test_request_payload_uses_aliases(
+            self,
+            httpx_mock: HTTPXMock,
+            service: PiiDetectionService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/pii-detection",
+                callback=capture,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[
+                    PiiDocument(id="user-prompt", role="user", document="Hello")
+                ],
+                files=[
+                    PiiFile(
+                        file_name="doc.pdf",
+                        file_url="https://input.example.com/doc.pdf",
+                        file_type="pdf",
+                    )
+                ],
+                language_code="en",
+                confidence_threshold=0.5,
+                entity_thresholds=[
+                    PiiEntityThreshold(category="Person", confidence_threshold=0.7),
+                ],
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            payload = json.loads(captured_request.content)
+
+            # Top-level uses camelCase aliases
+            assert "documents" in payload
+            assert "files" in payload
+            assert "languageCode" in payload
+            assert "confidenceThreshold" in payload
+            assert "entityThresholds" in payload
+
+            # File uses camelCase aliases
+            assert payload["files"][0]["fileName"] == "doc.pdf"
+            assert payload["files"][0]["fileUrl"] == "https://input.example.com/doc.pdf"
+            assert payload["files"][0]["fileType"] == "pdf"
+
+            # Entity threshold uses kebab-case aliases
+            threshold = payload["entityThresholds"][0]
+            assert threshold["pii-entity-category"] == "Person"
+            assert threshold["pii-entity-confidence-threshold"] == 0.7
+
+        async def test_request_excludes_none_fields(
+            self,
+            httpx_mock: HTTPXMock,
+            service: PiiDetectionService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/pii-detection",
+                callback=capture,
+            )
+
+            # Only documents set; other optional fields should be omitted
+            request = PiiDetectionRequest(
+                documents=[PiiDocument(id="user-prompt", role="user", document="Hello")]
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            payload = json.loads(captured_request.content)
+            assert "files" not in payload
+            assert "languageCode" not in payload
+            assert "confidenceThreshold" not in payload
+            assert "entityThresholds" not in payload
+
+        async def test_url_is_tenant_scoped(
+            self,
+            httpx_mock: HTTPXMock,
+            service: PiiDetectionService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/llmopstenant_/api/pii-detection",
+                callback=capture,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[PiiDocument(id="user-prompt", role="user", document="Hello")]
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            assert org.strip("/") in captured_request.url.path
+            assert tenant.strip("/") in captured_request.url.path
+            assert "/llmopstenant_/api/pii-detection" in captured_request.url.path
diff --git a/packages/uipath-platform/tests/services/test_pii_utilities.py b/packages/uipath-platform/tests/services/test_pii_utilities.py
new file mode 100644
index 000000000..751897609
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_pii_utilities.py
@@ -0,0 +1,179 @@
+"""Tests for PII rehydration utilities."""
+
+from uipath.platform.pii_detection import (
+    PiiDetectionResponse,
+    PiiDocumentResult,
+    PiiEntity,
+    PiiFileResult,
+    rehydrate_from_pii_entities,
+    rehydrate_from_pii_response,
+)
+
+
+def _entity(
+    pii_text: str,
+    replacement_text: str,
+    pii_type: str = "Person",
+    offset: int = 0,
+    confidence_score: float = 0.9,
+) -> PiiEntity:
+    return PiiEntity(
+        pii_text=pii_text,
+        replacement_text=replacement_text,
+        pii_type=pii_type,
+        offset=offset,
+        confidence_score=confidence_score,
+    )
+
+
+class TestRehydrateFromPiiEntities:
+    """Test rehydrate_from_pii_entities."""
+
+    def test_empty_text_returns_empty(self) -> None:
+        assert rehydrate_from_pii_entities("", [_entity("Alice", "[Person-1]")]) == ""
+
+    def test_no_entities_returns_text_unchanged(self) -> None:
+        text = "Hello [Person-1]"
+        assert rehydrate_from_pii_entities(text, []) == text
+
+    def test_replaces_single_placeholder(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "Hello [Person-1]", [_entity("Alice", "[Person-1]")]
+        )
+        assert result == "Hello Alice"
+
+    def test_replaces_multiple_placeholders(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "Contact [Person-1] at [Email-1]",
+            [
+                _entity("Alice", "[Person-1]"),
+                _entity("alice@example.com", "[Email-1]", pii_type="Email"),
+            ],
+        )
+        assert result == "Contact Alice at alice@example.com"
+
+    def test_longer_placeholders_replaced_first(self) -> None:
+        """[Person-10] must be rehydrated before [Person-1] to avoid partial match."""
+        result = rehydrate_from_pii_entities(
+            "[Person-1] and [Person-10]",
+            [
+                _entity("Alice", "[Person-1]"),
+                _entity("Zara", "[Person-10]"),
+            ],
+        )
+        assert result == "Alice and Zara"
+
+    def test_case_insensitive_placeholder_match(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "Hello [person-1]", [_entity("Alice", "[Person-1]")]
+        )
+        assert result == "Hello Alice"
+
+    def test_replaces_bracketless_variant(self) -> None:
+        """The LLM may drop brackets; bracketless variant should still be replaced."""
+        result = rehydrate_from_pii_entities(
+            "Hello Person-1", [_entity("Alice", "[Person-1]")]
+        )
+        assert result == "Hello Alice"
+
+    def test_skips_entities_with_empty_replacement_text(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "Hello [Person-1]",
+            [
+                _entity("Ignored", ""),
+                _entity("Alice", "[Person-1]"),
+            ],
+        )
+        assert result == "Hello Alice"
+
+    def test_skips_entities_with_empty_pii_text(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "Hello [Person-1]",
+            [_entity("", "[Person-1]")],
+        )
+        assert result == "Hello [Person-1]"
+
+    def test_preserves_non_placeholder_content(self) -> None:
+        result = rehydrate_from_pii_entities(
+            "The meeting with [Person-1] is at 3pm in the boardroom.",
+            [_entity("Alice", "[Person-1]")],
+        )
+        assert result == "The meeting with Alice is at 3pm in the boardroom."
+
+    def test_pii_text_with_special_characters(self) -> None:
+        """Special chars in PII text must not break regex substitution."""
+        result = rehydrate_from_pii_entities(
+            "Visit [URL-1]",
+            [_entity("https://example.com/path?q=1&x=2", "[URL-1]", pii_type="URL")],
+        )
+        assert result == "Visit https://example.com/path?q=1&x=2"
+
+    def test_regex_special_chars_in_replacement_text(self) -> None:
+        """Regex special chars in the placeholder must be escaped for the pattern."""
+        result = rehydrate_from_pii_entities(
+            "Hello [Person.1]",
+            [_entity("Alice", "[Person.1]")],
+        )
+        assert result == "Hello Alice"
+
+    def test_pii_text_inserted_verbatim_not_json_escaped(self) -> None:
+        """PII values are plain text: quotes, newlines and backslashes are
+        inserted as-is, never JSON-escaped."""
+        pii = 'Bob "The Boss"\nC:\\Users\\bob'
+        result = rehydrate_from_pii_entities(
+            "Name: [Person-1]", [_entity(pii, "[Person-1]")]
+        )
+        assert result == f"Name: {pii}"
+
+
+class TestRehydrateFromPiiResponse:
+    """Test rehydrate_from_pii_response."""
+
+    def test_merges_document_and_file_entities(self) -> None:
+        response = PiiDetectionResponse(
+            response=[
+                PiiDocumentResult(
+                    id="user-prompt",
+                    role="user",
+                    masked_document="Hi [Person-1]",
+                    initial_document="Hi Alice",
+                    pii_entities=[_entity("Alice", "[Person-1]")],
+                )
+            ],
+            files=[
+                PiiFileResult(
+                    file_name="doc.pdf",
+                    file_url="https://example.com/doc.pdf",
+                    pii_entities=[
+                        _entity("bob@example.com", "[Email-1]", pii_type="Email")
+                    ],
+                )
+            ],
+        )
+
+        result = rehydrate_from_pii_response(
+            "From [Person-1]: contact [Email-1]", response
+        )
+        assert result == "From Alice: contact bob@example.com"
+
+    def test_file_only_entity_is_rehydrated(self) -> None:
+        """Entities detected in files (not prompts) must also rehydrate."""
+        response = PiiDetectionResponse(
+            response=[],
+            files=[
+                PiiFileResult(
+                    file_name="doc.pdf",
+                    file_url="https://example.com/doc.pdf",
+                    pii_entities=[
+                        _entity("alice@example.com", "[Email-1]", pii_type="Email")
+                    ],
+                )
+            ],
+        )
+
+        result = rehydrate_from_pii_response("Email is [Email-1]", response)
+        assert result == "Email is alice@example.com"
+
+    def test_empty_response_returns_text_unchanged(self) -> None:
+        response = PiiDetectionResponse(response=[], files=[])
+        assert rehydrate_from_pii_response("No PII here", response) == "No PII here"
diff --git a/packages/uipath-platform/tests/services/test_portal_service.py b/packages/uipath-platform/tests/services/test_portal_service.py
new file mode 100644
index 000000000..f712a243b
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_portal_service.py
@@ -0,0 +1,107 @@
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform.portal import (
+    PortalService,
+    TenantsAndOrganizationInfoResponse,
+)
+
+SAMPLE_RESPONSE = {
+    "tenants": [
+        {"name": "TenantA", "id": "tenant-id-1"},
+        {"name": "TenantB", "id": "tenant-id-2"},
+    ],
+    "organization": {"id": "org-id-1", "name": "MyOrg"},
+}
+
+
+class TestPortalServiceGetTenantsAndOrganizations:
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_success(self, httpx_mock: HTTPXMock, use_async: bool):
+        domain = "https://cloud.uipath.com"
+        prt_id = "my-org"
+        access_token = "my-access-token"
+        url = f"{domain}/{prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+
+        httpx_mock.add_response(
+            url=url,
+            method="GET",
+            status_code=200,
+            json=SAMPLE_RESPONSE,
+        )
+
+        service = PortalService(domain)
+        if use_async:
+            result = await service.get_tenants_and_organizations_async(
+                prt_id=prt_id,
+                access_token=access_token,
+            )
+        else:
+            result = service.get_tenants_and_organizations(
+                prt_id=prt_id,
+                access_token=access_token,
+            )
+
+        assert isinstance(result, TenantsAndOrganizationInfoResponse)
+        assert len(result.tenants) == 2
+        assert result.tenants[0].name == "TenantA"
+        assert result.organization.name == "MyOrg"
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_401_raises(self, httpx_mock: HTTPXMock, use_async: bool):
+        domain = "https://cloud.uipath.com"
+        prt_id = "my-org"
+        url = f"{domain}/{prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+
+        httpx_mock.add_response(
+            url=url,
+            method="GET",
+            status_code=401,
+            json={"error": "Unauthorized"},
+        )
+
+        service = PortalService(domain)
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            if use_async:
+                await service.get_tenants_and_organizations_async(
+                    prt_id=prt_id,
+                    access_token="bad-token",
+                )
+            else:
+                service.get_tenants_and_organizations(
+                    prt_id=prt_id,
+                    access_token="bad-token",
+                )
+
+        assert exc_info.value.response.status_code == 401
+
+    @pytest.mark.parametrize("use_async", [False, True])
+    async def test_sends_bearer_token(self, httpx_mock: HTTPXMock, use_async: bool):
+        domain = "https://cloud.uipath.com"
+        prt_id = "my-org"
+        access_token = "secret-bearer-token"
+        url = f"{domain}/{prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+
+        httpx_mock.add_response(
+            url=url,
+            method="GET",
+            status_code=200,
+            json=SAMPLE_RESPONSE,
+        )
+
+        service = PortalService(domain)
+        if use_async:
+            await service.get_tenants_and_organizations_async(
+                prt_id=prt_id,
+                access_token=access_token,
+            )
+        else:
+            service.get_tenants_and_organizations(
+                prt_id=prt_id,
+                access_token=access_token,
+            )
+
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 1
+        assert requests[0].headers["Authorization"] == f"Bearer {access_token}"
diff --git a/packages/uipath-platform/tests/services/test_processes_service.py b/packages/uipath-platform/tests/services/test_processes_service.py
new file mode 100644
index 000000000..015888c54
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_processes_service.py
@@ -0,0 +1,570 @@
+import json
+import uuid
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_USER_AGENT
+from uipath.platform.orchestrator import Job
+from uipath.platform.orchestrator._attachments_service import AttachmentsService
+from uipath.platform.orchestrator._processes_service import ProcessesService
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> ProcessesService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    attachments_service = AttachmentsService(
+        config=config, execution_context=execution_context
+    )
+    return ProcessesService(
+        config=config,
+        execution_context=execution_context,
+        attachment_service=attachments_service,
+    )
+
+
+class TestProcessesService:
+    def test_invoke(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        input_arguments = {"key": "value"}
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = service.invoke(process_name, input_arguments)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+        assert sent_request.content.decode("utf-8") == json.dumps(
+            {
+                "startInfo": {
+                    "ReleaseName": process_name,
+                    "InputArguments": json.dumps(input_arguments),
+                    "Source": "AgentService",
+                }
+            },
+            separators=(",", ":"),
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke/{version}"
+        )
+
+    def test_invoke_without_input_arguments(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = service.invoke(process_name)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+        assert sent_request.content.decode("utf-8") == json.dumps(
+            {
+                "startInfo": {
+                    "ReleaseName": process_name,
+                    "InputArguments": "{}",
+                    "Source": "AgentService",
+                }
+            },
+            separators=(",", ":"),
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke/{version}"
+        )
+
+    def test_invoke_over_10k_limit_input(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        # Create input arguments that exceed 10k characters
+        large_text = "a" * 10001
+        input_arguments = {"large_text": large_text}
+
+        test_attachment_id = uuid.uuid4()
+        blob_uri = "https://test-storage.com/test-container/test-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments",
+            method="POST",
+            status_code=201,
+            json={
+                "Id": str(test_attachment_id),
+                "Name": "test-input.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["x-ms-blob-type", "Content-Type"],
+                        "Values": ["BlockBlob", "application/json"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="PUT",
+            status_code=201,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = service.invoke(process_name, input_arguments)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        # attachment creation, blob upload, job start
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 3
+
+        attachment_request = requests[0]
+        assert attachment_request.method == "POST"
+        assert "Attachments" in str(attachment_request.url)
+
+        blob_request = requests[1]
+        assert blob_request.method == "PUT"
+        assert blob_request.url == blob_uri
+
+        job_request = requests[2]
+        assert job_request.method == "POST"
+        assert (
+            job_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+
+        # verify InputFile is used
+        job_content = json.loads(job_request.content.decode("utf-8").replace("'", '"'))
+        assert "startInfo" in job_content
+        assert "ReleaseName" in job_content["startInfo"]
+        assert job_content["startInfo"]["ReleaseName"] == process_name
+        assert "InputFile" in job_content["startInfo"]
+        assert "InputArguments" not in job_content["startInfo"]
+        assert job_content["startInfo"]["InputFile"] == str(test_attachment_id)
+
+        assert HEADER_USER_AGENT in job_request.headers
+        assert (
+            job_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke/{version}"
+        )
+
+    @pytest.mark.asyncio
+    async def test_invoke_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        input_arguments = {"key": "value"}
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = await service.invoke_async(process_name, input_arguments)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+        assert sent_request.content.decode("utf-8") == json.dumps(
+            {
+                "startInfo": {
+                    "ReleaseName": process_name,
+                    "InputArguments": json.dumps(input_arguments),
+                    "Source": "AgentService",
+                }
+            },
+            separators=(",", ":"),
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke_async/{version}"
+        )
+
+    @pytest.mark.asyncio
+    async def test_invoke_async_without_input_arguments(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = await service.invoke_async(process_name)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+        assert sent_request.content.decode("utf-8") == json.dumps(
+            {
+                "startInfo": {
+                    "ReleaseName": process_name,
+                    "InputArguments": "{}",
+                    "Source": "AgentService",
+                }
+            },
+            separators=(",", ":"),
+        )
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke_async/{version}"
+        )
+
+    @pytest.mark.asyncio
+    async def test_invoke_async_over_10k_limit_input(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        process_name = "test-process"
+        # Create input arguments that exceed 10k characters
+        large_text = "a" * 10001
+        input_arguments = {"large_text": large_text}
+
+        test_attachment_id = uuid.uuid4()
+        blob_uri = "https://test-storage.com/test-container/test-blob"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Attachments",
+            method="POST",
+            status_code=201,
+            json={
+                "Id": str(test_attachment_id),
+                "Name": "test-input.json",
+                "BlobFileAccess": {
+                    "Uri": blob_uri,
+                    "Headers": {
+                        "Keys": ["x-ms-blob-type", "Content-Type"],
+                        "Values": ["BlockBlob", "application/json"],
+                    },
+                    "RequiresAuth": False,
+                },
+            },
+        )
+
+        httpx_mock.add_response(
+            url=blob_uri,
+            method="PUT",
+            status_code=201,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+                    }
+                ]
+            },
+        )
+
+        job = await service.invoke_async(process_name, input_arguments)
+
+        assert isinstance(job, Job)
+        assert job.key == "test-job-key"
+        assert job.state == "Running"
+        assert job.start_time == "2024-01-01T00:00:00Z"
+        assert job.id == 123
+        assert job.folder_key == "d0e09040-5997-44e1-93b7-4087689521b7"
+
+        # attachment creation, blob upload, job start
+        requests = httpx_mock.get_requests()
+        assert len(requests) == 3
+
+        attachment_request = requests[0]
+        assert attachment_request.method == "POST"
+        assert "Attachments" in str(attachment_request.url)
+
+        blob_request = requests[1]
+        assert blob_request.method == "PUT"
+        assert blob_request.url == blob_uri
+
+        job_request = requests[2]
+        assert job_request.method == "POST"
+        assert (
+            job_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        )
+
+        # verify InputFile is used
+        job_content = json.loads(job_request.content.decode("utf-8").replace("'", '"'))
+        assert "startInfo" in job_content
+        assert "ReleaseName" in job_content["startInfo"]
+        assert job_content["startInfo"]["ReleaseName"] == process_name
+        assert "InputFile" in job_content["startInfo"]
+        assert "InputArguments" not in job_content["startInfo"]
+        assert job_content["startInfo"]["InputFile"] == str(test_attachment_id)
+
+        assert HEADER_USER_AGENT in job_request.headers
+        assert (
+            job_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke_async/{version}"
+        )
+
+    def test_invoke_with_run_as_me_true(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        process_name = "test-process"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "Id": 123,
+                        "FolderKey": "test-folder-key",
+                    }
+                ]
+            },
+        )
+
+        service.invoke(process_name, run_as_me=True)
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        payload = json.loads(sent_request.content.decode("utf-8"))
+        assert payload["startInfo"]["RunAsMe"] is True
+
+    def test_invoke_with_run_as_me_false(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        process_name = "test-process"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "Id": 123,
+                        "FolderKey": "test-folder-key",
+                    }
+                ]
+            },
+        )
+
+        service.invoke(process_name, run_as_me=False)
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        payload = json.loads(sent_request.content.decode("utf-8"))
+        assert payload["startInfo"]["RunAsMe"] is False
+
+    def test_invoke_without_run_as_me_excludes_from_payload(
+        self,
+        httpx_mock: HTTPXMock,
+        service: ProcessesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        process_name = "test-process"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "Id": 123,
+                        "FolderKey": "test-folder-key",
+                    }
+                ]
+            },
+        )
+
+        service.invoke(process_name)
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        payload = json.loads(sent_request.content.decode("utf-8"))
+        assert "RunAsMe" not in payload["startInfo"]
diff --git a/tests/sdk/services/test_queues_service.py b/packages/uipath-platform/tests/services/test_queues_service.py
similarity index 53%
rename from tests/sdk/services/test_queues_service.py
rename to packages/uipath-platform/tests/services/test_queues_service.py
index 10b849d1c..2dd81ccc0 100644
--- a/tests/sdk/services/test_queues_service.py
+++ b/packages/uipath-platform/tests/services/test_queues_service.py
@@ -1,25 +1,29 @@
 import json
+from datetime import datetime, timezone
 
 import pytest
 from pytest_httpx import HTTPXMock
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.queues_service import QueuesService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models.queues import (
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import (
+    HEADER_FOLDER_KEY,
+    HEADER_FOLDER_PATH,
+    HEADER_USER_AGENT,
+)
+from uipath.platform.orchestrator import (
     CommitType,
     QueueItem,
     QueueItemPriority,
     TransactionItem,
     TransactionItemResult,
 )
+from uipath.platform.orchestrator._queues_service import QueuesService
 
 
 @pytest.fixture
 def service(
-    config: Config,
-    execution_context: ExecutionContext,
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
     monkeypatch: pytest.MonkeyPatch,
 ) -> QueuesService:
     monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
@@ -128,7 +132,6 @@ def test_create_item(
         version: str,
     ) -> None:
         queue_item = QueueItem(
-            name="test-queue",
             priority=QueueItemPriority.HIGH,
             specific_content={"key": "value"},
         )
@@ -143,7 +146,7 @@ def test_create_item(
             },
         )
 
-        response = service.create_item(queue_item)
+        response = service.create_item(queue_item, queue_name="test-queue")
 
         assert response["Id"] == 1
         assert response["Name"] == "test-queue"
@@ -184,7 +187,6 @@ async def test_create_item_async(
         version: str,
     ) -> None:
         queue_item = QueueItem(
-            name="test-queue",
             priority=QueueItemPriority.HIGH,
             specific_content={"key": "value"},
         )
@@ -199,7 +201,7 @@ async def test_create_item_async(
             },
         )
 
-        response = await service.create_item_async(queue_item)
+        response = await service.create_item_async(queue_item, queue_name="test-queue")
 
         assert response["Id"] == 1
         assert response["Name"] == "test-queue"
@@ -240,13 +242,11 @@ def test_create_items(
     ) -> None:
         queue_items = [
             QueueItem(
-                name="test-queue",
                 priority=QueueItemPriority.HIGH,
                 specific_content={"key": "value"},
             ),
             QueueItem(
-                name="test-queue",
-                priority=QueueItemPriority.MEDIUM,
+                priority=QueueItemPriority.LOW,
                 specific_content={"key2": "value2"},
             ),
         ]
@@ -264,7 +264,7 @@ def test_create_items(
                     {
                         "Id": 2,
                         "Name": "test-queue",
-                        "Priority": "Medium",
+                        "Priority": "Low",
                         "SpecificContent": {"key2": "value2"},
                     },
                 ]
@@ -282,7 +282,7 @@ def test_create_items(
         assert response["value"][0]["SpecificContent"] == {"key": "value"}
         assert response["value"][1]["Id"] == 2
         assert response["value"][1]["Name"] == "test-queue"
-        assert response["value"][1]["Priority"] == "Medium"
+        assert response["value"][1]["Priority"] == "Low"
         assert response["value"][1]["SpecificContent"] == {"key2": "value2"}
 
         sent_request = httpx_mock.get_request()
@@ -299,13 +299,11 @@ def test_create_items(
             "commitType": "AllOrNothing",
             "queueItems": [
                 {
-                    "Name": "test-queue",
                     "Priority": "High",
                     "SpecificContent": {"key": "value"},
                 },
                 {
-                    "Name": "test-queue",
-                    "Priority": "Medium",
+                    "Priority": "Low",
                     "SpecificContent": {"key2": "value2"},
                 },
             ],
@@ -329,13 +327,11 @@ async def test_create_items_async(
     ) -> None:
         queue_items = [
             QueueItem(
-                name="test-queue",
                 priority=QueueItemPriority.HIGH,
                 specific_content={"key": "value"},
             ),
             QueueItem(
-                name="test-queue",
-                priority=QueueItemPriority.MEDIUM,
+                priority=QueueItemPriority.LOW,
                 specific_content={"key2": "value2"},
             ),
         ]
@@ -353,7 +349,7 @@ async def test_create_items_async(
                     {
                         "Id": 2,
                         "Name": "test-queue",
-                        "Priority": "Medium",
+                        "Priority": "Low",
                         "SpecificContent": {"key2": "value2"},
                     },
                 ]
@@ -371,7 +367,7 @@ async def test_create_items_async(
         assert response["value"][0]["SpecificContent"] == {"key": "value"}
         assert response["value"][1]["Id"] == 2
         assert response["value"][1]["Name"] == "test-queue"
-        assert response["value"][1]["Priority"] == "Medium"
+        assert response["value"][1]["Priority"] == "Low"
         assert response["value"][1]["SpecificContent"] == {"key2": "value2"}
 
         sent_request = httpx_mock.get_request()
@@ -388,13 +384,11 @@ async def test_create_items_async(
             "commitType": "AllOrNothing",
             "queueItems": [
                 {
-                    "Name": "test-queue",
                     "Priority": "High",
                     "SpecificContent": {"key": "value"},
                 },
                 {
-                    "Name": "test-queue",
-                    "Priority": "Medium",
+                    "Priority": "Low",
                     "SpecificContent": {"key2": "value2"},
                 },
             ],
@@ -406,6 +400,158 @@ async def test_create_items_async(
             == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.QueuesService.create_items_async/{version}"
         )
 
+    def test_create_item_with_reference(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        reference_value = "TEST-REF-12345"
+        queue_item = QueueItem(
+            reference=reference_value,
+            priority=QueueItemPriority.HIGH,
+            specific_content={"invoice_id": "INV-001"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "test-queue",
+                "Reference": reference_value,
+                "Priority": "High",
+                "SpecificContent": {"invoice_id": "INV-001"},
+            },
+        )
+
+        response = service.create_item(queue_item, queue_name="test-queue")
+
+        assert response["Id"] == 1
+        assert response["Name"] == "test-queue"
+        assert response["Reference"] == reference_value
+        assert response["Priority"] == "High"
+        assert response["SpecificContent"] == {"invoice_id": "INV-001"}
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem"
+        )
+        assert json.loads(sent_request.content.decode()) == {
+            "itemData": {
+                "Name": "test-queue",
+                "Reference": reference_value,
+                "Priority": "High",
+                "SpecificContent": {"invoice_id": "INV-001"},
+            }
+        }
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.QueuesService.create_item/{version}"
+        )
+
+    @pytest.mark.asyncio
+    async def test_create_item_with_reference_async(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+        version: str,
+    ) -> None:
+        reference_value = "TEST-REF-12345"
+        queue_item = QueueItem(
+            reference=reference_value,
+            priority=QueueItemPriority.HIGH,
+            specific_content={"invoice_id": "INV-001"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={
+                "Id": 1,
+                "Name": "test-queue",
+                "Reference": reference_value,
+                "Priority": "High",
+                "SpecificContent": {"invoice_id": "INV-001"},
+            },
+        )
+
+        response = await service.create_item_async(queue_item, queue_name="test-queue")
+
+        assert response["Id"] == 1
+        assert response["Name"] == "test-queue"
+        assert response["Reference"] == reference_value
+        assert response["Priority"] == "High"
+        assert response["SpecificContent"] == {"invoice_id": "INV-001"}
+
+        sent_request = httpx_mock.get_request()
+        if sent_request is None:
+            raise Exception("No request was sent")
+
+        assert sent_request.method == "POST"
+        assert (
+            sent_request.url
+            == f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem"
+        )
+        assert json.loads(sent_request.content.decode()) == {
+            "itemData": {
+                "Name": "test-queue",
+                "Reference": reference_value,
+                "Priority": "High",
+                "SpecificContent": {"invoice_id": "INV-001"},
+            }
+        }
+
+        assert HEADER_USER_AGENT in sent_request.headers
+        assert (
+            sent_request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.QueuesService.create_item_async/{version}"
+        )
+
+    def test_create_item_with_datetime_fields(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        defer = datetime(2026, 5, 1, 9, 0, 0, tzinfo=timezone.utc)
+        due = datetime(2026, 5, 2, 17, 30, 0, tzinfo=timezone.utc)
+        risk = datetime(2026, 5, 2, 12, 0, 0, tzinfo=timezone.utc)
+        queue_item = QueueItem(
+            priority=QueueItemPriority.NORMAL,
+            specific_content={"key": "value"},
+            defer_date=defer,
+            due_date=due,
+            risk_sla_date=risk,
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        service.create_item(queue_item, queue_name="test-queue")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        body = json.loads(sent_request.content.decode())
+        assert body["itemData"]["DeferDate"] == defer.isoformat()
+        assert body["itemData"]["DueDate"] == due.isoformat()
+        assert body["itemData"]["RiskSlaDate"] == risk.isoformat()
+
     def test_create_transaction_item(
         self,
         httpx_mock: HTTPXMock,
@@ -416,7 +562,6 @@ def test_create_transaction_item(
         version: str,
     ) -> None:
         transaction_item = TransactionItem(
-            name="test-queue",
             specific_content={"key": "value"},
         )
         httpx_mock.add_response(
@@ -429,7 +574,9 @@ def test_create_transaction_item(
             },
         )
 
-        response = service.create_transaction_item(transaction_item)
+        response = service.create_transaction_item(
+            transaction_item, queue_name="test-queue"
+        )
 
         assert response["Id"] == 1
         assert response["Name"] == "test-queue"
@@ -469,7 +616,6 @@ async def test_create_transaction_item_async(
         version: str,
     ) -> None:
         transaction_item = TransactionItem(
-            name="test-queue",
             specific_content={"key": "value"},
         )
         httpx_mock.add_response(
@@ -482,7 +628,9 @@ async def test_create_transaction_item_async(
             },
         )
 
-        response = await service.create_transaction_item_async(transaction_item)
+        response = await service.create_transaction_item_async(
+            transaction_item, queue_name="test-queue"
+        )
 
         assert response["Id"] == 1
         assert response["Name"] == "test-queue"
@@ -686,3 +834,373 @@ async def test_complete_transaction_item_async(
             sent_request.headers[HEADER_USER_AGENT]
             == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.QueuesService.complete_transaction_item_async/{version}"
         )
+
+    def test_list_items_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/QueueItems",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.list_items(folder_key="custom-folder-key")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    def test_list_items_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/QueueItems",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.list_items(folder_path="Custom/Folder/Path")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
+
+    @pytest.mark.asyncio
+    async def test_list_items_async_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/QueueItems",
+            status_code=200,
+            json={"value": []},
+        )
+
+        await service.list_items_async(folder_key="custom-folder-key")
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    def test_create_item_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        queue_item = QueueItem(
+            priority=QueueItemPriority.HIGH,
+            specific_content={"key": "value"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        service.create_item(
+            queue_item, queue_name="test-queue", folder_key="custom-folder-key"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    def test_create_item_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        queue_item = QueueItem(
+            priority=QueueItemPriority.HIGH,
+            specific_content={"key": "value"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        service.create_item(
+            queue_item, queue_name="test-queue", folder_path="Custom/Folder/Path"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
+
+    @pytest.mark.asyncio
+    async def test_create_item_async_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        queue_item = QueueItem(
+            priority=QueueItemPriority.HIGH,
+            specific_content={"key": "value"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        await service.create_item_async(
+            queue_item, queue_name="test-queue", folder_key="custom-folder-key"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    def test_create_items_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        queue_items = [
+            QueueItem(
+                priority=QueueItemPriority.HIGH,
+                specific_content={"key": "value"},
+            ),
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.BulkAddQueueItems",
+            status_code=200,
+            json={"value": []},
+        )
+
+        service.create_items(
+            queue_items,
+            "test-queue",
+            CommitType.ALL_OR_NOTHING,
+            folder_key="custom-folder-key",
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    @pytest.mark.asyncio
+    async def test_create_items_async_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        queue_items = [
+            QueueItem(
+                priority=QueueItemPriority.HIGH,
+                specific_content={"key": "value"},
+            ),
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.BulkAddQueueItems",
+            status_code=200,
+            json={"value": []},
+        )
+
+        await service.create_items_async(
+            queue_items,
+            "test-queue",
+            CommitType.ALL_OR_NOTHING,
+            folder_path="Custom/Folder/Path",
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
+
+    def test_create_transaction_item_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_item = TransactionItem(
+            specific_content={"key": "value"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.StartTransaction",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        service.create_transaction_item(
+            transaction_item, queue_name="test-queue", folder_key="custom-folder-key"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    @pytest.mark.asyncio
+    async def test_create_transaction_item_async_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_item = TransactionItem(
+            specific_content={"key": "value"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues/UiPathODataSvc.StartTransaction",
+            status_code=200,
+            json={"Id": 1},
+        )
+
+        await service.create_transaction_item_async(
+            transaction_item, queue_name="test-queue", folder_path="Custom/Folder/Path"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
+
+    def test_update_progress_of_transaction_item_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_key = "test-transaction-key"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/QueueItems({transaction_key})/UiPathODataSvc.SetTransactionProgress",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        service.update_progress_of_transaction_item(
+            transaction_key, "Processing...", folder_key="custom-folder-key"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    @pytest.mark.asyncio
+    async def test_update_progress_of_transaction_item_async_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_key = "test-transaction-key"
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/QueueItems({transaction_key})/UiPathODataSvc.SetTransactionProgress",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        await service.update_progress_of_transaction_item_async(
+            transaction_key, "Processing...", folder_path="Custom/Folder/Path"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
+
+    def test_complete_transaction_item_with_folder_key(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_key = "test-transaction-key"
+        result = TransactionItemResult(
+            is_successful=True,
+            output={"result": "success"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues({transaction_key})/UiPathODataSvc.SetTransactionResult",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        service.complete_transaction_item(
+            transaction_key, result, folder_key="custom-folder-key"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_KEY in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_KEY] == "custom-folder-key"
+
+    @pytest.mark.asyncio
+    async def test_complete_transaction_item_async_with_folder_path(
+        self,
+        httpx_mock: HTTPXMock,
+        service: QueuesService,
+        base_url: str,
+        org: str,
+        tenant: str,
+    ) -> None:
+        transaction_key = "test-transaction-key"
+        result = TransactionItemResult(
+            is_successful=True,
+            output={"result": "success"},
+        )
+        httpx_mock.add_response(
+            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Queues({transaction_key})/UiPathODataSvc.SetTransactionResult",
+            status_code=200,
+            json={"status": "success"},
+        )
+
+        await service.complete_transaction_item_async(
+            transaction_key, result, folder_path="Custom/Folder/Path"
+        )
+
+        sent_request = httpx_mock.get_request()
+        assert sent_request is not None
+        assert HEADER_FOLDER_PATH in sent_request.headers
+        assert sent_request.headers[HEADER_FOLDER_PATH] == "Custom/Folder/Path"
diff --git a/packages/uipath-platform/tests/services/test_remote_a2a_service.py b/packages/uipath-platform/tests/services/test_remote_a2a_service.py
new file mode 100644
index 000000000..1f4239d4d
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_remote_a2a_service.py
@@ -0,0 +1,55 @@
+import pytest
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.agenthub._remote_a2a_service import RemoteA2aService
+from uipath.platform.common.constants import HEADER_FOLDER_KEY
+from uipath.platform.orchestrator._folder_service import FolderService
+
+
+@pytest.fixture
+def folders_service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> FolderService:
+    monkeypatch.setenv("UIPATH_FOLDER_KEY", "context-folder-key")
+    return FolderService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    folders_service: FolderService,
+    monkeypatch: pytest.MonkeyPatch,
+) -> RemoteA2aService:
+    monkeypatch.setenv("UIPATH_FOLDER_KEY", "context-folder-key")
+    return RemoteA2aService(
+        config=config,
+        execution_context=execution_context,
+        folders_service=folders_service,
+    )
+
+
+class TestRetrieveSpecFolderResolution:
+    def test_falls_back_to_folder_context_when_folder_path_missing(
+        self, service: RemoteA2aService
+    ) -> None:
+        """No folder_path (e.g. local debug) must not raise; it falls back to context."""
+        spec = service._retrieve_spec(slug="weather", folder_path=None)
+
+        assert "remote-a2a-agents/weather" in str(spec.endpoint)
+        assert spec.headers[HEADER_FOLDER_KEY] == "context-folder-key"
+
+    def test_resolves_explicit_folder_path(
+        self, service: RemoteA2aService, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(
+            service._folders_service,
+            "retrieve_folder_key",
+            lambda folder_path: "resolved-folder-key",
+        )
+
+        spec = service._retrieve_spec(slug="weather", folder_path="MyFolder")
+
+        assert spec.headers[HEADER_FOLDER_KEY] == "resolved-folder-key"
diff --git a/packages/uipath-platform/tests/services/test_resource_catalog_service.py b/packages/uipath-platform/tests/services/test_resource_catalog_service.py
new file mode 100644
index 000000000..3db6ee60e
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_resource_catalog_service.py
@@ -0,0 +1,861 @@
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.common.constants import HEADER_USER_AGENT
+from uipath.platform.orchestrator._folder_service import FolderService
+from uipath.platform.resource_catalog import ResourceType
+from uipath.platform.resource_catalog._resource_catalog_service import (
+    ResourceCatalogService,
+)
+
+
+@pytest.fixture
+def mock_folder_service() -> MagicMock:
+    """Mock FolderService for testing."""
+    service = MagicMock(spec=FolderService)
+    service.retrieve_folder_key.return_value = "test-folder-key"
+    service.retrieve_folder_key_async = AsyncMock(return_value="test-folder-key")
+    return service
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+    mock_folder_service: MagicMock,
+    monkeypatch: pytest.MonkeyPatch,
+) -> ResourceCatalogService:
+    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
+    return ResourceCatalogService(
+        config=config,
+        execution_context=execution_context,
+        folder_service=mock_folder_service,
+    )
+
+
+class TestResourceCatalogService:
+    @staticmethod
+    def _mock_response(
+        entity_id: str,
+        name: str,
+        entity_type: str,
+        entity_sub_type: str = "default",
+        description: str = "",
+        folder_key: str = "test-folder-key",
+        **extra_fields,
+    ) -> dict[str, Any]:
+        """Generate a mock Resource response."""
+        response = {
+            "entityKey": entity_id,
+            "name": name,
+            "entityType": entity_type,
+            "entitySubType": entity_sub_type,
+            "description": description,
+            "scope": "Tenant",
+            "searchState": "Available",
+            "timestamp": "2024-01-01T00:00:00Z",
+            "folderKey": folder_key,
+            "folderKeys": [folder_key],
+            "tenantKey": "test-tenant-key",
+            "accountKey": "test-account-key",
+            "userKey": "test-user-key",
+            "tags": [],
+            "folders": [],
+            "linkedFoldersCount": 0,
+            "dependencies": [],
+        }
+        response.update(extra_fields)
+        return response
+
+    class TestSearchResources:
+        def test_search_resources_with_name_filter(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/Search?skip=0&take=20&name=invoice",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="invoice-processor",
+                            entity_type="process",
+                            entity_sub_type="automation",
+                            description="Process invoice documents",
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            entity_id="2",
+                            name="invoice-queue",
+                            entity_type="queue",
+                            entity_sub_type="transactional",
+                            description="Queue for invoice processing",
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(service.search(name="invoice"))
+
+            assert len(resources) == 2
+            assert resources[0].name == "invoice-processor"
+            assert resources[0].resource_type == "process"
+            assert resources[1].name == "invoice-queue"
+            assert resources[1].resource_type == "queue"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert "name=invoice" in str(sent_request.url)
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ResourceCatalogService.search/{version}"
+            )
+
+        def test_search_resources_with_resource_types_filter(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/Search?skip=0&take=20&entityTypes=asset&entityTypes=queue",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="3",
+                            name="config-asset",
+                            entity_type="asset",
+                            entity_sub_type="text",
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            entity_id="4",
+                            name="work-queue",
+                            entity_type="queue",
+                            entity_sub_type="transactional",
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(
+                service.search(resource_types=[ResourceType.ASSET, ResourceType.QUEUE])
+            )
+
+            assert len(resources) == 2
+            assert resources[0].resource_type == "asset"
+            assert resources[1].resource_type == "queue"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert "entityTypes=asset" in str(
+                sent_request.url
+            ) or "entityTypes%5B%5D=asset" in str(sent_request.url)
+            assert "entityTypes=queue" in str(
+                sent_request.url
+            ) or "entityTypes%5B%5D=queue" in str(sent_request.url)
+
+        def test_search_resources_pagination(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # First page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/Search?skip=0&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "1", "resource-1", "asset"
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            "2", "resource-2", "queue"
+                        ),
+                    ]
+                },
+            )
+            # Second page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/Search?skip=2&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "3", "resource-3", "process"
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(service.search(page_size=2))
+
+            assert len(resources) == 3
+            assert resources[0].name == "resource-1"
+            assert resources[1].name == "resource-2"
+            assert resources[2].name == "resource-3"
+
+    class TestListResources:
+        def test_list_resources_without_filters(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=20",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="test-asset",
+                            entity_type="asset",
+                            entity_sub_type="text",
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            entity_id="2",
+                            name="test-queue",
+                            entity_type="queue",
+                            entity_sub_type="transactional",
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(service.list())
+
+            assert len(resources) == 2
+            assert resources[0].name == "test-asset"
+            assert resources[1].name == "test-queue"
+            mock_folder_service.retrieve_folder_key.assert_called_once_with(None)
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert str(sent_request.url).endswith("/Entities?skip=0&take=20")
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ResourceCatalogService.list/{version}"
+            )
+
+        def test_list_resources_with_folder_path(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=20&entityTypes=asset",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="finance-asset",
+                            entity_type="asset",
+                            entity_sub_type="number",
+                        )
+                    ]
+                },
+            )
+
+            resources = list(
+                service.list(
+                    folder_path="/Shared/Finance", resource_types=[ResourceType.ASSET]
+                )
+            )
+
+            assert len(resources) == 1
+            assert resources[0].name == "finance-asset"
+            mock_folder_service.retrieve_folder_key.assert_called_once_with(
+                "/Shared/Finance"
+            )
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert "X-UIPATH-FolderKey" in sent_request.headers
+
+        def test_list_resources_with_resource_filters(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=20&entityTypes=process&entityTypes=mcpserver&entitySubType=automation",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="automation-process",
+                            entity_type="process",
+                            entity_sub_type="automation",
+                        )
+                    ]
+                },
+            )
+
+            resources = list(
+                service.list(
+                    resource_types=[ResourceType.PROCESS, ResourceType.MCP_SERVER],
+                    resource_sub_types=["automation"],
+                )
+            )
+
+            assert len(resources) == 1
+            assert resources[0].resource_type == "process"
+            assert resources[0].resource_sub_type == "automation"
+
+        def test_list_resources_pagination(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # First page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=3",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "1", "resource-1", "asset"
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            "2", "resource-2", "queue"
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            "3", "resource-3", "process"
+                        ),
+                    ]
+                },
+            )
+            # Second page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=3&take=3",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "4", "resource-4", "bucket"
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(service.list(page_size=3))
+
+            assert len(resources) == 4
+            assert resources[0].name == "resource-1"
+            assert resources[3].name == "resource-4"
+
+        def test_list_resources_invalid_page_size(
+            self,
+            service: ResourceCatalogService,
+        ) -> None:
+            with pytest.raises(ValueError, match="page_size must be greater than 0"):
+                list(service.list(page_size=0))
+
+            with pytest.raises(ValueError, match="page_size must be greater than 0"):
+                list(service.list(page_size=-1))
+
+    class TestListResourcesByType:
+        def test_list_by_type_basic(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+            version: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/asset?skip=0&take=20",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="config-asset",
+                            entity_type="asset",
+                            entity_sub_type="text",
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            entity_id="2",
+                            name="number-asset",
+                            entity_type="asset",
+                            entity_sub_type="number",
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(service.list_by_type(resource_type=ResourceType.ASSET))
+
+            assert len(resources) == 2
+            assert resources[0].name == "config-asset"
+            assert resources[0].resource_type == "asset"
+            assert resources[1].name == "number-asset"
+            assert resources[1].resource_type == "asset"
+            mock_folder_service.retrieve_folder_key.assert_called_once_with(None)
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert sent_request.method == "GET"
+            assert str(sent_request.url).endswith("/Entities/asset?skip=0&take=20")
+            assert HEADER_USER_AGENT in sent_request.headers
+            assert (
+                sent_request.headers[HEADER_USER_AGENT]
+                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ResourceCatalogService.list_by_type/{version}"
+            )
+
+        def test_list_by_type_with_name_filter(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/process?skip=0&take=20&name=invoice",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="invoice-processor",
+                            entity_type="process",
+                            entity_sub_type="automation",
+                        )
+                    ]
+                },
+            )
+
+            resources = list(
+                service.list_by_type(resource_type=ResourceType.PROCESS, name="invoice")
+            )
+
+            assert len(resources) == 1
+            assert resources[0].name == "invoice-processor"
+            assert resources[0].resource_type == "process"
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert "name=invoice" in str(sent_request.url)
+
+        def test_list_by_type_with_folder_and_subtype(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/asset?skip=0&take=20&entitySubType=number",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="finance-number",
+                            entity_type="asset",
+                            entity_sub_type="number",
+                        )
+                    ]
+                },
+            )
+
+            resources = list(
+                service.list_by_type(
+                    resource_type=ResourceType.ASSET,
+                    folder_path="/Shared/Finance",
+                    resource_sub_types=["number"],
+                )
+            )
+
+            assert len(resources) == 1
+            assert resources[0].resource_sub_type == "number"
+            mock_folder_service.retrieve_folder_key.assert_called_once_with(
+                "/Shared/Finance"
+            )
+
+            sent_request = httpx_mock.get_request()
+            if sent_request is None:
+                raise Exception("No request was sent")
+
+            assert "entitySubType=number" in str(sent_request.url)
+            assert "X-UIPATH-FolderKey" in sent_request.headers
+
+        def test_list_by_type_pagination(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # First page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/queue?skip=0&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "1", "queue-1", "queue"
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            "2", "queue-2", "queue"
+                        ),
+                    ]
+                },
+            )
+            # Second page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/queue?skip=2&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "3", "queue-3", "queue"
+                        ),
+                    ]
+                },
+            )
+
+            resources = list(
+                service.list_by_type(resource_type=ResourceType.QUEUE, page_size=2)
+            )
+
+            assert len(resources) == 3
+            assert all(r.resource_type == "queue" for r in resources)
+
+        def test_list_by_type_invalid_page_size(
+            self,
+            service: ResourceCatalogService,
+        ) -> None:
+            with pytest.raises(ValueError, match="page_size must be greater than 0"):
+                list(
+                    service.list_by_type(resource_type=ResourceType.ASSET, page_size=0)
+                )
+
+            with pytest.raises(ValueError, match="page_size must be greater than 0"):
+                list(
+                    service.list_by_type(resource_type=ResourceType.ASSET, page_size=-1)
+                )
+
+    class TestAsyncMethods:
+        @pytest.mark.asyncio
+        async def test_search_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/Search?skip=0&take=20&name=test",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="test-resource",
+                            entity_type="asset",
+                        )
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.search_async(name="test"):
+                resources.append(resource)
+
+            assert len(resources) == 1
+            assert resources[0].name == "test-resource"
+
+        @pytest.mark.asyncio
+        async def test_list_resources_async(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=20",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="async-resource",
+                            entity_type="queue",
+                        )
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_async():
+                resources.append(resource)
+
+            assert len(resources) == 1
+            assert resources[0].name == "async-resource"
+            mock_folder_service.retrieve_folder_key_async.assert_called_once_with(None)
+
+        @pytest.mark.asyncio
+        async def test_list_resources_async_with_filters(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities?skip=0&take=20&entityTypes=asset&entitySubType=text",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="text-asset",
+                            entity_type="asset",
+                            entity_sub_type="text",
+                        )
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_async(
+                resource_types=[ResourceType.ASSET],
+                resource_sub_types=["text"],
+                folder_path="/Test/Folder",
+            ):
+                resources.append(resource)
+
+            assert len(resources) == 1
+            assert resources[0].resource_sub_type == "text"
+            mock_folder_service.retrieve_folder_key_async.assert_called_once_with(
+                "/Test/Folder"
+            )
+
+        @pytest.mark.asyncio
+        async def test_list_by_type_async_basic(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/asset?skip=0&take=20",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="async-asset-1",
+                            entity_type="asset",
+                            entity_sub_type="text",
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            entity_id="2",
+                            name="async-asset-2",
+                            entity_type="asset",
+                            entity_sub_type="number",
+                        ),
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_by_type_async(
+                resource_type=ResourceType.ASSET
+            ):
+                resources.append(resource)
+
+            assert len(resources) == 2
+            assert resources[0].name == "async-asset-1"
+            assert resources[0].resource_type == "asset"
+            assert resources[1].name == "async-asset-2"
+            assert resources[1].resource_type == "asset"
+            mock_folder_service.retrieve_folder_key_async.assert_called_once_with(None)
+
+        @pytest.mark.asyncio
+        async def test_list_by_type_async_with_name_filter(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/process?skip=0&take=20&name=workflow",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="workflow-processor",
+                            entity_type="process",
+                            entity_sub_type="automation",
+                        )
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_by_type_async(
+                resource_type=ResourceType.PROCESS, name="workflow"
+            ):
+                resources.append(resource)
+
+            assert len(resources) == 1
+            assert resources[0].name == "workflow-processor"
+            assert resources[0].resource_type == "process"
+
+        @pytest.mark.asyncio
+        async def test_list_by_type_async_with_folder_and_subtype(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/queue?skip=0&take=20&entitySubType=transactional",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            entity_id="1",
+                            name="transactional-queue",
+                            entity_type="queue",
+                            entity_sub_type="transactional",
+                        )
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_by_type_async(
+                resource_type=ResourceType.QUEUE,
+                folder_path="/Production",
+                resource_sub_types=["transactional"],
+            ):
+                resources.append(resource)
+
+            assert len(resources) == 1
+            assert resources[0].resource_sub_type == "transactional"
+            mock_folder_service.retrieve_folder_key_async.assert_called_once_with(
+                "/Production"
+            )
+
+        @pytest.mark.asyncio
+        async def test_list_by_type_async_pagination(
+            self,
+            httpx_mock: HTTPXMock,
+            service: ResourceCatalogService,
+            mock_folder_service: MagicMock,
+            base_url: str,
+            org: str,
+            tenant: str,
+        ) -> None:
+            # First page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/bucket?skip=0&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "1", "bucket-1", "bucket"
+                        ),
+                        TestResourceCatalogService._mock_response(
+                            "2", "bucket-2", "bucket"
+                        ),
+                    ]
+                },
+            )
+            # Second page
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/resourcecatalog_/Entities/bucket?skip=2&take=2",
+                status_code=200,
+                json={
+                    "value": [
+                        TestResourceCatalogService._mock_response(
+                            "3", "bucket-3", "bucket"
+                        ),
+                    ]
+                },
+            )
+
+            resources = []
+            async for resource in service.list_by_type_async(
+                resource_type=ResourceType.BUCKET, page_size=2
+            ):
+                resources.append(resource)
+
+            assert len(resources) == 3
+            assert all(r.resource_type == "bucket" for r in resources)
diff --git a/packages/uipath-platform/tests/services/test_retry.py b/packages/uipath-platform/tests/services/test_retry.py
new file mode 100644
index 000000000..ab893f042
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_retry.py
@@ -0,0 +1,252 @@
+import httpx
+from tenacity import Future, RetryCallState, Retrying
+
+from uipath.platform.common.retry import (
+    _MAX_BACKOFF_DELAY,
+    _MAX_RETRY_AFTER_DELAY,
+    exponential_backoff_with_jitter,
+    extract_retry_after_from_chain,
+    is_retryable_platform_exception,
+    is_retryable_response,
+    parse_retry_after,
+    platform_wait_strategy,
+)
+from uipath.platform.errors import EnrichedException
+
+
+class TestParseRetryAfter:
+    def test_valid_integer(self):
+        assert parse_retry_after("120") == 120.0
+
+    def test_valid_float(self):
+        assert parse_retry_after("1.5") == 1.5
+
+    def test_zero(self):
+        assert parse_retry_after("0") == 0.0
+
+    def test_whitespace(self):
+        assert parse_retry_after("  30  ") == 30.0
+
+    def test_negative_returns_none(self):
+        assert parse_retry_after("-1") is None
+
+    def test_non_numeric_returns_none(self):
+        assert parse_retry_after("not-a-number") is None
+
+    def test_http_date_returns_none(self):
+        assert parse_retry_after("Wed, 21 Oct 2015 07:28:00 GMT") is None
+
+    def test_empty_string_returns_none(self):
+        assert parse_retry_after("") is None
+
+
+class TestExponentialBackoffWithJitter:
+    def test_first_attempt(self):
+        result = exponential_backoff_with_jitter(attempt=1, initial=1.0)
+        # 1.0 * 2^0 + jitter(0,1) = 1.0 + [0, 1)
+        assert 1.0 <= result < 2.0
+
+    def test_second_attempt(self):
+        result = exponential_backoff_with_jitter(attempt=2, initial=1.0)
+        # 1.0 * 2^1 + jitter(0,1) = 2.0 + [0, 1)
+        assert 2.0 <= result < 3.0
+
+    def test_third_attempt(self):
+        result = exponential_backoff_with_jitter(attempt=3, initial=1.0)
+        # 1.0 * 2^2 + jitter(0,1) = 4.0 + [0, 1)
+        assert 4.0 <= result < 5.0
+
+    def test_growth_pattern(self):
+        # With large enough initial, growth dominates jitter
+        results = [
+            exponential_backoff_with_jitter(attempt=i, initial=10.0)
+            for i in range(1, 5)
+        ]
+        # Each base should roughly double (jitter is <=1.0, base starts at 10)
+        for i in range(1, len(results)):
+            assert results[i] > results[i - 1]
+
+    def test_custom_initial(self):
+        result = exponential_backoff_with_jitter(attempt=1, initial=5.0)
+        assert 5.0 <= result < 6.0
+
+
+class TestExtractRetryAfterFromChain:
+    @staticmethod
+    def _make_http_status_error(
+        status_code: int, retry_after: str | None = None
+    ) -> httpx.HTTPStatusError:
+        headers = {}
+        if retry_after is not None:
+            headers["retry-after"] = retry_after
+        response = httpx.Response(
+            status_code=status_code,
+            headers=headers,
+            request=httpx.Request("GET", "https://example.com"),
+        )
+        return httpx.HTTPStatusError(
+            message=f"{status_code}", request=response.request, response=response
+        )
+
+    def test_direct_http_status_error(self):
+        err = self._make_http_status_error(429, retry_after="30")
+        assert extract_retry_after_from_chain(err) == 30.0
+
+    def test_enriched_exception_wrapping(self):
+        http_err = self._make_http_status_error(429, retry_after="60")
+        enriched = EnrichedException(http_err)
+        enriched.__cause__ = http_err
+        assert extract_retry_after_from_chain(enriched) == 60.0
+
+    def test_missing_header(self):
+        err = self._make_http_status_error(500)
+        assert extract_retry_after_from_chain(err) is None
+
+    def test_unrelated_exception(self):
+        err = ValueError("something unrelated")
+        assert extract_retry_after_from_chain(err) is None
+
+    def test_zero_retry_after(self):
+        err = self._make_http_status_error(429, retry_after="0")
+        assert extract_retry_after_from_chain(err) == 0.0
+
+    def test_negative_retry_after_ignored(self):
+        err = self._make_http_status_error(429, retry_after="-5")
+        assert extract_retry_after_from_chain(err) is None
+
+
+def _make_http_status_error(
+    status_code: int, retry_after: str | None = None
+) -> httpx.HTTPStatusError:
+    headers = {}
+    if retry_after is not None:
+        headers["retry-after"] = retry_after
+    response = httpx.Response(
+        status_code=status_code,
+        headers=headers,
+        request=httpx.Request("GET", "https://example.com"),
+    )
+    return httpx.HTTPStatusError(
+        message=f"{status_code}", request=response.request, response=response
+    )
+
+
+def _make_retry_state(exception: BaseException, attempt: int = 1) -> RetryCallState:
+    rs = RetryCallState(Retrying(), None, None, None)
+    rs.attempt_number = attempt
+    f = Future(attempt)
+    f.set_exception(exception)
+    rs.outcome = f
+    return rs
+
+
+class TestIsRetryablePlatformException:
+    def test_connect_timeout(self):
+        err = httpx.ConnectTimeout("timed out")
+        assert is_retryable_platform_exception(err) is True
+
+    def test_timeout_exception(self):
+        err = httpx.TimeoutException("timed out")
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_408(self):
+        http_err = _make_http_status_error(408)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_429(self):
+        http_err = _make_http_status_error(429)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_502(self):
+        http_err = _make_http_status_error(502)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_503(self):
+        http_err = _make_http_status_error(503)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_504(self):
+        http_err = _make_http_status_error(504)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_524_cloudflare_timeout(self):
+        http_err = _make_http_status_error(524)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is True
+
+    def test_enriched_400_not_retryable(self):
+        http_err = _make_http_status_error(400)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is False
+
+    def test_enriched_500_not_retryable(self):
+        http_err = _make_http_status_error(500)
+        err = EnrichedException(http_err)
+        assert is_retryable_platform_exception(err) is False
+
+    def test_raw_http_error_not_matched(self):
+        err = _make_http_status_error(429)
+        assert is_retryable_platform_exception(err) is False
+
+    def test_unrelated_exception_not_retryable(self):
+        assert is_retryable_platform_exception(ValueError("nope")) is False
+
+
+class TestIsRetryableResponse:
+    def test_500(self):
+        assert is_retryable_response(httpx.Response(500)) is True
+
+    def test_502(self):
+        assert is_retryable_response(httpx.Response(502)) is True
+
+    def test_503(self):
+        assert is_retryable_response(httpx.Response(503)) is True
+
+    def test_599(self):
+        assert is_retryable_response(httpx.Response(599)) is True
+
+    def test_200_not_retryable(self):
+        assert is_retryable_response(httpx.Response(200)) is False
+
+    def test_400_not_retryable(self):
+        assert is_retryable_response(httpx.Response(400)) is False
+
+    def test_429_not_retryable(self):
+        assert is_retryable_response(httpx.Response(429)) is False
+
+
+class TestPlatformWaitStrategy:
+    def test_uses_retry_after_header(self):
+        http_err = _make_http_status_error(429, retry_after="5")
+        rs = _make_retry_state(http_err)
+        assert platform_wait_strategy(rs) == 5.0
+
+    def test_caps_retry_after_at_max(self):
+        http_err = _make_http_status_error(429, retry_after="999")
+        rs = _make_retry_state(http_err)
+        assert platform_wait_strategy(rs) == _MAX_RETRY_AFTER_DELAY
+
+    def test_falls_back_to_backoff_without_header(self):
+        http_err = _make_http_status_error(503)
+        rs = _make_retry_state(http_err, attempt=1)
+        wait = platform_wait_strategy(rs)
+        # attempt 1: 1.0 * 2^0 + jitter(0,1) = [1.0, 2.0)
+        assert 1.0 <= wait < 2.0
+
+    def test_backoff_capped_at_max(self):
+        http_err = _make_http_status_error(503)
+        # attempt 5: 1.0 * 2^4 = 16.0 + jitter, but capped at _MAX_BACKOFF_DELAY
+        rs = _make_retry_state(http_err, attempt=5)
+        assert platform_wait_strategy(rs) == _MAX_BACKOFF_DELAY
+
+    def test_no_outcome_falls_back_to_backoff(self):
+        rs = RetryCallState(Retrying(), None, None, None)
+        rs.attempt_number = 1
+        rs.outcome = None
+        wait = platform_wait_strategy(rs)
+        assert 1.0 <= wait < 2.0
diff --git a/packages/uipath-platform/tests/services/test_semantic_proxy_service.py b/packages/uipath-platform/tests/services/test_semantic_proxy_service.py
new file mode 100644
index 000000000..51b4f4895
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_semantic_proxy_service.py
@@ -0,0 +1,264 @@
+"""Tests for SemanticProxyService."""
+
+import json
+from typing import Any
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.semantic_proxy import (
+    PiiDetectionRequest,
+    PiiDetectionResponse,
+    PiiDocument,
+    PiiEntityThreshold,
+    PiiFile,
+    SemanticProxyService,
+)
+
+
+@pytest.fixture
+def service(
+    config: UiPathApiConfig,
+    execution_context: UiPathExecutionContext,
+) -> SemanticProxyService:
+    return SemanticProxyService(config=config, execution_context=execution_context)
+
+
+@pytest.fixture
+def sample_response_json() -> dict[str, Any]:
+    return {
+        "response": [
+            {
+                "id": "user-prompt",
+                "role": "user",
+                "maskedDocument": "Contact [Person-1]",
+                "initialDocument": "Contact Alison",
+                "piiEntities": [
+                    {
+                        "piiText": "Alison",
+                        "replacementText": "[Person-1]",
+                        "piiType": "Person",
+                        "offset": 8,
+                        "confidenceScore": 0.99,
+                    }
+                ],
+            }
+        ],
+        "files": [
+            {
+                "fileName": "doc.pdf",
+                "fileUrl": "https://blob.example.com/redacted/doc.pdf",
+                "piiEntities": [
+                    {
+                        "piiText": "alice@example.com",
+                        "replacementText": "[Email-1]",
+                        "piiType": "Email",
+                        "offset": 100,
+                        "confidenceScore": 0.88,
+                    }
+                ],
+            }
+        ],
+    }
+
+
+class TestSemanticProxyService:
+    """Test SemanticProxyService functionality."""
+
+    class TestDetectPii:
+        """Test detect_pii (sync)."""
+
+        def test_returns_typed_response(
+            self,
+            httpx_mock: HTTPXMock,
+            service: SemanticProxyService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/semanticproxy_/api/pii-detection",
+                status_code=200,
+                json=sample_response_json,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[
+                    PiiDocument(
+                        id="user-prompt", role="user", document="Contact Alison"
+                    )
+                ]
+            )
+            result = service.detect_pii(request)
+
+            assert isinstance(result, PiiDetectionResponse)
+            assert len(result.response) == 1
+            assert result.response[0].masked_document == "Contact [Person-1]"
+            assert len(result.files) == 1
+            assert result.files[0].file_name == "doc.pdf"
+            assert result.files[0].pii_entities[0].replacement_text == "[Email-1]"
+
+    class TestDetectPiiAsync:
+        """Test detect_pii_async."""
+
+        async def test_returns_typed_response(
+            self,
+            httpx_mock: HTTPXMock,
+            service: SemanticProxyService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            httpx_mock.add_response(
+                url=f"{base_url}{org}{tenant}/semanticproxy_/api/pii-detection",
+                status_code=200,
+                json=sample_response_json,
+            )
+
+            request = PiiDetectionRequest(
+                files=[
+                    PiiFile(
+                        file_name="doc.pdf",
+                        file_url="https://input.example.com/doc.pdf",
+                        file_type="pdf",
+                    )
+                ]
+            )
+            result = await service.detect_pii_async(request)
+
+            assert isinstance(result, PiiDetectionResponse)
+            assert (
+                result.files[0].file_url == "https://blob.example.com/redacted/doc.pdf"
+            )
+
+        async def test_request_payload_uses_aliases(
+            self,
+            httpx_mock: HTTPXMock,
+            service: SemanticProxyService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/semanticproxy_/api/pii-detection",
+                callback=capture,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[
+                    PiiDocument(id="user-prompt", role="user", document="Hello")
+                ],
+                files=[
+                    PiiFile(
+                        file_name="doc.pdf",
+                        file_url="https://input.example.com/doc.pdf",
+                        file_type="pdf",
+                    )
+                ],
+                language_code="en",
+                confidence_threshold=0.5,
+                entity_thresholds=[
+                    PiiEntityThreshold(category="Person", confidence_threshold=0.7),
+                ],
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            payload = json.loads(captured_request.content)
+
+            # Top-level uses camelCase aliases
+            assert "documents" in payload
+            assert "files" in payload
+            assert "languageCode" in payload
+            assert "confidenceThreshold" in payload
+            assert "entityThresholds" in payload
+
+            # File uses camelCase aliases
+            assert payload["files"][0]["fileName"] == "doc.pdf"
+            assert payload["files"][0]["fileUrl"] == "https://input.example.com/doc.pdf"
+            assert payload["files"][0]["fileType"] == "pdf"
+
+            # Entity threshold uses kebab-case aliases
+            threshold = payload["entityThresholds"][0]
+            assert threshold["pii-entity-category"] == "Person"
+            assert threshold["pii-entity-confidence-threshold"] == 0.7
+
+        async def test_request_excludes_none_fields(
+            self,
+            httpx_mock: HTTPXMock,
+            service: SemanticProxyService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/semanticproxy_/api/pii-detection",
+                callback=capture,
+            )
+
+            # Only documents set; other optional fields should be omitted
+            request = PiiDetectionRequest(
+                documents=[PiiDocument(id="user-prompt", role="user", document="Hello")]
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            payload = json.loads(captured_request.content)
+            assert "files" not in payload
+            assert "languageCode" not in payload
+            assert "confidenceThreshold" not in payload
+            assert "entityThresholds" not in payload
+
+        async def test_url_is_tenant_scoped(
+            self,
+            httpx_mock: HTTPXMock,
+            service: SemanticProxyService,
+            base_url: str,
+            org: str,
+            tenant: str,
+            sample_response_json: dict[str, Any],
+        ) -> None:
+            captured_request: httpx.Request | None = None
+
+            def capture(request: httpx.Request) -> httpx.Response:
+                nonlocal captured_request
+                captured_request = request
+                return httpx.Response(status_code=200, json=sample_response_json)
+
+            httpx_mock.add_callback(
+                method="POST",
+                url=f"{base_url}{org}{tenant}/semanticproxy_/api/pii-detection",
+                callback=capture,
+            )
+
+            request = PiiDetectionRequest(
+                documents=[PiiDocument(id="user-prompt", role="user", document="Hello")]
+            )
+            await service.detect_pii_async(request)
+
+            assert captured_request is not None
+            assert org.strip("/") in captured_request.url.path
+            assert tenant.strip("/") in captured_request.url.path
+            assert "/semanticproxy_/api/pii-detection" in captured_request.url.path
diff --git a/packages/uipath-platform/tests/services/test_server_version.py b/packages/uipath-platform/tests/services/test_server_version.py
new file mode 100644
index 000000000..ff53385c1
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_server_version.py
@@ -0,0 +1,23 @@
+import httpx
+from pytest_httpx import HTTPXMock
+
+from uipath.platform.orchestrator import get_server_version
+
+
+class TestGetServerVersion:
+    def test_success(self, httpx_mock: HTTPXMock):
+        domain = "https://cloud.uipath.com"
+        httpx_mock.add_response(
+            url=f"{domain}/orchestrator_/api/status/version",
+            method="GET",
+            status_code=200,
+            json={"version": "23.10.1.0"},
+        )
+
+        assert get_server_version(domain) == "23.10.1.0"
+
+    def test_error_returns_none(self, httpx_mock: HTTPXMock):
+        domain = "https://cloud.uipath.com"
+        httpx_mock.add_exception(httpx.ConnectError("Connection refused"))
+
+        assert get_server_version(domain) is None
diff --git a/packages/uipath-platform/tests/services/test_service_url_overrides.py b/packages/uipath-platform/tests/services/test_service_url_overrides.py
new file mode 100644
index 000000000..cc038a3b9
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_service_url_overrides.py
@@ -0,0 +1,90 @@
+import pytest
+
+from uipath.platform.common._service_url_overrides import (
+    inject_routing_headers,
+    resolve_service_url,
+)
+
+
+class TestResolveServiceUrl:
+    def test_returns_none_when_no_override(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("UIPATH_SERVICE_URL_AGENTHUB", raising=False)
+        assert resolve_service_url("agenthub_/llm/api/chat/completions") is None
+
+    def test_agenthub_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        result = resolve_service_url("agenthub_/llm/api/chat/completions")
+        assert result == "http://localhost:5200/llm/api/chat/completions"
+
+    def test_orchestrator_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_ORCHESTRATOR", "http://localhost:8080")
+        result = resolve_service_url("orchestrator_/odata/Buckets")
+        assert result == "http://localhost:8080/odata/Buckets"
+
+    def test_leading_slash_stripped(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        result = resolve_service_url("/agenthub_/llm/api/chat/completions")
+        assert result == "http://localhost:5200/llm/api/chat/completions"
+
+    def test_trailing_slash_on_override_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200/")
+        result = resolve_service_url("agenthub_/llm/api/chat/completions")
+        assert result == "http://localhost:5200/llm/api/chat/completions"
+
+    def test_compound_service_prefix(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTSRUNTIME", "http://localhost:6100")
+        result = resolve_service_url("agentsruntime_/api/execution/guardrails/validate")
+        assert result == "http://localhost:6100/api/execution/guardrails/validate"
+
+    def test_no_service_prefix_returns_none(self) -> None:
+        assert resolve_service_url("api/v1/users") is None
+
+    def test_empty_path_returns_none(self) -> None:
+        assert resolve_service_url("") is None
+
+    def test_service_only_path(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        result = resolve_service_url("agenthub_/")
+        assert result == "http://localhost:5200/"
+
+    def test_query_params_preserved(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_SERVICE_URL_AGENTHUB", "http://localhost:5200")
+        result = resolve_service_url(
+            "agenthub_/llm/openai/deployments/gpt-4/chat/completions?api-version=2024-10-21"
+        )
+        assert (
+            result
+            == "http://localhost:5200/llm/openai/deployments/gpt-4/chat/completions?api-version=2024-10-21"
+        )
+
+
+class TestInjectRoutingHeaders:
+    def test_injects_tenant_and_org(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "tenant-123")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "org-456")
+        headers: dict[str, str] = {}
+        inject_routing_headers(headers)
+        assert headers["X-UiPath-Internal-TenantId"] == "tenant-123"
+        assert headers["X-UiPath-Internal-AccountId"] == "org-456"
+
+    def test_skips_missing_env_vars(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("UIPATH_TENANT_ID", raising=False)
+        monkeypatch.delenv("UIPATH_ORGANIZATION_ID", raising=False)
+        headers: dict[str, str] = {}
+        inject_routing_headers(headers)
+        assert "X-UiPath-Internal-TenantId" not in headers
+        assert "X-UiPath-Internal-AccountId" not in headers
+
+    def test_does_not_overwrite_existing_headers(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_TENANT_ID", "tenant-123")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "org-456")
+        headers: dict[str, str] = {"X-Custom": "keep-me"}
+        inject_routing_headers(headers)
+        assert headers["X-Custom"] == "keep-me"
+        assert headers["X-UiPath-Internal-TenantId"] == "tenant-123"
diff --git a/packages/uipath-platform/tests/services/test_span_utils.py b/packages/uipath-platform/tests/services/test_span_utils.py
new file mode 100644
index 000000000..35c2b78e7
--- /dev/null
+++ b/packages/uipath-platform/tests/services/test_span_utils.py
@@ -0,0 +1,715 @@
+import json
+import os
+from datetime import datetime
+from unittest.mock import Mock, patch
+
+import pytest
+from opentelemetry.sdk.trace import Span as OTelSpan
+from opentelemetry.trace import SpanContext, StatusCode
+
+from uipath.platform.common import UiPathSpan, _SpanUtils
+from uipath.platform.common.constants import (
+    ENV_PROJECT_KEY,
+    ENV_UIPATH_AGENT_ID,
+    ENV_UIPATH_PROJECT_ID,
+)
+
+
+@pytest.fixture(autouse=True)
+def _clear_id_cache():
+    """Isolate the process-global id cache between tests."""
+    from uipath.platform.common._span_utils import _read_config_id
+
+    _read_config_id.cache_clear()
+    yield
+    _read_config_id.cache_clear()
+
+
+class TestOTelToUiPathSpan:
+    """OTEL attribute -> top-level UiPathSpan field mapping.
+
+    `_SpanUtils.otel_span_to_uipath_span` lifts a small set of OTEL
+    span attributes onto dedicated `UiPathSpan` fields surfaced under
+    `to_dict()`. This test documents that mapping — adding a new row
+    means the attribute is newly mapped, removing one breaks
+    downstream consumers.
+    """
+
+    ATTRIBUTE_FIELD_MAP = [
+        ("executionType", "execution_type", "ExecutionType", 1),
+        ("agentVersion", "agent_version", "AgentVersion", "1.2.3"),
+        ("agentId", "reference_id", "ReferenceId", "ref-abc"),
+        ("verbosityLevel", "verbosity_level", "VerbosityLevel", 6),
+    ]
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_attributes_map_to_top_level_fields(self) -> None:
+        attrs = {
+            otel_attr: value for otel_attr, _, _, value in self.ATTRIBUTE_FIELD_MAP
+        }
+
+        mock_span = Mock(spec=OTelSpan)
+        mock_context = SpanContext(
+            trace_id=0x123456789ABCDEF0123456789ABCDEF0,
+            span_id=0x0123456789ABCDEF,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = attrs
+        mock_span.events = []
+        mock_span.links = []
+        now_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = now_ns
+        mock_span.end_time = now_ns + 1_000_000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        for _, span_field, top_level_key, value in self.ATTRIBUTE_FIELD_MAP:
+            assert getattr(uipath_span, span_field) == value, span_field
+            assert span_dict[top_level_key] == value, top_level_key
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_verbosity_level_omitted_when_unset(self) -> None:
+        """Spans that don't set verbosityLevel must not carry the key on the wire.
+
+        Backwards compat: pre-existing spans never emitted VerbosityLevel; the
+        LLMOps backend applies its own default. Adding `"VerbosityLevel": null`
+        unconditionally would change the wire format for every existing span.
+        """
+        mock_span = Mock(spec=OTelSpan)
+        mock_context = SpanContext(
+            trace_id=0x123456789ABCDEF0123456789ABCDEF0,
+            span_id=0x0123456789ABCDEF,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+        mock_span.name = "legacy-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {"someOtherAttr": "value"}
+        mock_span.events = []
+        mock_span.links = []
+        now_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = now_ns
+        mock_span.end_time = now_ns + 1_000_000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        assert uipath_span.verbosity_level is None
+        assert "VerbosityLevel" not in span_dict
+
+
+class TestReferenceIdResolution:
+    """`reference_id` resolution chain.
+
+    `reference_id` is derived from the span's resolved `agentId` attribute
+    (which itself goes through `resolve_project_id()`), falling back to the
+    `referenceId` attribute. Falsy values (missing / empty string) at each step
+    fall through to the next source. The `referenceId` fallback exists for
+    backwards compatibility with older producers that only emit that attribute.
+    """
+
+    @pytest.mark.parametrize(
+        ("env_value", "attributes", "expected"),
+        [
+            pytest.param(
+                "env-agent",
+                {"agentId": "attr-agent", "referenceId": "attr-ref"},
+                "env-agent",
+                id="env-var-overrides-attr",
+            ),
+            pytest.param(
+                None,
+                {"agentId": "attr-agent", "referenceId": "attr-ref"},
+                "attr-agent",
+                id="agent-id-attr-when-env-unset",
+            ),
+            pytest.param(
+                None,
+                {"referenceId": "attr-ref"},
+                "attr-ref",
+                id="reference-id-fallback-when-agent-id-missing",
+            ),
+            pytest.param(
+                None,
+                {"agentId": "", "referenceId": "attr-ref"},
+                "attr-ref",
+                id="reference-id-fallback-when-agent-id-empty",
+            ),
+            pytest.param(
+                None,
+                {},
+                None,
+                id="none-when-all-sources-missing",
+            ),
+        ],
+    )
+    def test_reference_id_chain(
+        self,
+        env_value: str | None,
+        attributes: dict[str, object],
+        expected: str | None,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+        monkeypatch.delenv(ENV_UIPATH_AGENT_ID, raising=False)
+        monkeypatch.delenv(ENV_UIPATH_PROJECT_ID, raising=False)
+        if env_value is None:
+            monkeypatch.delenv(ENV_PROJECT_KEY, raising=False)
+        else:
+            monkeypatch.setenv(ENV_PROJECT_KEY, env_value)
+
+        mock_span = Mock(spec=OTelSpan)
+        mock_context = SpanContext(
+            trace_id=0x123456789ABCDEF0123456789ABCDEF0,
+            span_id=0x0123456789ABCDEF,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = attributes
+        mock_span.events = []
+        mock_span.links = []
+        now_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = now_ns
+        mock_span.end_time = now_ns + 1_000_000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        assert uipath_span.reference_id == expected
+
+
+class TestAgentIdResolution:
+    """`agentId` span attribute resolution via `resolve_project_id()`.
+
+    Priority: `uipath.json#id` (cached, read once per process) > `UIPATH_AGENT_ID`
+    / `UIPATH_PROJECT_ID` > the legacy `PROJECT_KEY` env var injected by the
+    executor at runtime. When no source is present the `agentId` attribute is
+    omitted entirely.
+    """
+
+    @staticmethod
+    def _make_span() -> Mock:
+        mock_span = Mock(spec=OTelSpan)
+        mock_context = SpanContext(
+            trace_id=0x123456789ABCDEF0123456789ABCDEF0,
+            span_id=0x0123456789ABCDEF,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {}
+        mock_span.events = []
+        mock_span.links = []
+        now_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = now_ns
+        mock_span.end_time = now_ns + 1_000_000
+        return mock_span
+
+    @staticmethod
+    def _resolve(monkeypatch: pytest.MonkeyPatch, tmp_path) -> object:
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+        monkeypatch.delenv("UIPATH_CONFIG_PATH", raising=False)
+        monkeypatch.delenv(ENV_UIPATH_AGENT_ID, raising=False)
+        monkeypatch.delenv(ENV_UIPATH_PROJECT_ID, raising=False)
+        monkeypatch.chdir(tmp_path)
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(
+            TestAgentIdResolution._make_span(), serialize_attributes=False
+        )
+        attributes = uipath_span.attributes
+        assert isinstance(attributes, dict)
+        return attributes.get("agentId")
+
+    def test_agent_id_from_uipath_json_wins_over_env(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        (tmp_path / "uipath.json").write_text(
+            json.dumps({"id": "00000000-0000-0000-0000-000000000001"})
+        )
+        monkeypatch.setenv(ENV_PROJECT_KEY, "from-env")
+        assert (
+            self._resolve(monkeypatch, tmp_path)
+            == "00000000-0000-0000-0000-000000000001"
+        )
+
+    def test_agent_id_falls_back_to_project_key(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        # No uipath.json on disk.
+        monkeypatch.setenv(ENV_PROJECT_KEY, "from-env")
+        assert self._resolve(monkeypatch, tmp_path) == "from-env"
+
+    def test_agent_id_falls_back_when_config_has_no_id(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        (tmp_path / "uipath.json").write_text(json.dumps({"functions": {}}))
+        monkeypatch.setenv(ENV_PROJECT_KEY, "from-env")
+        assert self._resolve(monkeypatch, tmp_path) == "from-env"
+
+    def test_agent_id_absent_when_no_source(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        monkeypatch.delenv(ENV_PROJECT_KEY, raising=False)
+        assert self._resolve(monkeypatch, tmp_path) is None
+
+    def test_non_guid_config_id_is_ignored_and_falls_back(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        # A malformed (non-GUID) id must not reach ReferenceId; fall back to env.
+        (tmp_path / "uipath.json").write_text(json.dumps({"id": "not-a-guid"}))
+        monkeypatch.setenv(ENV_PROJECT_KEY, "from-env")
+        assert self._resolve(monkeypatch, tmp_path) == "from-env"
+
+    def test_config_id_is_cached(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path
+    ) -> None:
+        from uipath.platform.common._span_utils import _read_config_id
+
+        first = "00000000-0000-0000-0000-000000000001"
+        second = "00000000-0000-0000-0000-000000000002"
+
+        _read_config_id.cache_clear()
+        monkeypatch.delenv("UIPATH_CONFIG_PATH", raising=False)
+        monkeypatch.chdir(tmp_path)
+        config = tmp_path / "uipath.json"
+
+        config.write_text(json.dumps({"id": first}))
+        assert _read_config_id() == first
+
+        # A later edit is not observed: the value is read once and cached.
+        config.write_text(json.dumps({"id": second}))
+        assert _read_config_id() == first
+
+        _read_config_id.cache_clear()
+        assert _read_config_id() == second
+
+
+class TestNormalizeIds:
+    """Tests for OTEL ID normalization functions."""
+
+    def test_normalize_trace_id_from_hex(self):
+        """Test normalizing a 32-char hex trace ID."""
+        trace_id = "1234567890abcdef1234567890abcdef"
+        result = _SpanUtils.normalize_trace_id(trace_id)
+        assert result == "1234567890abcdef1234567890abcdef"
+
+    def test_normalize_trace_id_from_uuid(self):
+        """Test normalizing a UUID format trace ID to hex."""
+        trace_id = "12345678-90ab-cdef-1234-567890abcdef"
+        result = _SpanUtils.normalize_trace_id(trace_id)
+        assert result == "1234567890abcdef1234567890abcdef"
+
+    def test_normalize_trace_id_uppercase(self):
+        """Test normalizing uppercase hex to lowercase."""
+        trace_id = "1234567890ABCDEF1234567890ABCDEF"
+        result = _SpanUtils.normalize_trace_id(trace_id)
+        assert result == "1234567890abcdef1234567890abcdef"
+
+    def test_normalize_trace_id_invalid_length(self):
+        """Test that invalid length raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid trace ID format"):
+            _SpanUtils.normalize_trace_id("1234")
+
+    def test_normalize_span_id_from_hex(self):
+        """Test normalizing a 16-char hex span ID."""
+        span_id = "1234567890abcdef"
+        result = _SpanUtils.normalize_span_id(span_id)
+        assert result == "1234567890abcdef"
+
+    def test_normalize_span_id_from_uuid(self):
+        """Test normalizing a UUID format span ID (takes last 16 chars)."""
+        span_id = "00000000-0000-0000-1234-567890abcdef"
+        result = _SpanUtils.normalize_span_id(span_id)
+        assert result == "1234567890abcdef"
+
+    def test_normalize_span_id_uppercase(self):
+        """Test normalizing uppercase hex to lowercase."""
+        span_id = "1234567890ABCDEF"
+        result = _SpanUtils.normalize_span_id(span_id)
+        assert result == "1234567890abcdef"
+
+    def test_normalize_span_id_invalid_length(self):
+        """Test that invalid length raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid span ID format"):
+            _SpanUtils.normalize_span_id("1234")
+
+
+class TestSpanUtils:
+    @patch.dict(
+        os.environ,
+        {
+            "UIPATH_ORGANIZATION_ID": "test-org",
+            "UIPATH_TENANT_ID": "test-tenant",
+            "UIPATH_FOLDER_KEY": "test-folder",
+            "UIPATH_PROCESS_UUID": "test-process",
+            "UIPATH_JOB_KEY": "test-job",
+        },
+    )
+    def test_otel_span_to_uipath_span(self):
+        # Create a mock OTel span
+        mock_span = Mock(spec=OTelSpan)
+
+        # Set span context
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        # Set span properties
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {
+            "key1": "value1",
+            "key2": 123,
+            "span_type": "CustomSpanType",
+        }
+        mock_span.events = []
+        mock_span.links = []
+
+        # Set times
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000  # 1ms later
+
+        # Convert to UiPath span
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+
+        # Verify the conversion
+        assert isinstance(uipath_span, UiPathSpan)
+        assert uipath_span.name == "test-span"
+        assert uipath_span.status == 1  # OK
+        assert uipath_span.span_type == "CustomSpanType"
+
+        # Verify IDs are in OTEL hex format
+        assert uipath_span.trace_id == "123456789abcdef0123456789abcdef0"  # 32-char hex
+        assert uipath_span.id == "0123456789abcdef"  # 16-char hex
+        assert uipath_span.parent_id is None
+
+        # Verify attributes
+        attributes_value = uipath_span.attributes
+        attributes = (
+            json.loads(attributes_value)
+            if isinstance(attributes_value, str)
+            else attributes_value
+        )
+        assert attributes["key1"] == "value1"
+        assert attributes["key2"] == 123
+
+        # Test with error status
+        mock_span.status.description = "Test error description"
+        mock_span.status.status_code = StatusCode.ERROR
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        assert uipath_span.status == 2  # Error
+
+    @patch.dict(
+        os.environ,
+        {
+            "UIPATH_ORGANIZATION_ID": "test-org",
+            "UIPATH_TENANT_ID": "test-tenant",
+        },
+    )
+    def test_otel_span_to_uipath_span_optimized_path(self):
+        """Test the optimized path where attributes are kept as dict."""
+        # Create a mock OTel span
+        mock_span = Mock(spec=OTelSpan)
+
+        # Set span context
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        # Set span properties
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {
+            "key1": "value1",
+            "key2": 123,
+        }
+        mock_span.events = []
+        mock_span.links = []
+
+        # Set times
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        # Test optimized path: serialize_attributes=False
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(
+            mock_span, serialize_attributes=False
+        )
+
+        # Verify attributes is a dict (not JSON string)
+        assert isinstance(uipath_span.attributes, dict)
+        assert uipath_span.attributes["key1"] == "value1"
+        assert uipath_span.attributes["key2"] == 123
+
+        # Test to_dict with serialize_attributes=False
+        span_dict = uipath_span.to_dict(serialize_attributes=False)
+        assert isinstance(span_dict["Attributes"], dict)
+        assert span_dict["Attributes"]["key1"] == "value1"
+
+        # Test to_dict with serialize_attributes=True
+        span_dict_serialized = uipath_span.to_dict(serialize_attributes=True)
+        assert isinstance(span_dict_serialized["Attributes"], str)
+        attrs = json.loads(span_dict_serialized["Attributes"])
+        assert attrs["key1"] == "value1"
+        assert attrs["key2"] == 123
+
+    @patch.dict(os.environ, {"UIPATH_TRACE_ID": "00000000-0000-4000-8000-000000000000"})
+    def test_otel_span_to_uipath_span_with_env_trace_id_uuid_format(self):
+        """Test that UUID format UIPATH_TRACE_ID is normalized to hex."""
+        # Create a mock OTel span
+        mock_span = Mock(spec=OTelSpan)
+
+        # Set span context
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+
+        # Set span properties
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {}
+        mock_span.events = []
+        mock_span.links = []
+
+        # Set times
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000  # 1ms later
+
+        # Convert to UiPath span
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+
+        # Verify the trace ID is normalized to 32-char hex format
+        assert uipath_span.trace_id == "00000000000040008000000000000000"
+
+    @patch.dict(os.environ, {"UIPATH_TRACE_ID": "1234567890abcdef1234567890abcdef"})
+    def test_otel_span_to_uipath_span_with_env_trace_id_hex_format(self):
+        """Test that hex format UIPATH_TRACE_ID is used directly."""
+        # Create a mock OTel span
+        mock_span = Mock(spec=OTelSpan)
+
+        # Set span context
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            is_remote=False,
+        )
+        mock_span.get_span_context.return_value = mock_context
+
+        # Set span properties
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {}
+        mock_span.events = []
+        mock_span.links = []
+
+        # Set times
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000  # 1ms later
+
+        # Convert to UiPath span
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+
+        # Verify the trace ID is used as-is (lowercase)
+        assert uipath_span.trace_id == "1234567890abcdef1234567890abcdef"
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_includes_execution_type(self):
+        """Test that executionType from attributes becomes top-level ExecutionType."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {"executionType": 0}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        assert span_dict["ExecutionType"] == 0
+        assert uipath_span.execution_type == 0
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_includes_agent_version(self):
+        """Test that agentVersion from attributes becomes top-level AgentVersion."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {"agentVersion": "2.0.0"}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        assert span_dict["AgentVersion"] == "2.0.0"
+        assert uipath_span.agent_version == "2.0.0"
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_execution_type_and_agent_version_both(self):
+        """Test that both executionType and agentVersion are extracted together."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "Agent run - Agent"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {"executionType": 1, "agentVersion": "1.0.0"}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        assert span_dict["ExecutionType"] == 1
+        assert span_dict["AgentVersion"] == "1.0.0"
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_missing_execution_type_and_agent_version(self):
+        """Test that missing executionType and agentVersion default to None."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        mock_span.attributes = {"someOtherAttr": "value"}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        assert span_dict["ExecutionType"] is None
+        assert span_dict["AgentVersion"] is None
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_source_defaults_to_coded_agents(self):
+        """Test that Source defaults to 10 (CodedAgents) and ignores attributes.source."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        # source in attributes should NOT override top-level Source
+        mock_span.attributes = {"source": "runtime"}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        # Top-level Source should be 10 (CodedAgents), string "runtime" is ignored
+        assert uipath_span.source == 10
+        assert span_dict["Source"] == 10
+
+        # attributes.source string should still be in Attributes JSON
+        attrs = json.loads(span_dict["Attributes"])
+        assert attrs["source"] == "runtime"
+
+    @patch.dict(os.environ, {"UIPATH_ORGANIZATION_ID": "test-org"})
+    def test_uipath_span_source_override_with_uipath_source(self):
+        """Test that uipath.source attribute overrides default (for low-code agents)."""
+        mock_span = Mock(spec=OTelSpan)
+
+        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
+        span_id = 0x0123456789ABCDEF
+        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
+        mock_span.get_span_context.return_value = mock_context
+
+        mock_span.name = "test-span"
+        mock_span.parent = None
+        mock_span.status.status_code = StatusCode.OK
+        # uipath.source=1 (Agents) overrides default of 10 (CodedAgents)
+        mock_span.attributes = {"uipath.source": 1, "source": "runtime"}
+        mock_span.events = []
+        mock_span.links = []
+
+        current_time_ns = int(datetime.now().timestamp() * 1e9)
+        mock_span.start_time = current_time_ns
+        mock_span.end_time = current_time_ns + 1000000
+
+        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
+        span_dict = uipath_span.to_dict()
+
+        # uipath.source overrides - low-code agents use 1 (Agents)
+        assert uipath_span.source == 1
+        assert span_dict["Source"] == 1
+
+        # String source still in Attributes JSON
+        attrs = json.loads(span_dict["Attributes"])
+        assert attrs["source"] == "runtime"
diff --git a/tests/sdk/services/test_uipath_llm_integration.py b/packages/uipath-platform/tests/services/test_uipath_llm_integration.py
similarity index 80%
rename from tests/sdk/services/test_uipath_llm_integration.py
rename to packages/uipath-platform/tests/services/test_uipath_llm_integration.py
index f00aa25ce..9e2292c60 100644
--- a/tests/sdk/services/test_uipath_llm_integration.py
+++ b/packages/uipath-platform/tests/services/test_uipath_llm_integration.py
@@ -1,22 +1,19 @@
-import json
 import os
 from unittest.mock import MagicMock, patch
 
 import pytest
 
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.llm_gateway_service import (
-    ChatModels,
-    UiPathLlmChatService,
-)
-from uipath.models.llm_gateway import (
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import (
     AutoToolChoice,
+    ChatModels,
+    RequiredToolChoice,
     SpecificToolChoice,
     ToolDefinition,
     ToolFunctionDefinition,
     ToolParametersDefinition,
     ToolPropertyDefinition,
+    UiPathLlmChatService,
 )
 
 
@@ -39,8 +36,8 @@ def llm_service(self):
         base_url = get_env_var("UIPATH_URL")
         api_key = get_env_var("UIPATH_ACCESS_TOKEN")
 
-        config = Config(base_url=base_url, secret=api_key)
-        execution_context = ExecutionContext()
+        config = UiPathApiConfig(base_url=base_url, secret=api_key)
+        execution_context = UiPathExecutionContext()
         return UiPathLlmChatService(config=config, execution_context=execution_context)
 
     @pytest.mark.asyncio
@@ -53,7 +50,7 @@ async def test_basic_chat_completions(self, llm_service):
 
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=50,
             temperature=0,
         )
@@ -104,7 +101,7 @@ async def test_tool_call_required(self, llm_service):
 
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=250,
             temperature=0,
             tools=[test_tool],
@@ -158,7 +155,7 @@ async def test_chat_with_conversation_history(self, llm_service):
 
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=250,
             temperature=0,
             frequency_penalty=1,
@@ -188,7 +185,7 @@ async def test_no_tools(self, llm_service):
 
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=100,
             temperature=0.7,
         )
@@ -208,11 +205,11 @@ async def test_no_tools(self, llm_service):
 class TestUiPathLLMServiceMocked:
     @pytest.fixture
     def config(self):
-        return Config(base_url="https://example.com", secret="test_secret")
+        return UiPathApiConfig(base_url="https://example.com", secret="test_secret")
 
     @pytest.fixture
     def execution_context(self):
-        return ExecutionContext()
+        return UiPathExecutionContext()
 
     @pytest.fixture
     def llm_service(self, config, execution_context):
@@ -263,7 +260,7 @@ async def test_basic_chat_completions_mocked(self, mock_request, llm_service):
         # Call the method
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=50,
             temperature=0,
         )
@@ -279,10 +276,10 @@ async def test_basic_chat_completions_mocked(self, mock_request, llm_service):
 
         # Verify the correct endpoint and payload
         args, kwargs = mock_request.call_args
-        assert "/llmgateway_/api/chat/completions" in args[1]
-        assert json.loads(kwargs["content"])["messages"] == messages
-        assert json.loads(kwargs["content"])["max_tokens"] == 50
-        assert json.loads(kwargs["content"])["temperature"] == 0
+        assert "/orchestrator_/llm/api/chat/completions" in args[1]
+        assert kwargs["json"]["messages"] == messages
+        assert kwargs["json"]["max_tokens"] == 50
+        assert kwargs["json"]["temperature"] == 0
 
     @pytest.mark.asyncio
     @patch.object(UiPathLlmChatService, "request_async")
@@ -356,7 +353,7 @@ async def test_tool_call_required_mocked(self, mock_request, llm_service):
         # Call the method
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=250,
             temperature=0,
             tools=[test_tool],
@@ -373,6 +370,87 @@ async def test_tool_call_required_mocked(self, mock_request, llm_service):
         assert result.choices[0].message.tool_calls[0].arguments["name"] == "John"
         assert result.choices[0].message.tool_calls[0].arguments["password"] == "1234"
 
+    @pytest.mark.asyncio
+    @patch.object(UiPathLlmChatService, "request_async")
+    async def test_raw_dict_tool_passthrough_mocked(self, mock_request, llm_service):
+        """A tool supplied as a raw dict is sent unchanged, preserving nested schema.
+
+        ToolDefinition's converter only emits flat properties, so callers that need
+        an arbitrary nested JSON schema (e.g. the eval mockers) pass the tool as a
+        dict already in UiPath wire format. It must reach the gateway verbatim.
+        """
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "id": "chatcmpl-raw",
+            "object": "chat.completion",
+            "created": 1677858242,
+            "model": "gpt-4o-mini-2024-07-18",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "call_raw",
+                                "name": "submit_tool_response",
+                                "arguments": {"response": {"items": [{"sku": "A1"}]}},
+                            }
+                        ],
+                    },
+                    "finish_reason": "tool_calls",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 5,
+                "total_tokens": 15,
+                "cache_read_input_tokens": None,
+            },
+        }
+        mock_request.return_value = mock_response
+
+        nested_tool = {
+            "name": "submit_tool_response",
+            "description": "Return the simulated response matching the schema.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "response": {
+                        "type": "object",
+                        "properties": {
+                            "items": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {"sku": {"type": "string"}},
+                                },
+                            }
+                        },
+                    }
+                },
+                "required": ["response"],
+            },
+        }
+
+        result = await llm_service.chat_completions(
+            messages=[{"role": "user", "content": "go"}],
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
+            tools=[nested_tool],
+            tool_choice=RequiredToolChoice(),
+        )
+
+        mock_request.assert_called_once()
+        _, kwargs = mock_request.call_args
+        body = kwargs["json"]
+        # The dict tool is forwarded byte-for-byte, nested array schema intact.
+        assert body["tools"] == [nested_tool]
+        assert body["tool_choice"] == {"type": "required"}
+        assert result.choices[0].message.tool_calls[0].arguments == {
+            "response": {"items": [{"sku": "A1"}]}
+        }
+
     @pytest.mark.asyncio
     @patch.object(UiPathLlmChatService, "request_async")
     async def test_chat_with_conversation_history_mocked(
@@ -439,7 +517,7 @@ async def test_chat_with_conversation_history_mocked(
         # Call the method
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=250,
             temperature=0,
             frequency_penalty=1,
@@ -494,7 +572,7 @@ async def test_no_tools_mocked(self, mock_request, llm_service):
         # Call the method
         result = await llm_service.chat_completions(
             messages=messages,
-            model=ChatModels.gpt_4o_mini_2024_07_18,
+            model=ChatModels.gpt_4_1_mini_2025_04_14,
             max_tokens=100,
             temperature=0.7,
         )
@@ -509,6 +587,6 @@ async def test_no_tools_mocked(self, mock_request, llm_service):
 
         # Verify the correct payload was sent
         args, kwargs = mock_request.call_args
-        assert json.loads(kwargs["content"])["messages"] == messages
-        assert json.loads(kwargs["content"])["max_tokens"] == 100
-        assert json.loads(kwargs["content"])["temperature"] == 0.7
+        assert kwargs["json"]["messages"] == messages
+        assert kwargs["json"]["max_tokens"] == 100
+        assert kwargs["json"]["temperature"] == 0.7
diff --git a/packages/uipath-platform/tests/services/tests_data/documents_service/classification_response.json b/packages/uipath-platform/tests/services/tests_data/documents_service/classification_response.json
new file mode 100644
index 000000000..a815fc783
--- /dev/null
+++ b/packages/uipath-platform/tests/services/tests_data/documents_service/classification_response.json
@@ -0,0 +1,23 @@
+{
+  "classificationResults": [
+    {
+      "DocumentTypeId": "0d209d75-9afd-ef11-aaa7-000d3a234147",
+      "DocumentId": "0a9f9927-e6af-f011-8e60-6045bd9ba6d0",
+      "Confidence": 0.53288215,
+      "OcrConfidence": -1.0,
+      "Reference": {
+        "TextStartIndex": 0,
+        "TextLength": 0,
+        "Tokens": []
+      },
+      "DocumentBounds": {
+        "StartPage": 0,
+        "PageCount": 1,
+        "TextStartIndex": 0,
+        "TextLength": 629,
+        "PageRange": "1"
+      },
+      "ClassifierName": "Production_classifier"
+    }
+  ]
+}
diff --git a/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_completed.json b/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_completed.json
new file mode 100644
index 000000000..0f340b00e
--- /dev/null
+++ b/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_completed.json
@@ -0,0 +1,1277 @@
+{
+  "actionData": {
+    "type": "Validation",
+    "id": 10432640,
+    "status": "Completed",
+    "title": "Test Validation Action",
+    "priority": "Medium",
+    "taskCatalogName": "default_du_actions",
+    "taskUrl": "https://dummy.uipath.com/82e69757-09ff-4e6d-83e7-d530f2a99999/bd829329-42ff-40aa-96dc-95a781699999/actions_/tasks/10499999",
+    "folderPath": "Shared",
+    "folderId": 1744784,
+    "data": {
+      "automaticExtractionResultsPath": "TestDirectory/12c04908-67f0-f011-8196-6045bd99999/input_results.zip",
+      "validatedExtractionResultsPath": "TestDirectory/12c04908-67f0-f011-8196-6045bd99999/output_results.zip",
+      "documentRejectionDetails": null
+    },
+    "action": "Completed",
+    "isDeleted": false,
+    "assignedToUser": {
+      "id": 4303796,
+      "emailAddress": "dummy.dummy@dummy.com"
+    },
+    "creatorUser": null,
+    "deleterUser": null,
+    "lastModifierUser": {
+      "id": 4303796,
+      "emailAddress": "dummy.dummy@dummy.com"
+    },
+    "completedByUser": {
+      "id": 4303796,
+      "emailAddress": "dummy.dummy@dummy.com"
+    },
+    "creationTime": "2026-01-22T10:03:02.9434351Z",
+    "lastAssignedTime": "2026-01-22T10:03:45.587Z",
+    "completionTime": "2026-01-22T10:03:56.71Z",
+    "processingTime": null
+  },
+  "validatedExtractionResults": {
+    "DocumentId": "47f037fe-66f0-f011-8196-6045bd99999",
+    "ResultsVersion": 1,
+    "ResultsDocument": {
+      "Bounds": {
+        "StartPage": 0,
+        "PageCount": 1,
+        "TextStartIndex": 0,
+        "TextLength": 635,
+        "PageRange": "1"
+      },
+      "Language": "eng",
+      "DocumentGroup": "",
+      "DocumentCategory": "",
+      "DocumentTypeId": "00000000-0000-0000-0000-000000000000",
+      "DocumentTypeName": "Default",
+      "DocumentTypeDataVersion": 0,
+      "DataVersion": 1,
+      "DocumentTypeSource": "Automatic",
+      "DocumentTypeField": {
+        "Components": [],
+        "Value": "Default",
+        "UnformattedValue": "",
+        "Reference": { "TextStartIndex": 0, "TextLength": 0, "Tokens": [] },
+        "DerivedFields": [],
+        "Confidence": 1.0,
+        "OperatorConfirmed": true,
+        "OcrConfidence": 1.0,
+        "TextType": "Unknown",
+        "ValidatorNotes": "",
+        "ValidatorNotesInfo": ""
+      },
+      "Fields": [
+        {
+          "FieldId": "Uber Receipt",
+          "FieldName": "Uber Receipt",
+          "FieldType": "Table",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [
+                {
+                  "FieldId": "Uber Receipt.Header",
+                  "FieldName": "Header",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Date of Trip",
+                          "FieldName": "Date of Trip",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Date of Trip",
+                              "UnformattedValue": "Date of Trip",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Customer Name",
+                          "FieldName": "Customer Name",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Customer Name",
+                              "UnformattedValue": "Customer Name",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Total Amount Paid",
+                          "FieldName": "Total Amount Paid",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Total Amount Paid",
+                              "UnformattedValue": "Total Amount Paid",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": true,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                },
+                {
+                  "FieldId": "Uber Receipt.Body",
+                  "FieldName": "Body",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Date of Trip",
+                          "FieldName": "Date of Trip",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "12/11/2023 00:00:00",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 565,
+                                "TextLength": 17,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 565,
+                                    "TextLength": 8,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [47.2702, 464.3362, 33.9578, 5.9088]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 574,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [47.2702, 500.5087, 6.6439, 5.9088]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 574,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [47.2702, 507.8908, 1.4764, 5.9088]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 578,
+                                    "TextLength": 4,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [47.2702, 511.5819, 16.2407, 5.9088]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Customer Name",
+                          "FieldName": "Customer Name",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Alex",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 41,
+                                "TextLength": 5,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 41,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [84.2, 275.3536, 33.9578, 13.2947]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Total Amount Paid",
+                          "FieldName": "Total Amount Paid",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "66.79 RON",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 584,
+                                "TextLength": 9,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 584,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [146.2421, 473.933, 22.1464, 8.1246]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 588,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [146.2421, 500.5087, 26.5757, 8.1246]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": true,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                }
+              ],
+              "Value": "",
+              "UnformattedValue": "",
+              "Reference": {
+                "TextStartIndex": 0,
+                "TextLength": 0,
+                "Tokens": []
+              },
+              "DerivedFields": [],
+              "Confidence": 1.0,
+              "OperatorConfirmed": true,
+              "OcrConfidence": 1.0,
+              "TextType": "Unknown",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": true,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        },
+        {
+          "FieldId": "Uber Receipt > Fare Breakdown",
+          "FieldName": "Uber Receipt > Fare Breakdown",
+          "FieldType": "Table",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [
+                {
+                  "FieldId": "Uber Receipt > Fare Breakdown.Header",
+                  "FieldName": "Header",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Fare Amount",
+                          "FieldName": "Fare Amount",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Fare Amount",
+                              "UnformattedValue": "Fare Amount",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Subtotal",
+                          "FieldName": "Subtotal",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Subtotal",
+                              "UnformattedValue": "Subtotal",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Promotion Amount",
+                          "FieldName": "Promotion Amount",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Promotion Amount",
+                              "UnformattedValue": "Promotion Amount",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": true,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                },
+                {
+                  "FieldId": "Uber Receipt > Fare Breakdown.Body",
+                  "FieldName": "Body",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Fare Amount",
+                          "FieldName": "Fare Amount",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "65.29 RON",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 595,
+                                "TextLength": 9,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 595,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [187.6035, 493.8648, 14.026, 4.4316]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 599,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [187.6035, 509.3672, 16.9789, 4.4316]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Subtotal",
+                          "FieldName": "Subtotal",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "65.29 RON",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 606,
+                                "TextLength": 9,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 606,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [224.5333, 491.6501, 14.7643, 5.1702]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 610,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [224.5333, 508.629, 18.4553, 5.1702]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 1.0,
+                              "OperatorConfirmed": true,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Promotion Amount",
+                          "FieldName": "Promotion Amount",
+                          "FieldType": "Text",
+                          "IsMissing": true,
+                          "DataSource": "Automatic",
+                          "Values": [],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": true,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": true,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                }
+              ],
+              "Value": "",
+              "UnformattedValue": "",
+              "Reference": {
+                "TextStartIndex": 0,
+                "TextLength": 0,
+                "Tokens": []
+              },
+              "DerivedFields": [],
+              "Confidence": 1.0,
+              "OperatorConfirmed": true,
+              "OcrConfidence": 1.0,
+              "TextType": "Unknown",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": true,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        }
+      ],
+      "Tables": [
+        {
+          "FieldId": "Uber Receipt",
+          "FieldName": "Uber Receipt",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "DataVersion": 0,
+          "OperatorConfirmed": true,
+          "Values": [
+            {
+              "OperatorConfirmed": true,
+              "Confidence": 1.0,
+              "OcrConfidence": 1.0,
+              "Cells": [
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 0,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Date of Trip",
+                      "UnformattedValue": "Date of Trip",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 1,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Customer Name",
+                      "UnformattedValue": "Customer Name",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 2,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Total Amount Paid",
+                      "UnformattedValue": "Total Amount Paid",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 0,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "12/11/2023 00:00:00",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 565,
+                        "TextLength": 17,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 565,
+                            "TextLength": 8,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[47.2702, 464.3362, 33.9578, 5.9088]]
+                          },
+                          {
+                            "TextStartIndex": 574,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[47.2702, 500.5087, 6.6439, 5.9088]]
+                          },
+                          {
+                            "TextStartIndex": 574,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[47.2702, 507.8908, 1.4764, 5.9088]]
+                          },
+                          {
+                            "TextStartIndex": 578,
+                            "TextLength": 4,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[47.2702, 511.5819, 16.2407, 5.9088]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 1,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Alex",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 41,
+                        "TextLength": 5,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 41,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[84.2, 275.3536, 33.9578, 13.2947]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 2,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "66.79 RON",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 584,
+                        "TextLength": 9,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 584,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[146.2421, 473.933, 22.1464, 8.1246]]
+                          },
+                          {
+                            "TextStartIndex": 588,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[146.2421, 500.5087, 26.5757, 8.1246]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                }
+              ],
+              "ColumnInfo": [
+                {
+                  "FieldId": "Date of Trip",
+                  "FieldName": "Date of Trip",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "Customer Name",
+                  "FieldName": "Customer Name",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "Total Amount Paid",
+                  "FieldName": "Total Amount Paid",
+                  "FieldType": "Text"
+                }
+              ],
+              "NumberOfRows": 2,
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        },
+        {
+          "FieldId": "Uber Receipt > Fare Breakdown",
+          "FieldName": "Uber Receipt > Fare Breakdown",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "DataVersion": 0,
+          "OperatorConfirmed": true,
+          "Values": [
+            {
+              "OperatorConfirmed": true,
+              "Confidence": 1.0,
+              "OcrConfidence": 1.0,
+              "Cells": [
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 0,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Fare Amount",
+                      "UnformattedValue": "Fare Amount",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 1,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Subtotal",
+                      "UnformattedValue": "Subtotal",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 2,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Promotion Amount",
+                      "UnformattedValue": "Promotion Amount",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 0,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "65.29 RON",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 595,
+                        "TextLength": 9,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 595,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[187.6035, 493.8648, 14.026, 4.4316]]
+                          },
+                          {
+                            "TextStartIndex": 599,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[187.6035, 509.3672, 16.9789, 4.4316]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 1,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "65.29 RON",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 606,
+                        "TextLength": 9,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 606,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[224.5333, 491.6501, 14.7643, 5.1702]]
+                          },
+                          {
+                            "TextStartIndex": 610,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[224.5333, 508.629, 18.4553, 5.1702]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 1.0,
+                      "OperatorConfirmed": true,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 2,
+                  "IsHeader": false,
+                  "IsMissing": true,
+                  "OperatorConfirmed": true,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": []
+                }
+              ],
+              "ColumnInfo": [
+                {
+                  "FieldId": "Fare Amount",
+                  "FieldName": "Fare Amount",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "Subtotal",
+                  "FieldName": "Subtotal",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "Promotion Amount",
+                  "FieldName": "Promotion Amount",
+                  "FieldType": "Text"
+                }
+              ],
+              "NumberOfRows": 2,
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        }
+      ]
+    },
+    "ExtractorPayloads": null,
+    "BusinessRulesResults": null
+  },
+  "dataProjection": [
+    {
+      "fieldGroupName": "Uber Receipt",
+      "fieldValues": [
+        {
+          "id": "Date of Trip",
+          "name": "Date of Trip",
+          "value": "12/11/2023 00:00:00",
+          "unformattedValue": "",
+          "confidence": 1,
+          "ocrConfidence": 1,
+          "type": "Text"
+        },
+        {
+          "id": "Customer Name",
+          "name": "Customer Name",
+          "value": "Alex",
+          "unformattedValue": "",
+          "confidence": 1,
+          "ocrConfidence": 1,
+          "type": "Text"
+        },
+        {
+          "id": "Total Amount Paid",
+          "name": "Total Amount Paid",
+          "value": "66.79 RON",
+          "unformattedValue": "",
+          "confidence": 1,
+          "ocrConfidence": 1,
+          "type": "Text"
+        }
+      ]
+    },
+    {
+      "fieldGroupName": "Uber Receipt > Fare Breakdown",
+      "fieldValues": [
+        {
+          "id": "Fare Amount",
+          "name": "Fare Amount",
+          "value": "65.29 RON",
+          "unformattedValue": "",
+          "confidence": 1,
+          "ocrConfidence": 1,
+          "type": "Text"
+        },
+        {
+          "id": "Subtotal",
+          "name": "Subtotal",
+          "value": "65.29 RON",
+          "unformattedValue": "",
+          "confidence": 1,
+          "ocrConfidence": 1,
+          "type": "Text"
+        },
+        {
+          "id": "Promotion Amount",
+          "name": "Promotion Amount",
+          "value": null,
+          "unformattedValue": null,
+          "confidence": null,
+          "ocrConfidence": null,
+          "type": "Text"
+        }
+      ]
+    }
+  ],
+  "actionStatus": "Completed"
+}
diff --git a/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_unassigned.json b/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_unassigned.json
new file mode 100644
index 000000000..d3342117a
--- /dev/null
+++ b/packages/uipath-platform/tests/services/tests_data/documents_service/extraction_validation_action_response_unassigned.json
@@ -0,0 +1,29 @@
+{
+  "actionData": {
+    "type": "Validation",
+    "id": 7372483,
+    "status": "Unassigned",
+    "title": "Auto Validation",
+    "priority": "Medium",
+    "taskCatalogName": "default_du_actions",
+    "taskUrl": "https://dummy.uipath.com/40921a85-2b9d-44ea-8655-abf869de8588/f994a44a-10d7-44cf-a1c1-a9f20b469ac3/actions_/tasks/7372483",
+    "folderPath": "Shared",
+    "folderId": 249142,
+    "data": {
+      "automaticExtractionResultsPath": "Dummy/e777cf4c-2083-f011-b484-000d3a2a9e3c/input_results.zip",
+      "validatedExtractionResultsPath": "Dummy/e777cf4c-2083-f011-b484-000d3a2a9e3c/output_results.zip",
+      "documentRejectionDetails": null
+    },
+    "action": null,
+    "isDeleted": false,
+    "assignedToUser": null,
+    "creatorUser": null,
+    "deleterUser": null,
+    "lastModifierUser": null,
+    "completedByUser": null,
+    "creationTime": "2025-08-27T08:32:02.7115597Z",
+    "lastAssignedTime": null,
+    "completionTime": null
+  },
+  "actionStatus": "Unassigned"
+}
diff --git a/packages/uipath-platform/tests/services/tests_data/documents_service/ixp_extraction_response.json b/packages/uipath-platform/tests/services/tests_data/documents_service/ixp_extraction_response.json
new file mode 100644
index 000000000..219f37e5f
--- /dev/null
+++ b/packages/uipath-platform/tests/services/tests_data/documents_service/ixp_extraction_response.json
@@ -0,0 +1,1078 @@
+{
+  "extractionResult": {
+    "DocumentId": "8253c809-2dbe-f011-8194-000d3a296f55",
+    "ResultsVersion": 0,
+    "ResultsDocument": {
+      "Bounds": {
+        "StartPage": 0,
+        "PageCount": 1,
+        "TextStartIndex": 0,
+        "TextLength": 629,
+        "PageRange": "1"
+      },
+      "Language": "eng",
+      "DocumentGroup": "",
+      "DocumentCategory": "",
+      "DocumentTypeId": "00000000-0000-0000-0000-000000000000",
+      "DocumentTypeName": "Default",
+      "DocumentTypeDataVersion": 0,
+      "DataVersion": 0,
+      "DocumentTypeSource": "Automatic",
+      "DocumentTypeField": {
+        "Components": [],
+        "Value": "Default",
+        "UnformattedValue": "",
+        "Reference": {
+          "TextStartIndex": 0,
+          "TextLength": 0,
+          "Tokens": []
+        },
+        "DerivedFields": [],
+        "Confidence": 1.0,
+        "OperatorConfirmed": false,
+        "OcrConfidence": -1.0,
+        "TextType": "Unknown",
+        "ValidatorNotes": "",
+        "ValidatorNotesInfo": ""
+      },
+      "Fields": [
+        {
+          "FieldId": "Details",
+          "FieldName": "Details",
+          "FieldType": "Table",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [
+                {
+                  "FieldId": "Details.Header",
+                  "FieldName": "Header",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Total",
+                          "FieldName": "Total",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Total",
+                              "UnformattedValue": "Total",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": -1.0,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "From",
+                          "FieldName": "From",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "From",
+                              "UnformattedValue": "From",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": -1.0,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "To",
+                          "FieldName": "To",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "To",
+                              "UnformattedValue": "To",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": -1.0,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Dummy field",
+                          "FieldName": "Dummy field",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Dummy field",
+                              "UnformattedValue": "Dummy field",
+                              "Reference": {
+                                "TextStartIndex": 0,
+                                "TextLength": 0,
+                                "Tokens": []
+                              },
+                              "DerivedFields": [],
+                              "Confidence": -1.0,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Unknown",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": -1.0,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": false,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                },
+                {
+                  "FieldId": "Details.Body",
+                  "FieldName": "Body",
+                  "FieldType": "Internal",
+                  "IsMissing": false,
+                  "DataSource": "Automatic",
+                  "Values": [
+                    {
+                      "Components": [
+                        {
+                          "FieldId": "Total",
+                          "FieldName": "Total",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "66.79 RON",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 620,
+                                "TextLength": 9,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 620,
+                                    "TextLength": 3,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [304.3017, 479.8387, 19.9318, 6.6474]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 624,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [304.3017, 503.4615, 23.6228, 6.6474]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 0.9975757,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "From",
+                          "FieldName": "From",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Aleea Muscel 9, Cluj-Napoca 400347, Romania",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 337,
+                                "TextLength": 43,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 337,
+                                    "TextLength": 5,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 122.5434, 19.1935, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 343,
+                                    "TextLength": 6,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 143.9516, 22.8846, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 350,
+                                    "TextLength": 2,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 168.3126, 4.4293, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 350,
+                                    "TextLength": 2,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 172.7419, 2.2147, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 353,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 176.433, 12.5496, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 353,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 188.9826, 2.9528, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 353,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 191.1973, 24.361, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 365,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 217.773, 24.361, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 365,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 242.134, 2.2147, 7.386]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 373,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [423.9544, 246.5633, 28.7903, 7.386]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 0.9979634,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "To",
+                          "FieldName": "To",
+                          "FieldType": "Text",
+                          "IsMissing": false,
+                          "DataSource": "Automatic",
+                          "Values": [
+                            {
+                              "Components": [],
+                              "Value": "Strada Traian Vuia 149-151, Cluj-Napoca 400397, Romania",
+                              "UnformattedValue": "",
+                              "Reference": {
+                                "TextStartIndex": 391,
+                                "TextLength": 55,
+                                "Tokens": [
+                                  {
+                                    "TextStartIndex": 391,
+                                    "TextLength": 6,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 123.2816, 22.1464, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 398,
+                                    "TextLength": 6,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 146.9045, 19.9318, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 405,
+                                    "TextLength": 4,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 168.3126, 15.5025, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 410,
+                                    "TextLength": 8,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 186.0298, 25.0992, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 410,
+                                    "TextLength": 8,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 211.8672, 2.2147, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 419,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 215.5583, 12.5496, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 419,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 228.1079, 2.9528, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 419,
+                                    "TextLength": 11,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 231.0608, 24.361, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 431,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 256.8983, 25.0992, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 431,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 281.2593, 2.2147, 7.3859]
+                                    ]
+                                  },
+                                  {
+                                    "TextStartIndex": 439,
+                                    "TextLength": 7,
+                                    "Page": 0,
+                                    "PageWidth": 595.0,
+                                    "PageHeight": 842.0,
+                                    "Boxes": [
+                                      [443.1579, 285.6886, 28.7903, 7.3859]
+                                    ]
+                                  }
+                                ]
+                              },
+                              "DerivedFields": [],
+                              "Confidence": 0.99986005,
+                              "OperatorConfirmed": false,
+                              "OcrConfidence": 1.0,
+                              "TextType": "Text",
+                              "ValidatorNotes": "",
+                              "ValidatorNotesInfo": ""
+                            }
+                          ],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        },
+                        {
+                          "FieldId": "Dummy field",
+                          "FieldName": "Dummy field",
+                          "FieldType": "Text",
+                          "IsMissing": true,
+                          "DataSource": "Automatic",
+                          "Values": [],
+                          "DataVersion": 0,
+                          "OperatorConfirmed": false,
+                          "ValidatorNotes": "",
+                          "ValidatorNotesInfo": ""
+                        }
+                      ],
+                      "Value": "",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 0.9975757,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ],
+                  "DataVersion": 0,
+                  "OperatorConfirmed": false,
+                  "ValidatorNotes": "",
+                  "ValidatorNotesInfo": ""
+                }
+              ],
+              "Value": "",
+              "UnformattedValue": "",
+              "Reference": {
+                "TextStartIndex": 0,
+                "TextLength": 0,
+                "Tokens": []
+              },
+              "DerivedFields": [],
+              "Confidence": 0.9975757,
+              "OperatorConfirmed": true,
+              "OcrConfidence": 1.0,
+              "TextType": "Unknown",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        }
+      ],
+      "Tables": [
+        {
+          "FieldId": "Details",
+          "FieldName": "Details",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "Values": [
+            {
+              "OperatorConfirmed": true,
+              "Confidence": 0.9975757,
+              "OcrConfidence": 1.0,
+              "Cells": [
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 0,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Total",
+                      "UnformattedValue": "Total",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": -1.0,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 1,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "From",
+                      "UnformattedValue": "From",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": -1.0,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 2,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "To",
+                      "UnformattedValue": "To",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": -1.0,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 0,
+                  "ColumnIndex": 3,
+                  "IsHeader": true,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Dummy field",
+                      "UnformattedValue": "Dummy field",
+                      "Reference": {
+                        "TextStartIndex": 0,
+                        "TextLength": 0,
+                        "Tokens": []
+                      },
+                      "DerivedFields": [],
+                      "Confidence": -1.0,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Unknown",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 0,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "66.79 RON",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 620,
+                        "TextLength": 9,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 620,
+                            "TextLength": 3,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[304.3017, 479.8387, 19.9318, 6.6474]]
+                          },
+                          {
+                            "TextStartIndex": 624,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[304.3017, 503.4615, 23.6228, 6.6474]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 0.9975757,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 1,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Aleea Muscel 9, Cluj-Napoca 400347, Romania",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 337,
+                        "TextLength": 43,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 337,
+                            "TextLength": 5,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 122.5434, 19.1935, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 343,
+                            "TextLength": 6,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 143.9516, 22.8846, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 350,
+                            "TextLength": 2,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 168.3126, 4.4293, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 350,
+                            "TextLength": 2,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 172.7419, 2.2147, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 353,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 176.433, 12.5496, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 353,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 188.9826, 2.9528, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 353,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 191.1973, 24.361, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 365,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 217.773, 24.361, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 365,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 242.134, 2.2147, 7.386]]
+                          },
+                          {
+                            "TextStartIndex": 373,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[423.9544, 246.5633, 28.7903, 7.386]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 0.9979634,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 2,
+                  "IsHeader": false,
+                  "IsMissing": false,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": [
+                    {
+                      "Components": [],
+                      "Value": "Strada Traian Vuia 149-151, Cluj-Napoca 400397, Romania",
+                      "UnformattedValue": "",
+                      "Reference": {
+                        "TextStartIndex": 391,
+                        "TextLength": 55,
+                        "Tokens": [
+                          {
+                            "TextStartIndex": 391,
+                            "TextLength": 6,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 123.2816, 22.1464, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 398,
+                            "TextLength": 6,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 146.9045, 19.9318, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 405,
+                            "TextLength": 4,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 168.3126, 15.5025, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 410,
+                            "TextLength": 8,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 186.0298, 25.0992, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 410,
+                            "TextLength": 8,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 211.8672, 2.2147, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 419,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 215.5583, 12.5496, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 419,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 228.1079, 2.9528, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 419,
+                            "TextLength": 11,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 231.0608, 24.361, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 431,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 256.8983, 25.0992, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 431,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 281.2593, 2.2147, 7.3859]]
+                          },
+                          {
+                            "TextStartIndex": 439,
+                            "TextLength": 7,
+                            "Page": 0,
+                            "PageWidth": 595.0,
+                            "PageHeight": 842.0,
+                            "Boxes": [[443.1579, 285.6886, 28.7903, 7.3859]]
+                          }
+                        ]
+                      },
+                      "DerivedFields": [],
+                      "Confidence": 0.99986005,
+                      "OperatorConfirmed": false,
+                      "OcrConfidence": 1.0,
+                      "TextType": "Text",
+                      "ValidatorNotes": "",
+                      "ValidatorNotesInfo": ""
+                    }
+                  ]
+                },
+                {
+                  "RowIndex": 1,
+                  "ColumnIndex": 3,
+                  "IsHeader": false,
+                  "IsMissing": true,
+                  "OperatorConfirmed": false,
+                  "DataSource": "Automatic",
+                  "DataVersion": 0,
+                  "Values": []
+                }
+              ],
+              "ColumnInfo": [
+                {
+                  "FieldId": "Total",
+                  "FieldName": "Total",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "From",
+                  "FieldName": "From",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "To",
+                  "FieldName": "To",
+                  "FieldType": "Text"
+                },
+                {
+                  "FieldId": "Dummy field",
+                  "FieldName": "Dummy field",
+                  "FieldType": "Text"
+                }
+              ],
+              "NumberOfRows": 2,
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        }
+      ]
+    },
+    "ExtractorPayloads": null,
+    "BusinessRulesResults": null
+  },
+  "projectId": "c390c3ab-358a-80ee-9dcf-9ea0d5ca7bb3",
+  "projectType": "IXP",
+  "tag": "live",
+  "documentTypeId": "00000000-0000-0000-0000-000000000000",
+  "dataProjection": [
+    {
+      "fieldGroupName": "Details",
+      "fieldValues": [
+        {
+          "id": "Total",
+          "name": "Total",
+          "value": "66.79 RON",
+          "unformattedValue": "",
+          "confidence": 0.9975757,
+          "ocrConfidence": 1.0,
+          "type": "Text"
+        },
+        {
+          "id": "From",
+          "name": "From",
+          "value": "Aleea Muscel 9, Cluj-Napoca 400347, Romania",
+          "unformattedValue": "",
+          "confidence": 0.9979634,
+          "ocrConfidence": 1.0,
+          "type": "Text"
+        },
+        {
+          "id": "To",
+          "name": "To",
+          "value": "Strada Traian Vuia 149-151, Cluj-Napoca 400397, Romania",
+          "unformattedValue": "",
+          "confidence": 0.99986005,
+          "ocrConfidence": 1.0,
+          "type": "Text"
+        },
+        {
+          "id": "Dummy field",
+          "name": "Dummy field",
+          "value": null,
+          "unformattedValue": null,
+          "confidence": null,
+          "ocrConfidence": null,
+          "type": "Text"
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/uipath-platform/tests/services/tests_data/documents_service/modern_extraction_response.json b/packages/uipath-platform/tests/services/tests_data/documents_service/modern_extraction_response.json
new file mode 100644
index 000000000..141919c16
--- /dev/null
+++ b/packages/uipath-platform/tests/services/tests_data/documents_service/modern_extraction_response.json
@@ -0,0 +1,192 @@
+{
+  "extractionResult": {
+    "DocumentId": "da303456-7ba3-f011-8e60-6045bd9ba6d0",
+    "ResultsVersion": 0,
+    "ResultsDocument": {
+      "Bounds": {
+        "StartPage": 0,
+        "PageCount": 1,
+        "TextStartIndex": 0,
+        "TextLength": 629,
+        "PageRange": "1"
+      },
+      "Language": "eng",
+      "DocumentGroup": "",
+      "DocumentCategory": "",
+      "DocumentTypeId": "2e4e0ad9-72a3-f011-8e61-000d3a395253",
+      "DocumentTypeName": "receipts",
+      "DocumentTypeDataVersion": 0,
+      "DataVersion": 0,
+      "DocumentTypeSource": "Automatic",
+      "DocumentTypeField": {
+        "Components": [],
+        "Value": "receipts",
+        "UnformattedValue": "",
+        "Reference": {
+          "TextStartIndex": 0,
+          "TextLength": 0,
+          "Tokens": []
+        },
+        "DerivedFields": [],
+        "Confidence": 1.0,
+        "OperatorConfirmed": false,
+        "OcrConfidence": -1.0,
+        "TextType": "Unknown",
+        "ValidatorNotes": "",
+        "ValidatorNotesInfo": ""
+      },
+      "Fields": [
+        {
+          "FieldId": "field-2",
+          "FieldName": "To",
+          "FieldType": "Text",
+          "IsMissing": true,
+          "DataSource": "Automatic",
+          "Values": [],
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        },
+        {
+          "FieldId": "field-1",
+          "FieldName": "From",
+          "FieldType": "Text",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [],
+              "Value": "with",
+              "UnformattedValue": "with",
+              "Reference": {
+                "TextStartIndex": 275,
+                "TextLength": 4,
+                "Tokens": [
+                  {
+                    "TextStartIndex": 275,
+                    "TextLength": 4,
+                    "Page": 0,
+                    "PageWidth": 595.0,
+                    "PageHeight": 842.0,
+                    "Boxes": [[378.08, 96.32, 12.27, 8.54]]
+                  }
+                ]
+              },
+              "DerivedFields": [],
+              "Confidence": 0.56592697,
+              "OperatorConfirmed": false,
+              "OcrConfidence": 1.0,
+              "TextType": "Text",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        },
+        {
+          "FieldId": "date",
+          "FieldName": "Transaction Date",
+          "FieldType": "Date",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [],
+              "Value": "2025-12-01",
+              "UnformattedValue": "December",
+              "Reference": {
+                "TextStartIndex": 559,
+                "TextLength": 8,
+                "Tokens": [
+                  {
+                    "TextStartIndex": 559,
+                    "TextLength": 8,
+                    "Page": 0,
+                    "PageWidth": 595.0,
+                    "PageHeight": 842.0,
+                    "Boxes": [[45.09, 464.79, 33.09, 9.87]]
+                  }
+                ]
+              },
+              "DerivedFields": [
+                {
+                  "FieldId": "Year",
+                  "Value": "2025"
+                },
+                {
+                  "FieldId": "Month",
+                  "Value": "12"
+                },
+                {
+                  "FieldId": "Day",
+                  "Value": "1"
+                }
+              ],
+              "Confidence": 0.8514132,
+              "OperatorConfirmed": false,
+              "OcrConfidence": 1.0,
+              "TextType": "Text",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        },
+        {
+          "FieldId": "total",
+          "FieldName": "Total Amount",
+          "FieldType": "Number",
+          "IsMissing": false,
+          "DataSource": "Automatic",
+          "Values": [
+            {
+              "Components": [],
+              "Value": "66.79",
+              "UnformattedValue": "66.79",
+              "Reference": {
+                "TextStartIndex": 582,
+                "TextLength": 5,
+                "Tokens": [
+                  {
+                    "TextStartIndex": 582,
+                    "TextLength": 5,
+                    "Page": 0,
+                    "PageWidth": 595.0,
+                    "PageHeight": 842.0,
+                    "Boxes": [[143.28, 500.81, 26.95, 14.68]]
+                  }
+                ]
+              },
+              "DerivedFields": [
+                {
+                  "FieldId": "Value",
+                  "Value": "66.79"
+                }
+              ],
+              "Confidence": 0.9245848,
+              "OperatorConfirmed": false,
+              "OcrConfidence": 1.0,
+              "TextType": "Text",
+              "ValidatorNotes": "",
+              "ValidatorNotesInfo": ""
+            }
+          ],
+          "DataVersion": 0,
+          "OperatorConfirmed": false,
+          "ValidatorNotes": "",
+          "ValidatorNotesInfo": ""
+        }
+      ],
+      "Tables": []
+    },
+    "ExtractorPayloads": null,
+    "BusinessRulesResults": null
+  }
+}
diff --git a/packages/uipath-platform/uv.lock b/packages/uipath-platform/uv.lock
new file mode 100644
index 000000000..2c3e5d025
--- /dev/null
+++ b/packages/uipath-platform/uv.lock
@@ -0,0 +1,1229 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[options]
+exclude-newer = "2026-06-22T13:55:56.0776194Z"
+exclude-newer-span = "P2D"
+
+[options.exclude-newer-package]
+uipath-core = false
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "bandit"
+version = "1.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "stevedore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/89/76/a7f3e639b78601118aaa4a394db2c66ae2597fbd8c39644c32874ed11e0c/bandit-1.9.3.tar.gz", hash = "sha256:ade4b9b7786f89ef6fc7344a52b34558caec5da74cb90373aed01de88472f774", size = 4242154, upload-time = "2026-01-19T04:05:22.802Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/0b/8bdc52111c83e2dc2f97403dc87c0830b8989d9ae45732b34b686326fb2c/bandit-1.9.3-py3-none-any.whl", hash = "sha256:4745917c88d2246def79748bde5e08b9d5e9b92f877863d43fab70cd8814ce6a", size = 134451, upload-time = "2026-01-19T04:05:20.938Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/ad/b59e5b451cf7172b8d1043dc0fa718f23aab379bc1521ee13d4bd9bfa960/coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053", size = 219278, upload-time = "2026-02-09T12:56:31.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/17/0cb7ca3de72e5f4ef2ec2fa0089beafbcaaaead1844e8b8a63d35173d77d/coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11", size = 219783, upload-time = "2026-02-09T12:56:33.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/63/325d8e5b11e0eaf6d0f6a44fad444ae58820929a9b0de943fa377fe73e85/coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa", size = 250200, upload-time = "2026-02-09T12:56:34.474Z" },
+    { url = "https://files.pythonhosted.org/packages/76/53/c16972708cbb79f2942922571a687c52bd109a7bd51175aeb7558dff2236/coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7", size = 252114, upload-time = "2026-02-09T12:56:35.749Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c2/7ab36d8b8cc412bec9ea2d07c83c48930eb4ba649634ba00cb7e4e0f9017/coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00", size = 254220, upload-time = "2026-02-09T12:56:37.796Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/4d/cf52c9a3322c89a0e6febdfbc83bb45c0ed3c64ad14081b9503adee702e7/coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef", size = 256164, upload-time = "2026-02-09T12:56:39.016Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/eb1dd17bd6de8289df3580e967e78294f352a5df8a57ff4671ee5fc3dcd0/coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903", size = 250325, upload-time = "2026-02-09T12:56:40.668Z" },
+    { url = "https://files.pythonhosted.org/packages/71/07/8c1542aa873728f72267c07278c5cc0ec91356daf974df21335ccdb46368/coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f", size = 251913, upload-time = "2026-02-09T12:56:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d7/c62e2c5e4483a748e27868e4c32ad3daa9bdddbba58e1bc7a15e252baa74/coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299", size = 249974, upload-time = "2026-02-09T12:56:43.323Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9f/4c5c015a6e98ced54efd0f5cf8d31b88e5504ecb6857585fc0161bb1e600/coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505", size = 253741, upload-time = "2026-02-09T12:56:45.155Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/59/0f4eef89b9f0fcd9633b5d350016f54126ab49426a70ff4c4e87446cabdc/coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6", size = 249695, upload-time = "2026-02-09T12:56:46.636Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/b7476f938deb07166f3eb281a385c262675d688ff4659ad56c6c6b8e2e70/coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9", size = 250599, upload-time = "2026-02-09T12:56:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/34/c3420709d9846ee3785b9f2831b4d94f276f38884032dca1457fa83f7476/coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9", size = 221780, upload-time = "2026-02-09T12:56:50.479Z" },
+    { url = "https://files.pythonhosted.org/packages/61/08/3d9c8613079d2b11c185b865de9a4c1a68850cfda2b357fae365cf609f29/coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f", size = 222715, upload-time = "2026-02-09T12:56:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1a/54c3c80b2f056164cc0a6cdcb040733760c7c4be9d780fe655f356f433e4/coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f", size = 221385, upload-time = "2026-02-09T12:56:53.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
+    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
+    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
+    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
+    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
+    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
+    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
+    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
+    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.24.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/92/a8e2479937ff39185d20dd6a851c1a63e55849e447a55e798cc2e1f49c65/filelock-3.24.3.tar.gz", hash = "sha256:011a5644dc937c22699943ebbfc46e969cdde3e171470a6e40b9533e5a72affa", size = 37935, upload-time = "2026-02-19T00:48:20.543Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/0f/5d0c71a1aefeb08efff26272149e07ab922b64f46c63363756224bd6872e/filelock-3.24.3-py3-none-any.whl", hash = "sha256:426e9a4660391f7f8a810d71b0555bce9008b0a1cc342ab1f6947d37639e002d", size = 24331, upload-time = "2026-02-19T00:48:18.465Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/8d/e8b97e6bd3fb6fb271346f7981362f1e04d6a7463abd0de79e1fda17c067/identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980", size = 99360, upload-time = "2026-01-12T18:58:58.201Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/58/40fbbcefeda82364720eba5cf2270f98496bdfa19ea75b4cccae79c698e6/identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0", size = 99202, upload-time = "2026-01-12T18:58:56.627Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471, upload-time = "2026-02-17T16:13:06.101Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/01/0e748af5e4fee180cf7cd12bd12b0513ad23b045dccb2a83191bde82d168/librt-0.8.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:681dc2451d6d846794a828c16c22dc452d924e9f700a485b7ecb887a30aad1fd", size = 65315, upload-time = "2026-02-17T16:11:25.152Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/4d/7184806efda571887c798d573ca4134c80ac8642dcdd32f12c31b939c595/librt-0.8.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3b4350b13cc0e6f5bec8fa7caf29a8fb8cdc051a3bae45cfbfd7ce64f009965", size = 68021, upload-time = "2026-02-17T16:11:26.129Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/88/c3c52d2a5d5101f28d3dc89298444626e7874aa904eed498464c2af17627/librt-0.8.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ac1e7817fd0ed3d14fd7c5df91daed84c48e4c2a11ee99c0547f9f62fdae13da", size = 194500, upload-time = "2026-02-17T16:11:27.177Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5d/6fb0a25b6a8906e85b2c3b87bee1d6ed31510be7605b06772f9374ca5cb3/librt-0.8.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:747328be0c5b7075cde86a0e09d7a9196029800ba75a1689332348e998fb85c0", size = 205622, upload-time = "2026-02-17T16:11:28.242Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a6/8006ae81227105476a45691f5831499e4d936b1c049b0c1feb17c11b02d1/librt-0.8.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0af2bd2bc204fa27f3d6711d0f360e6b8c684a035206257a81673ab924aa11e", size = 218304, upload-time = "2026-02-17T16:11:29.344Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/19/60e07886ad16670aae57ef44dada41912c90906a6fe9f2b9abac21374748/librt-0.8.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d480de377f5b687b6b1bc0c0407426da556e2a757633cc7e4d2e1a057aa688f3", size = 211493, upload-time = "2026-02-17T16:11:30.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/cf/f666c89d0e861d05600438213feeb818c7514d3315bae3648b1fc145d2b6/librt-0.8.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d0ee06b5b5291f609ddb37b9750985b27bc567791bc87c76a569b3feed8481ac", size = 219129, upload-time = "2026-02-17T16:11:32.021Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/ef/f1bea01e40b4a879364c031476c82a0dc69ce068daad67ab96302fed2d45/librt-0.8.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9e2c6f77b9ad48ce5603b83b7da9ee3e36b3ab425353f695cba13200c5d96596", size = 213113, upload-time = "2026-02-17T16:11:33.192Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/80/cdab544370cc6bc1b72ea369525f547a59e6938ef6863a11ab3cd24759af/librt-0.8.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:439352ba9373f11cb8e1933da194dcc6206daf779ff8df0ed69c5e39113e6a99", size = 212269, upload-time = "2026-02-17T16:11:34.373Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/9c/48d6ed8dac595654f15eceab2035131c136d1ae9a1e3548e777bb6dbb95d/librt-0.8.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:82210adabbc331dbb65d7868b105185464ef13f56f7f76688565ad79f648b0fe", size = 234673, upload-time = "2026-02-17T16:11:36.063Z" },
+    { url = "https://files.pythonhosted.org/packages/16/01/35b68b1db517f27a01be4467593292eb5315def8900afad29fabf56304ba/librt-0.8.1-cp311-cp311-win32.whl", hash = "sha256:52c224e14614b750c0a6d97368e16804a98c684657c7518752c356834fff83bb", size = 54597, upload-time = "2026-02-17T16:11:37.544Z" },
+    { url = "https://files.pythonhosted.org/packages/71/02/796fe8f02822235966693f257bf2c79f40e11337337a657a8cfebba5febc/librt-0.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:c00e5c884f528c9932d278d5c9cbbea38a6b81eb62c02e06ae53751a83a4d52b", size = 61733, upload-time = "2026-02-17T16:11:38.691Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ad/232e13d61f879a42a4e7117d65e4984bb28371a34bb6fb9ca54ec2c8f54e/librt-0.8.1-cp311-cp311-win_arm64.whl", hash = "sha256:f7cdf7f26c2286ffb02e46d7bac56c94655540b26347673bea15fa52a6af17e9", size = 52273, upload-time = "2026-02-17T16:11:40.308Z" },
+    { url = "https://files.pythonhosted.org/packages/95/21/d39b0a87ac52fc98f621fb6f8060efb017a767ebbbac2f99fbcbc9ddc0d7/librt-0.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a28f2612ab566b17f3698b0da021ff9960610301607c9a5e8eaca62f5e1c350a", size = 66516, upload-time = "2026-02-17T16:11:41.604Z" },
+    { url = "https://files.pythonhosted.org/packages/69/f1/46375e71441c43e8ae335905e069f1c54febee63a146278bcee8782c84fd/librt-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60a78b694c9aee2a0f1aaeaa7d101cf713e92e8423a941d2897f4fa37908dab9", size = 68634, upload-time = "2026-02-17T16:11:43.268Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/33/c510de7f93bf1fa19e13423a606d8189a02624a800710f6e6a0a0f0784b3/librt-0.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:758509ea3f1eba2a57558e7e98f4659d0ea7670bff49673b0dde18a3c7e6c0eb", size = 198941, upload-time = "2026-02-17T16:11:44.28Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/36/e725903416409a533d92398e88ce665476f275081d0d7d42f9c4951999e5/librt-0.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:039b9f2c506bd0ab0f8725aa5ba339c6f0cd19d3b514b50d134789809c24285d", size = 209991, upload-time = "2026-02-17T16:11:45.462Z" },
+    { url = "https://files.pythonhosted.org/packages/30/7a/8d908a152e1875c9f8eac96c97a480df425e657cdb47854b9efaa4998889/librt-0.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bb54f1205a3a6ab41a6fd71dfcdcbd278670d3a90ca502a30d9da583105b6f7", size = 224476, upload-time = "2026-02-17T16:11:46.542Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/a22c34f2c485b8903a06f3fe3315341fe6876ef3599792344669db98fcff/librt-0.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:05bd41cdee35b0c59c259f870f6da532a2c5ca57db95b5f23689fcb5c9e42440", size = 217518, upload-time = "2026-02-17T16:11:47.746Z" },
+    { url = "https://files.pythonhosted.org/packages/79/6f/5c6fea00357e4f82ba44f81dbfb027921f1ab10e320d4a64e1c408d035d9/librt-0.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adfab487facf03f0d0857b8710cf82d0704a309d8ffc33b03d9302b4c64e91a9", size = 225116, upload-time = "2026-02-17T16:11:49.298Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a0/95ced4e7b1267fe1e2720a111685bcddf0e781f7e9e0ce59d751c44dcfe5/librt-0.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:153188fe98a72f206042be10a2c6026139852805215ed9539186312d50a8e972", size = 217751, upload-time = "2026-02-17T16:11:50.49Z" },
+    { url = "https://files.pythonhosted.org/packages/93/c2/0517281cb4d4101c27ab59472924e67f55e375bc46bedae94ac6dc6e1902/librt-0.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dd3c41254ee98604b08bd5b3af5bf0a89740d4ee0711de95b65166bf44091921", size = 218378, upload-time = "2026-02-17T16:11:51.783Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e8/37b3ac108e8976888e559a7b227d0ceac03c384cfd3e7a1c2ee248dbae79/librt-0.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e0d138c7ae532908cbb342162b2611dbd4d90c941cd25ab82084aaf71d2c0bd0", size = 241199, upload-time = "2026-02-17T16:11:53.561Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/35812d041c53967fedf551a39399271bbe4257e681236a2cf1a69c8e7fa1/librt-0.8.1-cp312-cp312-win32.whl", hash = "sha256:43353b943613c5d9c49a25aaffdba46f888ec354e71e3529a00cca3f04d66a7a", size = 54917, upload-time = "2026-02-17T16:11:54.758Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d1/fa5d5331b862b9775aaf2a100f5ef86854e5d4407f71bddf102f4421e034/librt-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff8baf1f8d3f4b6b7257fcb75a501f2a5499d0dda57645baa09d4d0d34b19444", size = 62017, upload-time = "2026-02-17T16:11:55.748Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7c/c614252f9acda59b01a66e2ddfd243ed1c7e1deab0293332dfbccf862808/librt-0.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f2ae3725904f7377e11cc37722d5d401e8b3d5851fb9273d7f4fe04f6b3d37d", size = 52441, upload-time = "2026-02-17T16:11:56.801Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529, upload-time = "2026-02-17T16:11:57.809Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669, upload-time = "2026-02-17T16:11:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279, upload-time = "2026-02-17T16:11:59.862Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288, upload-time = "2026-02-17T16:12:00.954Z" },
+    { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809, upload-time = "2026-02-17T16:12:02.108Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075, upload-time = "2026-02-17T16:12:03.631Z" },
+    { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486, upload-time = "2026-02-17T16:12:04.725Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219, upload-time = "2026-02-17T16:12:05.828Z" },
+    { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750, upload-time = "2026-02-17T16:12:07.09Z" },
+    { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624, upload-time = "2026-02-17T16:12:08.43Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969, upload-time = "2026-02-17T16:12:09.633Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000, upload-time = "2026-02-17T16:12:10.632Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495, upload-time = "2026-02-17T16:12:11.633Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6a/907ef6800f7bca71b525a05f1839b21f708c09043b1c6aa77b6b827b3996/librt-0.8.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6cfa7fe54fd4d1f47130017351a959fe5804bda7a0bc7e07a2cdbc3fdd28d34f", size = 66081, upload-time = "2026-02-17T16:12:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/18/25e991cd5640c9fb0f8d91b18797b29066b792f17bf8493da183bf5caabe/librt-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:228c2409c079f8c11fb2e5d7b277077f694cb93443eb760e00b3b83cb8b3176c", size = 68309, upload-time = "2026-02-17T16:12:13.756Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/36/46820d03f058cfb5a9de5940640ba03165ed8aded69e0733c417bb04df34/librt-0.8.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7aae78ab5e3206181780e56912d1b9bb9f90a7249ce12f0e8bf531d0462dd0fc", size = 196804, upload-time = "2026-02-17T16:12:14.818Z" },
+    { url = "https://files.pythonhosted.org/packages/59/18/5dd0d3b87b8ff9c061849fbdb347758d1f724b9a82241aa908e0ec54ccd0/librt-0.8.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:172d57ec04346b047ca6af181e1ea4858086c80bdf455f61994c4aa6fc3f866c", size = 206907, upload-time = "2026-02-17T16:12:16.513Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/96/ef04902aad1424fd7299b62d1890e803e6ab4018c3044dca5922319c4b97/librt-0.8.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b1977c4ea97ce5eb7755a78fae68d87e4102e4aaf54985e8b56806849cc06a3", size = 221217, upload-time = "2026-02-17T16:12:17.906Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ff/7e01f2dda84a8f5d280637a2e5827210a8acca9a567a54507ef1c75b342d/librt-0.8.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:10c42e1f6fd06733ef65ae7bebce2872bcafd8d6e6b0a08fe0a05a23b044fb14", size = 214622, upload-time = "2026-02-17T16:12:19.108Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/8c/5b093d08a13946034fed57619742f790faf77058558b14ca36a6e331161e/librt-0.8.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c8dfa264b9193c4ee19113c985c95f876fae5e51f731494fc4e0cf594990ba7", size = 221987, upload-time = "2026-02-17T16:12:20.331Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/cc/86b0b3b151d40920ad45a94ce0171dec1aebba8a9d72bb3fa00c73ab25dd/librt-0.8.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:01170b6729a438f0dedc4a26ed342e3dc4f02d1000b4b19f980e1877f0c297e6", size = 215132, upload-time = "2026-02-17T16:12:21.54Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/be/8588164a46edf1e69858d952654e216a9a91174688eeefb9efbb38a9c799/librt-0.8.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7b02679a0d783bdae30d443025b94465d8c3dc512f32f5b5031f93f57ac32071", size = 215195, upload-time = "2026-02-17T16:12:23.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f2/0b9279bea735c734d69344ecfe056c1ba211694a72df10f568745c899c76/librt-0.8.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:190b109bb69592a3401fe1ffdea41a2e73370ace2ffdc4a0e8e2b39cdea81b78", size = 237946, upload-time = "2026-02-17T16:12:24.275Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/cc/5f2a34fbc8aeb35314a3641f9956fa9051a947424652fad9882be7a97949/librt-0.8.1-cp314-cp314-win32.whl", hash = "sha256:e70a57ecf89a0f64c24e37f38d3fe217a58169d2fe6ed6d70554964042474023", size = 50689, upload-time = "2026-02-17T16:12:25.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/cd4d010ab2147339ca2b93e959c3686e964edc6de66ddacc935c325883d7/librt-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:7e2f3edca35664499fbb36e4770650c4bd4a08abc1f4458eab9df4ec56389730", size = 57875, upload-time = "2026-02-17T16:12:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/84/0f/2143cb3c3ca48bd3379dcd11817163ca50781927c4537345d608b5045998/librt-0.8.1-cp314-cp314-win_arm64.whl", hash = "sha256:0d2f82168e55ddefd27c01c654ce52379c0750ddc31ee86b4b266bcf4d65f2a3", size = 48058, upload-time = "2026-02-17T16:12:28.556Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/0e/9b23a87e37baf00311c3efe6b48d6b6c168c29902dfc3f04c338372fd7db/librt-0.8.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c74a2da57a094bd48d03fa5d196da83d2815678385d2978657499063709abe1", size = 68313, upload-time = "2026-02-17T16:12:29.659Z" },
+    { url = "https://files.pythonhosted.org/packages/db/9a/859c41e5a4f1c84200a7d2b92f586aa27133c8243b6cac9926f6e54d01b9/librt-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a355d99c4c0d8e5b770313b8b247411ed40949ca44e33e46a4789b9293a907ee", size = 70994, upload-time = "2026-02-17T16:12:31.516Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/28/10605366ee599ed34223ac2bf66404c6fb59399f47108215d16d5ad751a8/librt-0.8.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2eb345e8b33fb748227409c9f1233d4df354d6e54091f0e8fc53acdb2ffedeb7", size = 220770, upload-time = "2026-02-17T16:12:33.294Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8d/16ed8fd452dafae9c48d17a6bc1ee3e818fd40ef718d149a8eff2c9f4ea2/librt-0.8.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9be2f15e53ce4e83cc08adc29b26fb5978db62ef2a366fbdf716c8a6c8901040", size = 235409, upload-time = "2026-02-17T16:12:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/89/1b/7bdf3e49349c134b25db816e4a3db6b94a47ac69d7d46b1e682c2c4949be/librt-0.8.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:785ae29c1f5c6e7c2cde2c7c0e148147f4503da3abc5d44d482068da5322fd9e", size = 246473, upload-time = "2026-02-17T16:12:36.656Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/8a/91fab8e4fd2a24930a17188c7af5380eb27b203d72101c9cc000dbdfd95a/librt-0.8.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d3a7da44baf692f0c6aeb5b2a09c5e6fc7a703bca9ffa337ddd2e2da53f7732", size = 238866, upload-time = "2026-02-17T16:12:37.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e0/c45a098843fc7c07e18a7f8a24ca8496aecbf7bdcd54980c6ca1aaa79a8e/librt-0.8.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fc48998000cbc39ec0d5311312dda93ecf92b39aaf184c5e817d5d440b29624", size = 250248, upload-time = "2026-02-17T16:12:39.445Z" },
+    { url = "https://files.pythonhosted.org/packages/82/30/07627de23036640c952cce0c1fe78972e77d7d2f8fd54fa5ef4554ff4a56/librt-0.8.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e96baa6820280077a78244b2e06e416480ed859bbd8e5d641cf5742919d8beb4", size = 240629, upload-time = "2026-02-17T16:12:40.889Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c1/55bfe1ee3542eba055616f9098eaf6eddb966efb0ca0f44eaa4aba327307/librt-0.8.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31362dbfe297b23590530007062c32c6f6176f6099646bb2c95ab1b00a57c382", size = 239615, upload-time = "2026-02-17T16:12:42.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/39/191d3d28abc26c9099b19852e6c99f7f6d400b82fa5a4e80291bd3803e19/librt-0.8.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc3656283d11540ab0ea01978378e73e10002145117055e03722417aeab30994", size = 263001, upload-time = "2026-02-17T16:12:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/eb/7697f60fbe7042ab4e88f4ee6af496b7f222fffb0a4e3593ef1f29f81652/librt-0.8.1-cp314-cp314t-win32.whl", hash = "sha256:738f08021b3142c2918c03692608baed43bc51144c29e35807682f8070ee2a3a", size = 51328, upload-time = "2026-02-17T16:12:45.148Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/72/34bf2eb7a15414a23e5e70ecb9440c1d3179f393d9349338a91e2781c0fb/librt-0.8.1-cp314-cp314t-win_amd64.whl", hash = "sha256:89815a22daf9c51884fb5dbe4f1ef65ee6a146e0b6a8df05f753e2e4a9359bf4", size = 58722, upload-time = "2026-02-17T16:12:46.85Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755, upload-time = "2026-02-17T16:12:47.943Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" },
+    { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
+    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
+    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
+    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/0f/7e6b713ac117c1f5e4e3300748af699b9902a2e5e34c9cf443dde25a01fa/opentelemetry_instrumentation-0.60b1.tar.gz", hash = "sha256:57ddc7974c6eb35865af0426d1a17132b88b2ed8586897fee187fd5b8944bd6a", size = 31706, upload-time = "2025-12-11T13:36:42.515Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/d2/6788e83c5c86a2690101681aeef27eeb2a6bf22df52d3f263a22cee20915/opentelemetry_instrumentation-0.60b1-py3-none-any.whl", hash = "sha256:04480db952b48fb1ed0073f822f0ee26012b7be7c3eac1a3793122737c78632d", size = 33096, upload-time = "2025-12-11T13:35:33.067Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" },
+]
+
+[[package]]
+name = "outcome"
+version = "1.3.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060, upload-time = "2023-10-26T04:26:04.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692, upload-time = "2023-10-26T04:26:02.532Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/04/fea538adf7dbbd6d186f551d595961e564a3b6715bdf276b477460858672/platformdirs-4.9.2.tar.gz", hash = "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291", size = 28394, upload-time = "2026-02-16T03:56:10.574Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/31/05e764397056194206169869b50cf2fee4dbbbc71b344705b9c0d878d4d8/platformdirs-4.9.2-py3-none-any.whl", hash = "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd", size = 21168, upload-time = "2026-02-16T03:56:08.891Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
+[[package]]
+name = "pytest-httpx"
+version = "0.36.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/5574834da9499066fa1a5ea9c336f94dba2eae02298d36dab192fcf95c86/pytest_httpx-0.36.0.tar.gz", hash = "sha256:9edb66a5fd4388ce3c343189bc67e7e1cb50b07c2e3fc83b97d511975e8a831b", size = 56793, upload-time = "2025-12-02T16:34:57.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/d2/1eb1ea9c84f0d2033eb0b49675afdc71aa4ea801b74615f00f3c33b725e3/pytest_httpx-0.36.0-py3-none-any.whl", hash = "sha256:bd4c120bb80e142df856e825ec9f17981effb84d159f9fa29ed97e2357c3a9c8", size = 20229, upload-time = "2025-12-02T16:34:56.45Z" },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
+]
+
+[[package]]
+name = "pytest-trio"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "outcome" },
+    { name = "pytest" },
+    { name = "trio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/08/056279526554c6c6e6ad6d4a479a338d14dc785ac30be8bdc6ca0153c1be/pytest-trio-0.8.0.tar.gz", hash = "sha256:8363db6336a79e6c53375a2123a41ddbeccc4aa93f93788651641789a56fb52e", size = 46525, upload-time = "2022-11-01T17:24:29.352Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/22/71953f47e0da5852c899f58cd7a31e6100f37c632b7b9ee52d067613a844/pytest_trio-0.8.0-py3-none-any.whl", hash = "sha256:e6a7e7351ae3e8ec3f4564d30ee77d1ec66e1df611226e5618dbb32f9545c841", size = 27221, upload-time = "2022-11-01T17:24:27.501Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/99/a4cab2acbb884f80e558b0771e97e21e939c5dfb460f488d19df485e8298/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8", size = 230143, upload-time = "2026-02-01T16:20:47.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
+]
+
+[[package]]
+name = "rust-just"
+version = "1.46.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/50/3828817f76e19977a4048c2c8b39a7f48babc21dd9dbed4af2f3c18d4570/rust_just-1.46.0.tar.gz", hash = "sha256:84437481c814577529835132e2cc5fcc35a981c1712e4877cb20fc2f5ec5b2d6", size = 1447346, upload-time = "2026-01-03T02:03:17.948Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/0b/a5bf2707b02a484d91f8275efa39f76fe19304f5bfba82293fa4b18608d2/rust_just-1.46.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7d6d4c67a443f1acb1f78f9ba4b3349fa04f17e8be2d4448b771cdc93a382812", size = 1739556, upload-time = "2026-01-03T02:02:42.835Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ae/40bcd996ccb2fcb0152b5bfde7beaf3840877a8837611421c495b45c82da/rust_just-1.46.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0caf9b77d30455558d017c9e625ce94c373f88d81656477127727604fa5d36ab", size = 1620974, upload-time = "2026-01-03T02:02:45.341Z" },
+    { url = "https://files.pythonhosted.org/packages/62/36/7067e0eaf674ed7c98b35ed50d713c0c885f2d2b57847a627e11502da1b8/rust_just-1.46.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b63521acd91c65164c202ded3ae730130c7fb4377f59cd2f9847b45161c94fd", size = 1703423, upload-time = "2026-01-03T02:02:47.681Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/47/3e98182f5e03c48880d647651385863552a3e24cfec5c51d116c06e6f180/rust_just-1.46.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46a35110c7acf27bdded79cf3bbfea9eb80a53f6f81f374248fe3340584c92e5", size = 1666645, upload-time = "2026-01-03T02:02:50.38Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5e/b9badf6e6982e5744f076d12ab911e5ac8b4b03a0674bab4f498ed9d0b4c/rust_just-1.46.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a2407cefc2e5ed4527297747bd5bcb61a885776021cb2438c3a7b118b2cabc2", size = 1847430, upload-time = "2026-01-03T02:02:52.716Z" },
+    { url = "https://files.pythonhosted.org/packages/98/10/6916d7c862b99de600a1fd3739d13353c220dfbc0229a0b2c5012c2f801d/rust_just-1.46.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0dab319619f600561b993242312a344953b1ea44637b30257af905a70ce6f568", size = 1926224, upload-time = "2026-01-03T02:02:55.194Z" },
+    { url = "https://files.pythonhosted.org/packages/24/93/18bc615e68a80f43105d5e7cc3571e85776aec829ac40faae4de5d5dc2f3/rust_just-1.46.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3b4c26dd86e5d96047fc0935967f22cb9f49c687767d78b7d3fe511eba39ffa", size = 1902165, upload-time = "2026-01-03T02:02:57.636Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/e3c19a24ff64e78a04df0bdf4c61e15c28dcac8b7b5c3a5505eb5749d40a/rust_just-1.46.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdb496ca26efc508be0e625309b74b1f6316b4f7295d13247c3b791dfa77eb1", size = 1835209, upload-time = "2026-01-03T02:03:00.256Z" },
+    { url = "https://files.pythonhosted.org/packages/26/75/0850c38e41025794826165329a097f657152902a785c0579f213b7d61ae6/rust_just-1.46.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3cf1c32a258f8ee44af877ec271e2eea257923a3303a6d2610b0b5f1523daaab", size = 1719519, upload-time = "2026-01-03T02:03:02.774Z" },
+    { url = "https://files.pythonhosted.org/packages/48/85/53c6ee2b9cdbbe1bd43cd0f8096036c29e9e6ba2d3d6344206c490e2ce18/rust_just-1.46.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:657ab85882c124b0fbcd75763035d0dbd20b06c582cc6d4f55017d7b517d5a89", size = 1685664, upload-time = "2026-01-03T02:03:05.514Z" },
+    { url = "https://files.pythonhosted.org/packages/33/04/1ad3a66bef0d0f554f0f9971b048bbaf7b3955458f3fda47b48fbf8ff009/rust_just-1.46.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:644b71bfe68863b71ee2618a88dbfd446ea70e2dcfa7b0e5eaec7b6dc4faceca", size = 1838231, upload-time = "2026-01-03T02:03:07.618Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/75/33c2e887a68e57b356cda74d325d6ebe406bb72ad8c4e2d067d4fa9b697b/rust_just-1.46.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e9d8a879fb86eb1c7f7f83953999ae4ce53ea4e5c0ca531cf6ff09e1e9335ff7", size = 1900319, upload-time = "2026-01-03T02:03:09.873Z" },
+    { url = "https://files.pythonhosted.org/packages/44/30/6b1677aa64a4f69f3ec174b5e2a9a49e0ffd06946d4b4dc8295366fbd9dd/rust_just-1.46.0-py3-none-win32.whl", hash = "sha256:100701de91bded3f6f2bf564d09c2f8e483b8dfb490d1c74008ce3c01ff0ff67", size = 1623463, upload-time = "2026-01-03T02:03:12.343Z" },
+    { url = "https://files.pythonhosted.org/packages/64/61/97ad7a1ea67b9485404b18150c258015842cf116a1ce626421863fd8f0e1/rust_just-1.46.0-py3-none-win_amd64.whl", hash = "sha256:ccaf8e473f64f5c815b0039e883a1feaf5634b9cdffd1dbff9e5fde77b5926f4", size = 1801103, upload-time = "2026-01-03T02:03:15.256Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "stevedore"
+version = "5.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/5b/496f8abebd10c3301129abba7ddafd46c71d799a70c44ab080323987c4c9/stevedore-5.6.0.tar.gz", hash = "sha256:f22d15c6ead40c5bbfa9ca54aa7e7b4a07d59b36ae03ed12ced1a54cf0b51945", size = 516074, upload-time = "2025-11-20T10:06:07.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/40/8561ce06dc46fd17242c7724ab25b257a2ac1b35f4ebf551b40ce6105cfa/stevedore-5.6.0-py3-none-any.whl", hash = "sha256:4a36dccefd7aeea0c70135526cecb7766c4c84c473b1af68db23d541b6dc1820", size = 54428, upload-time = "2025-11-20T10:06:05.946Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
+]
+
+[[package]]
+name = "trio"
+version = "0.33.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
+    { name = "idna" },
+    { name = "outcome" },
+    { name = "sniffio" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/b6/c744031c6f89b18b3f5f4f7338603ab381d740a7f45938c4607b2302481f/trio-0.33.0.tar.gz", hash = "sha256:a29b92b73f09d4b48ed249acd91073281a7f1063f09caba5dc70465b5c7aa970", size = 605109, upload-time = "2026-02-14T18:40:55.386Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/93/dab25dc87ac48da0fe0f6419e07d0bfd98799bed4e05e7b9e0f85a1a4b4b/trio-0.33.0-py3-none-any.whl", hash = "sha256:3bd5d87f781d9b0192d592aef28691f8951d6c2e41b7e1da4c25cde6c180ae9b", size = 510294, upload-time = "2026-02-14T18:40:53.313Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.22"
+source = { editable = "../uipath-core" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.76"
+source = { editable = "." }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "bandit" },
+    { name = "mypy" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "pytest-httpx" },
+    { name = "pytest-mock" },
+    { name = "pytest-trio" },
+    { name = "ruff" },
+    { name = "rust-just" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "sqlparse", specifier = ">=0.5.5" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../uipath-core" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.38.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d2/03/a94d404ca09a89a7301a7008467aed525d4cdeb9186d262154dd23208709/virtualenv-20.38.0.tar.gz", hash = "sha256:94f39b1abaea5185bf7ea5a46702b56f1d0c9aa2f41a6c2b8b0af4ddc74c10a7", size = 5864558, upload-time = "2026-02-19T07:48:02.385Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/394801755d4c8684b655d35c665aea7836ec68320304f62ab3c94395b442/virtualenv-20.38.0-py3-none-any.whl", hash = "sha256:d6e78e5889de3a4742df2d3d44e779366325a90cf356f15621fddace82431794", size = 5837778, upload-time = "2026-02-19T07:47:59.778Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath/.python-version b/packages/uipath/.python-version
new file mode 100644
index 000000000..2c0733315
--- /dev/null
+++ b/packages/uipath/.python-version
@@ -0,0 +1 @@
+3.11
diff --git a/packages/uipath/CLAUDE.md b/packages/uipath/CLAUDE.md
new file mode 100644
index 000000000..9b4c372c2
--- /dev/null
+++ b/packages/uipath/CLAUDE.md
@@ -0,0 +1,121 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the main `uipath` package.
+
+## Package Purpose
+
+The top-level SDK package that users `uv pip install`. Contains the CLI (`uipath` command), agent framework, evaluation framework, tracing, telemetry, and function utilities. Depends on `uipath-platform` and `uipath-core`.
+
+## Development Commands
+
+```bash
+cd packages/uipath
+
+uv sync --all-extras          # Install dependencies
+just lint                     # ruff check + custom httpx linter
+just format                   # ruff format --check
+just validate                 # lint + format
+just build                    # validate + update-agents-md + uv build
+just install                  # uv sync --all-extras
+just test-lint-httpx          # Test the custom httpx linter
+
+pytest                        # Run all tests
+pytest tests/cli/             # Run CLI tests
+pytest tests/cli/test_pack.py::test_name  # Single test
+ruff check .                  # Lint
+ruff format --check .         # Format check
+mypy src tests                # Type check
+```
+
+### Custom Linter
+
+`scripts/lint_httpx_client.py` enforces httpx client usage patterns. Run with `just lint` or `python scripts/lint_httpx_client.py`.
+
+### AGENTS.md Generation
+
+`scripts/update_agents_md.py` auto-generates `src/uipath/_resources/AGENTS.md` from agent definitions. Run via `just build` or `just update-agents-md`.
+
+## CLI Architecture (`src/uipath/_cli/`)
+
+Uses **click** framework. Commands are organized as `cli_<command>.py` files.
+
+**Critical: lazy imports.** The CLI `__init__.py` defers all heavy imports to keep startup fast (~0.5s). Do NOT add top-level imports to `_cli/__init__.py`.
+
+### Commands
+
+| File | Command | Purpose |
+|------|---------|---------|
+| `cli_new.py` | `new` | Create new project |
+| `cli_init.py` | `init` | Initialize project (generates entry-points.json) |
+| `cli_pack.py` | `pack` | Package into .nupkg |
+| `cli_publish.py` | `publish` | Publish to Orchestrator feed |
+| `cli_deploy.py` | `deploy` | Pack + publish in one step |
+| `cli_run.py` | `run` | Execute a project locally |
+| `cli_auth.py` | `auth` | Browser-based authentication |
+| `cli_invoke.py` | `invoke` | Invoke a specific entrypoint |
+| `cli_eval.py` | `eval` | Run evaluations |
+| `cli_push.py` | `push` | Push to remote storage |
+| `cli_pull.py` | `pull` | Pull from remote storage |
+| `cli_dev.py` | `dev` | Development server mode |
+| `cli_add.py` | `add` | Add resource/dependency |
+| `cli_server.py` | `server` | Run as server |
+| `cli_register.py` | `register` | Register resource |
+| `cli_debug.py` | `debug` | Debug execution |
+
+Sub-commands: `services/cli_assets.py` (asset management), `services/cli_buckets.py` (bucket management).
+
+## Agent Framework (`src/uipath/agent/`)
+
+- **`models/`** — Agent definition models (`agent.py` is the main one, ~43KB), evaluation config, legacy compat
+- **`utils/`** — `load_agent_definition`, `create_agent_project`, `download_agent_project`, token counting
+
+## Evaluation Framework (`src/uipath/eval/`)
+
+Plugin-based evaluator registration system with deterministic and LLM-based evaluators.
+
+- **`evaluators/`** — 11 active evaluators: ExactMatch, Contains, JsonSimilarity, BinaryClassification, MulticlassClassification, LLMJudgeOutput, LLMJudgeTrajectory, ToolCallOrder/Args/Count/Output. Plus ~7 legacy evaluators.
+- **`mocks/`** — LLM mocking, input mocking, cache management, mockito integration. Key exports: `mockable`, `UiPathMockRuntime`, `MockingContext`.
+- **`runtime/`** — `UiPathEvalRuntime`, `UiPathEvalContext`, `evaluate()` entry point, parallelization, exporters.
+- **`models/`** — `AgentExecution`, `EvaluationResult`, `ToolCall`, `LLMResponse`, evaluator type enums.
+
+## Functions Module (`src/uipath/functions/`)
+
+- `UiPathFunctionsRuntime` / `UiPathDebugFunctionsRuntime` — function execution runtimes
+- `UiPathFunctionsRuntimeFactory` — factory pattern for runtime creation
+- `graph_builder.py` — function graph construction
+- `schema_gen.py` — schema generation from function definitions
+
+## Tracing (`src/uipath/tracing/`)
+
+OpenTelemetry integration with `JsonLinesFileExporter`, `LlmOpsHttpExporter`, `LiveTrackingSpanProcessor`. The `traced` decorator is re-exported from `uipath-core`.
+
+## Telemetry (`src/uipath/telemetry/`)
+
+Application Insights tracking: `track()`, `track_event()`, `is_telemetry_enabled()`, `flush_events()`.
+
+## Bundled Resources (`src/uipath/_resources/`)
+
+Documentation files bundled with the package: `AGENTS.md` (auto-generated), `CLAUDE.md`, `CLI_REFERENCE.md`, `SDK_REFERENCE.md`, `REQUIRED_STRUCTURE.md`, `eval.md`, `new-agent.md`.
+
+## Test Structure
+
+```
+tests/
+├── agent/          # Agent models, react prompts, utils
+├── cli/            # CLI command tests (largest test suite)
+│   ├── chat/       # Chat bridge tests
+│   ├── contract/   # SDK/CLI alignment tests
+│   ├── eval/       # Evaluation tests (30+ files, mocks, integration)
+│   ├── evaluators/ # Legacy evaluator tests
+│   ├── integration/# End-to-end tests
+│   ├── mocks/      # Mock fixtures
+│   ├── models/     # Model tests
+│   ├── unit/       # Unit tests
+│   └── utils/      # Utility tests
+├── evaluators/     # General evaluator tests
+├── functions/      # Functions runtime tests
+├── resource_overrides/ # Resource override tests
+├── sdk/            # SDK functionality tests
+├── telemetry/      # Telemetry tests
+└── tracing/        # Tracing integration tests
+```
diff --git a/CONTRIBUTING.md b/packages/uipath/CONTRIBUTING.md
similarity index 63%
rename from CONTRIBUTING.md
rename to packages/uipath/CONTRIBUTING.md
index d8989f611..3cd2a9e8b 100644
--- a/CONTRIBUTING.md
+++ b/packages/uipath/CONTRIBUTING.md
@@ -4,11 +4,11 @@
 
 ### Prerequisites
 
-1. **Install Python ≥ 3.10**:
-    - Download and install Python 3.10 from the official [Python website](https://www.python.org/downloads/)
+1. **Install Python ≥ 3.11**:
+    - Download and install Python 3.11 from the official [Python website](https://www.python.org/downloads/)
     - Verify the installation by running:
         ```sh
-        python3.10 --version
+        python3.11 --version
         ```
 
     Alternative: [mise](https://mise.jdx.dev/lang/python.html)
@@ -21,7 +21,21 @@
     uv venv
     ```
 
-4. **Install dependencies**:
+4. **Activate the virtual environment**:
+    - Linux/Mac
+    ```sh
+    source .venv/bin/activate
+    ```
+    - Windows Powershell
+    ```sh
+    .venv\Scripts\Activate.ps1
+    ```
+    - Windows Bash
+    ```sh
+    source .venv/Scripts/activate
+    ```
+
+5. **Install dependencies**:
     ```sh
     uv sync --all-extras --no-cache
     ```
@@ -38,7 +52,7 @@ For additional commands related to linting, formatting, and building, run `just
 
 2. Initialize the Python project:
     ```sh
-    uv init . --python 3.10
+    uv init . --python 3.11
     ```
 
 3. Set the SDK path:
@@ -51,12 +65,15 @@ For additional commands related to linting, formatting, and building, run `just
     uv add --editable ${PATH_TO_SDK}
     ```
 
-> **Note:** Instead of cloning the project into `.venv/lib/python3.10/site-packages/uipath`, this mode creates a file named `_uipath.pth` inside `.venv/lib/python3.10/site-packages`. This file contains the value of `PATH_TO_SDK`, which is added to `sys.path`—the list of directories where Python searches for packages. To view the entries, run `python -c 'import sys; print(sys.path)'`.
+> **Note:** Instead of cloning the project into `.venv/lib/python3.11/site-packages/uipath`, this mode creates a file named `_uipath.pth` inside `.venv/lib/python3.11/site-packages`. This file contains the value of `PATH_TO_SDK`, which is added to `sys.path`—the list of directories where Python searches for packages. To view the entries, run `python -c 'import sys; print(sys.path)'`.
 
 ## API Style Guide
 
 ### General Rule
 - Use `key` instead of `id` for resource identifiers
+- Write well-typed, type-checker-friendly code.
+  - Do not use `# type: ignore` comments unless *absolutely* required.
+  - NEVER use `# type: ignore` at the start of a file.
 
 ### Standard Methods and Naming Conventions
 
@@ -81,3 +98,11 @@ For additional commands related to linting, formatting, and building, run `just
 #### Update a Resource
 - **Method Name:** `update`
 - **Purpose:** Modify an existing resource
+
+## Pull Requests
+
+### General Rules
+- Please write informative description to the PRs for the reviewers to understand the context.
+- If you want to publish a `dev` build, please add a `build:dev` label to your PR.
+  - You can then use the published `dev` version from the PR description/comments to use as needed <img width="880" height="433" alt="image" src="https://github.com/user-attachments/assets/b670bb08-a469-454f-a5f6-10d60477c033" />
+
diff --git a/packages/uipath/README.md b/packages/uipath/README.md
new file mode 100644
index 000000000..d90c937fc
--- /dev/null
+++ b/packages/uipath/README.md
@@ -0,0 +1,206 @@
+# UiPath Python SDK
+
+[![PyPI downloads](https://img.shields.io/pypi/dm/uipath.svg)](https://pypi.org/project/uipath/)
+[![PyPI - Version](https://img.shields.io/pypi/v/uipath)](https://img.shields.io/pypi/v/uipath)
+[![Python versions](https://img.shields.io/pypi/pyversions/uipath.svg)](https://pypi.org/project/uipath/)
+
+A Python SDK that enables programmatic interaction with UiPath Cloud Platform services including processes, assets, buckets, context grounding, data services, jobs, and more. The package also features a CLI for creation, packaging, and deployment of automations to UiPath Cloud Platform.
+
+Use the [UiPath LangChain SDK](https://github.com/UiPath/uipath-langchain-python) to pack and publish LangGraph Agents.
+
+Check out other [UiPath Integrations](https://github.com/UiPath/uipath-integrations-python) to pack and publish agents built with LlamaIndex, OpenAI Agents, Google ADK, and more.
+
+This [quickstart guide](https://uipath.github.io/uipath-python/) walks you through deploying your first agent to UiPath Cloud Platform.
+
+## Table of Contents
+
+-   [Installation](#installation)
+-   [Configuration](#configuration)
+    -   [Environment Variables](#environment-variables)
+-   [Basic Usage](#basic-usage)
+-   [Available Services](#available-services)
+-   [Examples](#examples)
+    -   [Buckets Service](#buckets-service)
+    -   [Context Grounding Service](#context-grounding-service)
+-   [Command Line Interface (CLI)](#command-line-interface-cli)
+    -   [Authentication](#authentication)
+    -   [Initialize a Project](#initialize-a-project)
+    -   [Debug a Project](#debug-a-project)
+    -   [Package a Project](#package-a-project)
+    -   [Publish a Package](#publish-a-package)
+-   [Project Structure](#project-structure)
+-   [Development](#development)
+    -   [Setting Up a Development Environment](#setting-up-a-development-environment)
+
+## Installation
+
+```bash
+pip install uipath
+```
+
+using `uv`:
+
+```bash
+uv add uipath
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project root with the following variables:
+
+```
+UIPATH_URL=https://cloud.uipath.com/ACCOUNT_NAME/TENANT_NAME
+UIPATH_ACCESS_TOKEN=YOUR_TOKEN_HERE
+```
+
+## Basic Usage
+
+```python
+from uipath.platform import UiPath
+# Initialize the SDK
+sdk = UiPath()
+# Execute a process
+job = sdk.processes.invoke(
+    name="MyProcess",
+    input_arguments={"param1": "value1", "param2": 42}
+)
+# Work with assets
+asset = sdk.assets.retrieve(name="MyAsset")
+```
+
+## Available Services
+
+The SDK provides access to various UiPath services:
+
+-   `sdk.processes` - Manage and execute UiPath automation processes
+
+-   `sdk.assets` - Work with assets (variables, credentials) stored in UiPath
+
+-   `sdk.buckets` - Manage cloud storage containers for automation files
+
+-   `sdk.connections` - Handle connections to external systems
+
+-   `sdk.context_grounding` - Work with semantic contexts for AI-enabled automation
+
+-   `sdk.jobs` - Monitor and manage automation jobs
+
+-   `sdk.queues` - Work with transaction queues
+
+-   `sdk.tasks` - Work with Action Center
+
+-   `sdk.api_client` - Direct access to the API client for custom requests
+
+## Examples
+
+### Buckets Service
+
+```python
+# Download a file from a bucket
+sdk.buckets.download(
+    bucket_key="my-bucket",
+    blob_file_path="path/to/file.xlsx",
+    destination_path="local/path/file.xlsx"
+)
+```
+
+### Context Grounding Service
+
+```python
+# Search for contextual information
+results = sdk.context_grounding.search(
+    name="my-knowledge-index",
+    query="How do I process an invoice?",
+    number_of_results=5
+)
+```
+
+## Command Line Interface (CLI)
+
+The SDK also provides a command-line interface for creating, packaging, and deploying automations:
+
+### Authentication
+
+```bash
+uipath auth
+```
+
+This command opens a browser for authentication and creates/updates your `.env` file with the proper credentials.
+
+### Initialize a Project
+
+```bash
+uipath init
+```
+
+The `uipath.json` file should include your entry points in the `functions` section:
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+Running `uipath init` will process these function definitions and create the corresponding `entry-points.json` file needed for deployment.
+
+For more details on the configuration format, see the [UiPath configuration specifications](specs/README.md).
+
+### Debug a Project
+
+```bash
+uipath run ENTRYPOINT [INPUT]
+```
+
+Executes a Python script with the provided JSON input arguments.
+
+### Package a Project
+
+```bash
+uipath pack
+```
+
+Packages your project into a `.nupkg` file that can be deployed to UiPath.
+
+**Note:** Your `pyproject.toml` must include:
+
+-   A description field (avoid characters: &, <, >, ", ', ;)
+-   Author information
+
+Example:
+
+```toml
+description = "Your package description"
+authors = [{name = "Your Name", email = "your.email@example.com"}]
+```
+
+### Publish a Package
+
+```bash
+uipath publish
+```
+
+Publishes the most recently created package to your UiPath Orchestrator.
+
+## Project Structure
+
+To properly use the CLI for packaging and publishing, your project should include:
+
+-   A `pyproject.toml` file with project metadata
+-   A `uipath.json` file with your function definitions (e.g., `"functions": {"main": "main.py:main"}`)
+-   A `entry-points.json` file (generated by `uipath init`)
+-   A `bindings.json` file (generated by `uipath init`) to configure resource overrides
+-   Any Python files needed for your automation
+
+
+## Development
+
+### Tools
+
+Check out [uipath-dev](https://github.com/uipath/uipath-dev-python) - an interactive application for building, testing, and debugging UiPath Python runtimes, agents, and automation scripts.
+
+### Contributions
+
+Please read our [contribution guidelines](https://github.com/UiPath/uipath-integrations-python/blob/main/CONTRIBUTING.md) before submitting a pull request.
+
diff --git a/packages/uipath/docs/AutomationSuite.md b/packages/uipath/docs/AutomationSuite.md
new file mode 100644
index 000000000..ca1f820c8
--- /dev/null
+++ b/packages/uipath/docs/AutomationSuite.md
@@ -0,0 +1,150 @@
+# Automation Suite
+
+## Airgapped Deployments
+
+Airgapped Automation Suite environments (deployments without internet access) require special configuration for Python package dependencies. You need to configure your project to use a Python package feed that is accessible within your environment.
+
+You have two main options for managing Python packages:
+
+1. **Use Azure DevOps Artifacts** - Leverage Azure DevOps as a Python package feed with upstream PyPI sources (suitable for environments with restricted but not fully airgapped access)
+2. **Host your own Python package index** - Set up a self-hosted PyPI mirror or repository within your infrastructure (required for truly airgapped environments)
+
+### Using Azure DevOps Artifacts as a Python Feed
+
+Azure DevOps Artifacts can serve as a private Python package feed that includes packages from common public sources (PyPI). This is suitable for environments with restricted internet access where Azure DevOps services are still accessible.
+
+#### Step 1: Create an Azure DevOps Artifacts Feed
+
+1. Navigate to your Azure DevOps project
+2. Go to **Artifacts**
+3. Click **Create Feed**
+4. Configure your feed settings and ensure you select the option to **Include packages from common public sources** (this will upstream PyPI packages)
+
+#### Step 2: Authenticate with a Personal Access Token (PAT)
+
+You'll need to create a Personal Access Token (PAT) to authenticate with your Azure DevOps feed.
+
+1. Follow the [Microsoft documentation to create a PAT](https://learn.microsoft.com/en-us/azure/devops/organizations/accounts/use-personal-access-tokens-to-authenticate?view=azure-devops&tabs=Windows)
+2. Ensure your PAT has at least **Packaging (Read)** permissions
+3. Save your PAT securely - you'll need it for the next step
+
+#### Step 3: Configure Your Project
+
+Add the following configuration to your `pyproject.toml` file:
+
+```toml
+[[tool.uv.index]]
+name = "my-feed"
+url = "https://az:PAT_STRING@YOUR_ORG.pkgs.visualstudio.com/YourProject/_packaging/my-feed/pypi/simple/"
+publish-url = "https://az:PAT_STRING@YOUR_ORG.pkgs.visualstudio.com/YourProject/_packaging/my-feed/pypi/upload/"
+default = true
+```
+
+Replace the following placeholders:
+
+- **`PAT_STRING`**: Your actual Personal Access Token from Step 2
+- **`YOUR_ORG`**: Your Azure DevOps organization name
+- **`YourProject`**: Your Azure DevOps project name
+- **`my-feed`**: The name of your feed (in both the `name` field and the URL)
+
+/// tip
+**Organization-scoped feeds**: If you're using an organization-scoped feed instead of a project-scoped feed, the URL format will be slightly different, but the same authentication logic applies. The URL will follow this pattern:
+
+```toml
+url = "https://az:PAT_STRING@YOUR_ORG.pkgs.visualstudio.com/_packaging/my-feed/pypi/simple/"
+```
+
+Note the absence of the project name in the URL path.
+///
+
+/// tip
+**Using environment variables**: You can also configure the feed URL using environment variables instead of hardcoding the PAT in `pyproject.toml`:
+
+```toml
+[[tool.uv.index]]
+name = "my-feed"
+url = "https://az:${AZURE_DEVOPS_PAT}@YOUR_ORG.pkgs.visualstudio.com/YourProject/_packaging/my-feed/pypi/simple/"
+default = true # to use this feed as your default
+```
+
+Then set the environment variable before running your commands locally:
+
+```bash
+export AZURE_DEVOPS_PAT=your_pat_token
+```
+
+**Important**: When deploying your process to UiPath, you'll need to configure these environment variables in the process settings. Navigate to your process in UiPath Orchestrator and add the environment variables (e.g., `AZURE_DEVOPS_PAT`) with their corresponding values. This ensures your process can authenticate with the external feed when running in the UiPath environment.
+///
+
+/// tip
+**Specifying sources for specific packages**: If you don't want to set your custom feed as the default, you can use `[tool.uv.sources]` to specify which packages should come from your custom feed:
+
+```toml
+[[tool.uv.index]]
+name = "my-feed"
+url = "https://az:PAT_STRING@YOUR_ORG.pkgs.visualstudio.com/YourProject/_packaging/my-feed/pypi/simple/"
+
+[tool.uv.sources]
+uipath = { index = "my-feed" }
+# Add other packages as needed
+some-private-package = { index = "my-feed" }
+```
+
+This allows you to selectively pull specific packages from your custom feed while using the default PyPI for others.
+///
+
+#### Step 4: Install Dependencies
+
+Once configured, you can install dependencies using `uv`:
+
+<!-- termynal -->
+```bash
+> uv add uipath
+⠋ Resolved 25 packages from my-feed
+✓  Successfully installed uipath
+```
+
+#### Verification
+
+To verify your feed configuration is working correctly, you can check that `uv` resolves packages from your custom feed:
+
+<!-- termynal -->
+```bash
+> uv add --dry-run uipath
+⠋ Checking package availability...
+✓  All packages available from my-feed
+```
+
+### Hosting Your Own Python Package Index
+
+For truly airgapped deployments where you need complete control over your infrastructure, you can host your own Python package index within your network. This approach eliminates any external dependencies and provides full control over the packages available in your environment.
+
+#### Popular Self-Hosted Solutions
+
+Several tools are available for hosting a Python package index:
+
+- **[devpi](https://devpi.net/)** - A PyPI-compatible server with caching and mirroring capabilities
+- **[PyPI Server](https://pypi.org/project/pypiserver/)** - A minimal PyPI-compatible server for hosting packages
+- **[JFrog Artifactory](https://jfrog.com/artifactory/)** - Enterprise artifact repository with Python support
+- **[Sonatype Nexus Repository](https://www.sonatype.com/products/nexus-repository)** - Universal artifact repository manager
+- **[bandersnatch](https://github.com/pypa/bandersnatch)** - PyPI mirror client for creating a complete or filtered mirror
+
+#### Configuration for Self-Hosted Index
+
+Once you have your Python package index set up and accessible within your airgapped network, configure your `pyproject.toml` to point to it:
+
+```toml
+[[tool.uv.index]]
+name = "internal-pypi"
+url = "https://pypi.internal.company.com/simple/"
+default = true
+```
+
+If your internal index requires authentication:
+
+```toml
+[[tool.uv.index]]
+name = "internal-pypi"
+url = "https://username:password@pypi.internal.company.com/simple/"
+default = true
+```
diff --git a/docs/CONTRIBUTING.md b/packages/uipath/docs/CONTRIBUTING.md
similarity index 100%
rename from docs/CONTRIBUTING.md
rename to packages/uipath/docs/CONTRIBUTING.md
diff --git a/docs/FAQ.md b/packages/uipath/docs/FAQ.md
similarity index 79%
rename from docs/FAQ.md
rename to packages/uipath/docs/FAQ.md
index 1d18a5ef0..602a42196 100644
--- a/docs/FAQ.md
+++ b/packages/uipath/docs/FAQ.md
@@ -1,6 +1,6 @@
 # Frequently Asked Questions (FAQ)
 
-### Q: Why am I getting a "Failed to prepare environment" error when deploying my python agent to UiPath Cloud Platform?
+### Q: Why am I getting a "Failed to prepare environment" error when deploying my Python project to UiPath Cloud Platform?
 
 #### Error Message
 
@@ -30,12 +30,12 @@
 
 #### Description
 
-This error might occur when deploying coded-agents to UiPath Cloud Platform, even though the same project might work correctly in your local environment. The issue is often related to how Python packages are discovered and distributed during the cloud deployment process.
+This error might occur when deploying coded functions or coded agents to UiPath Cloud Platform, even though the same project might work correctly in your local environment. The issue is often related to how Python packages are discovered and distributed during the cloud deployment process.
 
 #### Common Causes
 
 1. Multiple top-level packages or modules in your project structure
-2. Improper configuration or formatting in the pyproject.toml or requirements.txt files
+2. Improper configuration or formatting in the pyproject.toml file
 
 #### Solution
 
@@ -66,7 +66,7 @@ packages = ["your_package"]
 
 ##### 3. Verify Dependencies
 
-- Ensure all required dependencies are properly listed in your `requirements.txt` or `pyproject.toml`
+- Ensure all required dependencies are properly listed in your `pyproject.toml`
 
 #### Reference
 
@@ -283,6 +283,55 @@ If you encounter SSL certificate errors:
    ////
 
 
+### Q: Why are my job runs hanging on UiPath Cloud Platform?
+
+#### Error Message
+
+You may see errors like these in the logs panel:
+
+```python
+[Error] .venv/lib/python3.14/site-packages/azure/monitor/opentelemetry/exporter/export/_base.py:472: SyntaxWarning: 'return' in a 'finally' block
+[Error]   return ExportResult.FAILED_NOT_RETRYABLE  # pylint: disable=W0134
+[Error] .venv/lib/python3.14/site-packages/azure/monitor/opentelemetry/exporter/export/_base.py:474: SyntaxWarning: 'return' in a 'finally' block
+[Error]   return result  # pylint: disable=W0134
+```
+
+#### Description
+
+If your Python job runs are hanging or not completing when deployed to UiPath Cloud Platform's serverless environment, this may be caused by a library incompatibility issue from an outdated version of the UiPath Python library.
+
+#### Solution
+
+Ensure you're using **`uipath` version 2.1.169 or later**. This version includes fixes for serverless execution.
+
+To check your current version:
+
+<!-- termynal -->
+```bash
+> uipath --version
+uipath version 2.1.169
+```
+
+To upgrade to the latest version:
+
+<!-- termynal -->
+```bash
+> uv sync --upgrade-package uipath
+Installed 1 package in 15ms
+ - uipath==2.1.140
+ + uipath==2.1.169
+```
+
+After upgrading, update your `pyproject.toml` to ensure the correct version is used in your deployment:
+
+**pyproject.toml:**
+```toml
+[project]
+dependencies = [
+    "uipath>=2.1.169",
+]
+```
+
 ---
 
 *Note: This FAQ will be updated as new information becomes available. If you continue experiencing issues after following these solutions, please contact UiPath support.*
diff --git a/docs/assets/env-preparation-failed-dark.png b/packages/uipath/docs/assets/env-preparation-failed-dark.png
similarity index 100%
rename from docs/assets/env-preparation-failed-dark.png
rename to packages/uipath/docs/assets/env-preparation-failed-dark.png
diff --git a/docs/assets/env-preparation-failed-light.png b/packages/uipath/docs/assets/env-preparation-failed-light.png
similarity index 100%
rename from docs/assets/env-preparation-failed-light.png
rename to packages/uipath/docs/assets/env-preparation-failed-light.png
diff --git a/packages/uipath/docs/assets/favicon.png b/packages/uipath/docs/assets/favicon.png
new file mode 100644
index 000000000..e6ed2a94b
Binary files /dev/null and b/packages/uipath/docs/assets/favicon.png differ
diff --git a/docs/assets/logo-dark.svg b/packages/uipath/docs/assets/logo-dark.svg
similarity index 100%
rename from docs/assets/logo-dark.svg
rename to packages/uipath/docs/assets/logo-dark.svg
diff --git a/docs/assets/logo-light.svg b/packages/uipath/docs/assets/logo-light.svg
similarity index 100%
rename from docs/assets/logo-light.svg
rename to packages/uipath/docs/assets/logo-light.svg
diff --git a/packages/uipath/docs/cli/index.md b/packages/uipath/docs/cli/index.md
new file mode 100644
index 000000000..e74a4d83e
--- /dev/null
+++ b/packages/uipath/docs/cli/index.md
@@ -0,0 +1,473 @@
+# CLI Reference
+
+The following commands apply to both **coded functions** and **coded agents**. The entry point name (`main`, `agent`, or any key you define in `uipath.json`) is the first argument to `run`, `debug`, `eval`, and `invoke`.
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: auth
+    :depth: 1
+    :style: table
+
+/// info | UiPath Automation Suite
+For UiPath Automation Suite deployments, you must set the `UIPATH_URL` environment variable to your dedicated instance URL before running this command.
+
+Example:
+```bash
+UIPATH_URL=https://your-instance.com/account/tenant/orchestrator_/
+```
+
+You can set this environment variable either:
+- In a `.env` file in your project directory
+- As a system-wide environment variable
+///
+
+<!-- termynal -->
+
+```shell
+> uipath auth
+⠋ Authenticating with UiPath ...
+🔗 If a browser window did not open, please open the following URL in your browser: [LINK]
+👇 Select tenant:
+  0: Tenant1
+  1: Tenant2
+Select tenant number: 0
+Selected tenant: Tenant1
+✓  Authentication successful.
+```
+
+/// info | Unattended Authentication (Client Credentials)
+
+For CI/CD pipelines and other non-interactive contexts, authenticate with the OAuth client credentials flow by passing all three of `--client-id`, `--client-secret`, and `--base-url`. The CLI exchanges them for an access token and writes it to the same on-disk session used by interactive logins, so subsequent commands like `uipath publish` and `uipath invoke` work without further setup.
+
+The `--base-url` must point at the tenant scope (`https://<host>/<organization>/<tenant>`). The optional `--scope` flag controls the OAuth scopes requested and defaults to `OR.Execution`. Pass a space-separated list (for example `"OR.Execution OR.Queues"`) to request additional scopes — match the scopes you granted to the External Application and the operations you intend to run.
+
+**Setup:**
+
+1. In the Automation Cloud **Admin** page, open **External Applications** and create one of type *Confidential*. Grant it the Orchestrator scopes you need (for example `OR.Execution`). See the [External Applications guide](https://docs.uipath.com/automation-cloud/automation-cloud/latest/admin-guide/managing-external-applications) for details.
+2. Copy the generated **App ID** and **App Secret** — these become `--client-id` and `--client-secret`.
+
+**Example:**
+
+<!-- termynal -->
+```shell
+> uipath auth --client-id 12345678-c4c5-4f1f-93ff-4f5ab47d57ea \
+              --client-secret 'your-secret' \
+              --base-url https://cloud.uipath.com/your-org/your-tenant
+✓  Authentication successful.
+> uipath publish --tenant
+```
+
+/// warning
+Treat `--client-secret` as a credential. In CI, prefer reading it from a secret store and passing it on the command line, rather than committing it to source control or leaving it in shell history.
+///
+
+**Configuring the same flow in code:** if you would rather skip the CLI session and pass credentials directly to the SDK, the [`asset-modifier-agent` sample](https://github.com/UiPath/uipath-python/tree/main/packages/uipath/samples/asset-modifier-agent) shows how to construct a `UiPath` client with `client_id`, `client_secret`, `scope`, and `base_url` from environment variables.
+
+///
+
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: init
+    :depth: 1
+    :style: table
+
+Initializes a UiPath project by generating all required configuration and metadata files. Run this command when setting up a new project and after modifying your agent's or function's input/output schema.
+
+### Generated Files
+
+| File | Description |
+|------|-------------|
+| `uipath.json` | Project configuration with entrypoint definitions |
+| `bindings.json` | Resource bindings (assets, processes, buckets, etc.) |
+| `entry-points.json` | Entry point definitions with input/output schemas |
+| `project.uiproj` | Project metadata for StudioWeb integration |
+| `.uipath/studio_metadata.json` | Studio metadata (schema and code version) |
+| `.env` | Environment variables file |
+| `AGENTS.md`, `CLAUDE.md` | Agent documentation and coding assistant instructions |
+| `.agent/CLI_REFERENCE.md`, `.agent/SDK_REFERENCE.md`, `.agent/REQUIRED_STRUCTURE.md` | Agent reference docs |
+
+/// warning
+
+The `uipath.json` file should include your entry points in the `functions` section:
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+Running `uipath init` will process these function definitions and create the corresponding `entry-points.json` file needed for deployment.
+///
+
+
+<!-- termynal -->
+```shell
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'uipath.json' file.
+✓  Created 'bindings.json' file.
+✓  Created 'entry-points.json' file with 1 entrypoint(s).
+✓  Created 1 mermaid diagram file(s).
+✓  Updated 'project.uiproj' file.
+✓  Created '.uipath/studio_metadata.json' file.
+✓  Created: CLAUDE.md, CLI_REFERENCE.md, SDK_REFERENCE.md, AGENTS.md, REQUIRED_STRUCTURE.md.
+```
+
+/// info
+### About the `.mermaid` files
+
+`uipath init` generates one `<entrypoint>.mermaid` file per function/agent containing a static call graph, rendered in the UiPath Orchestrator UI. These files are regenerated on every `uipath init`.
+///
+
+/// warning
+### About the `id` field
+
+The first `uipath init` mints a stable `id` (GUID) into `uipath.json` and preserves it across subsequent runs. It is what identifies your project consistently wherever it is deployed and run.
+
+Do not change or remove it. Changing it makes the project look like a brand-new, unrelated one, so you lose the link to everything previously published and tracked under the old id. `uipath pack` rejects an `id` that is not a valid GUID.
+///
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: run
+    :depth: 1
+    :style: table
+
+/// tip
+For step-by-step debugging with breakpoints and variable inspection (supported from `2.0.66` onward):
+```console
+# Install debugpy package
+uv pip install debugpy
+# Run with debugging enabled
+uipath run [ENTRYPOINT] [INPUT] --debug
+```
+For vscode:
+1. add the [debug configuration](https://github.com/UiPath/uipath-python/blob/main/.vscode/launch.json) in your `.vscode/launch.json` file.
+2. Place breakpoints in your code where needed.
+3. Use the shortcut `F5`, or navigate to Run -> Start Debugging -> Python Debugger: Attach.
+
+Upon starting the debugging process, one should see the following logs in terminal:
+```console
+🐛 Debug server started on port 5678
+📌 Waiting for debugger to attach...
+  - VS Code: Run -> Start Debugging -> Python Debugger: Attach
+✓  Debugger attached successfully!
+```
+///
+
+/// warning
+Depending on the shell you are using, it may be necessary to escape the input json:
+
+/// tab | Bash/ZSH
+```console
+uipath run main '{"message": "hello"}'
+```
+///
+
+/// tab | Windows CMD
+```console
+uipath run main "{""message"": ""hello""}"
+```
+///
+
+/// tab | Windows PowerShell
+```console
+uipath run main '{\"message\":\"hello\"}'
+```
+///
+
+///
+
+<!-- termynal -->
+
+```shell
+> uipath run main '{"message": "test"}'
+[2025-04-11 10:13:58,857][INFO] {'message': 'test'}
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: pack
+    :depth: 1
+    :style: table
+
+Packages your project into a `.nupkg` file that can be deployed to UiPath.
+
+/// info
+### Default Files Included in `.nupkg`
+
+By default, the following file types are included in the `.nupkg` file:
+
+- `.py`
+- `.mermaid`
+- `.json`
+- `.yaml`
+- `.yml`
+- `.md`
+
+---
+
+### Including Extra Files
+
+To include additional files, update the `uipath.json` file by adding a `packOptions` section. Use the following configuration format:
+
+```json
+{
+    "packOptions": {
+        "filesIncluded": [
+            "<file here>"
+        ],
+        "fileExtensionsIncluded": [
+            "<new file extension to include, with leading dot (e.g., '.go')>"
+        ]
+    }
+}
+```
+
+///
+
+/// warning
+Your `pyproject.toml` must include:
+
+-   A description field (avoid characters: &, <, >, ", ', ;)
+-   Author information
+
+Example:
+
+```toml
+description = "Your package description"
+authors = [{name = "Your Name", email = "your.email@example.com"}]
+```
+///
+
+/// info
+### Dependency Locking
+
+By default, `uipath pack` includes `uv.lock` in the `.nupkg` (creating it if it does not exist). The executor then installs the pinned versions from the lock file, so every run uses the exact same dependency versions.
+
+Use `--nolock` to opt out — `uv.lock` is not added to the package. With no lock file present, the executor resolves dependencies on each run and picks the latest versions compatible with the constraints in your `pyproject.toml`.
+
+<!-- termynal -->
+```shell
+> uipath pack --nolock
+⠋ Packaging project ...
+✓  Project successfully packaged.
+```
+
+**When to lock (default):** you want reproducible runs and protection against breaking changes or malicious upgrades in your dependencies. The versions you tested with are the versions that run.
+
+**When to use `--nolock`:** you want each run to pick up the latest patches automatically within your declared constraints, or your project does not use uv.
+///
+
+<!-- termynal -->
+```shell
+> uipath pack
+⠋ Packaging project ...
+Name       : test
+Version    : 0.1.0
+Description: Add your description here
+Authors    : Your Name
+✓  Project successfully packaged.
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: publish
+    :depth: 1
+    :style: table
+
+/// warning
+To properly use the CLI for packaging and publishing, your project should include:
+
+-   A `pyproject.toml` file with project metadata
+-   A `uipath.json` file (generated by `uipath init`)
+-   Any Python files needed for your automation
+///
+
+<!-- termynal -->
+
+```shell
+> uipath publish
+⠋ Fetching available package feeds...
+👇 Select package feed:
+  0: Orchestrator Tenant Processes Feed
+  1: Orchestrator Personal Workspace Feed
+Select feed number: 0
+Selected feed: Orchestrator Tenant Processes Feed
+⠸ Publishing most recent package: test.0.1.0.nupkg ...
+✓  Package published successfully!
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: deploy
+    :depth: 1
+    :style: table
+
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: invoke
+    :depth: 1
+    :style: table
+
+<!-- termynal -->
+
+```shell
+> uipath invoke main '{"message": "hello"}'
+⠴ Loading configuration ...
+⠴ Starting job ...
+✨ Job started successfully!
+🔗 Monitor your job here: [LINK]
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: push
+    :depth: 1
+    :style: table
+
+<!-- termynal -->
+
+```shell
+> uipath push
+Pushing UiPath project to Studio Web...
+Uploading 'main.py'
+Uploading 'uipath.json'
+Updating 'pyproject.toml'
+Uploading '.uipath/studio_metadata.json'
+
+Importing referenced resources to Studio Web project...
+
+ 🔵 Resource import summary: 0 total resources - 0 created, 0 updated, 0 unchanged, 0 not found
+```
+
+/// info
+### Dependency Locking
+
+By default, `uipath push` includes `uv.lock` in the upload (creating it if it does not exist). The executor then installs the pinned versions from the lock file, so every run uses the exact same dependency versions.
+
+Use `--nolock` to opt out — `uv.lock` is not uploaded. With no lock file present, the executor resolves dependencies on each run and picks the latest versions compatible with the constraints in your `pyproject.toml`.
+
+**When to lock (default):** you want reproducible runs and protection against breaking changes or malicious upgrades in your dependencies. The versions you tested with are the versions that run.
+
+**When to use `--nolock`:** you want each run to pick up the latest patches automatically within your declared constraints, or your project does not use uv.
+///
+
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: pull
+    :depth: 1
+    :style: table
+
+<!-- termynal -->
+
+```shell
+> uipath pull
+Pulling UiPath project from Studio Web...
+Processing: main.py
+Updated 'main.py'
+Processing: uipath.json
+File 'uipath.json' is up to date
+✓  Project pulled successfully
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: debug
+    :depth: 1
+    :style: table
+
+Runs your project under the debug runtime, with a debug bridge attached. Locally, the bridge is the interactive **console** (read commands from stdin, stop at breakpoints). In the cloud, the bridge is **SignalR** (driven by Studio Web / Orchestrator). The `--attach` flag lets you override that default, including `none` for executors that need the debug command's surrounding behavior (bindings fetch, state streaming) but cannot speak the interactive debug protocol.
+
+### Attach modes
+
+| Mode | When to use |
+|------|-------------|
+| `signalr` | Remote runs driven by Studio Web / Orchestrator. Default when `job_id` is set. |
+| `console` | Local interactive debugging from the terminal. Default when no `job_id`. |
+| `none` | Run under the debug command without attaching a debugger. No wait-for-start gate, no breakpoints, no step mode. |
+
+/// info
+`--attach` selects the **debug bridge**. It's unrelated to `--debug`, which starts a `debugpy` server for Python-level breakpoints in your IDE. The two can be combined.
+///
+
+<!-- termynal -->
+
+```shell
+> uipath debug main '{"message": "test"}'
+Debug Mode Commands
+  c, continue     Continue until next breakpoint
+  s, step         Step to next node
+  b <node>        Set breakpoint at <node>
+  l, list         List all breakpoints
+  r <node>        Remove breakpoint at <node>
+  h, help         Show help
+  q, quit         Exit debugger
+▶ START
+> b analyze_sentiment
+✓ Breakpoint set at: analyze_sentiment
+> c
+────────────────────────────────────────
+■ BREAKPOINT analyze_sentiment (before)
+Next: analyze_sentiment
+────────────────────────────────────────
+> s
+● analyze_sentiment
+> c
+✓ Execution completed
+```
+---
+
+::: mkdocs-click
+    :module: uipath._cli
+    :command: eval
+    :depth: 1
+    :style: table
+
+Runs an evaluation set against your project. Entry point and eval set are auto-discovered from the project if not passed explicitly. Evaluations run in parallel (see `--workers`) and, unless `--no-report` is passed, results are reported back to Studio Web when `UIPATH_PROJECT_ID` is set.
+
+### Common flags
+
+| Flag | Purpose |
+|------|---------|
+| `--eval-ids` | Run only a subset of evaluations by id. |
+| `--workers` | Parallel workers for running evaluations (default 1). |
+| `--no-report` | Skip reporting results back to UiPath. |
+| `--enable-mocker-cache` | Cache LLM mocker responses across runs. |
+| `--input-overrides` | Per-eval input overrides, merged into the eval's input. |
+| `--trace-file` | Write OpenTelemetry traces to a JSONL file for offline inspection. |
+| `--resume` | Resume evaluation from a previous suspended state. |
+
+<!-- termynal -->
+
+```shell
+> uipath eval
+⠋ Running evaluations ...
+  Weather in Paris
+  LLM Judge Output       0.7
+  Tool Call Arguments    1.0
+  Tool Call Count        1.0
+  Tool Call Order        1.0
+
+Evaluation Results
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓
+┃  Evaluation        ┃  LLM Judge Output  ┃  Tool Call Args    ┃  Tool Call Count   ┃  Tool Call Order   ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━┩
+│  Weather in Paris  │               0.7  │               1.0  │               1.0  │               1.0  │
+├────────────────────┼────────────────────┼────────────────────┼────────────────────┼────────────────────┤
+│  Average           │               0.7  │               1.0  │               1.0  │               1.0  │
+└────────────────────┴────────────────────┴────────────────────┴────────────────────┴────────────────────┘
+```
diff --git a/packages/uipath/docs/core/agents.md b/packages/uipath/docs/core/agents.md
new file mode 100644
index 000000000..21b812647
--- /dev/null
+++ b/packages/uipath/docs/core/agents.md
@@ -0,0 +1,244 @@
+# Python Coded Agents
+
+A coded agent is Python code that uses an LLM reasoning loop to make decisions, call tools, and produce a result. You write the agent logic using a framework of your choice — the `uipath` SDK provides the platform layer: authentication, assets, buckets, connections, tracing, and human-in-the-loop. Package it with the CLI and deploy it as an Orchestrator job.
+
+Use a coded agent when your automation needs multi-step reasoning, dynamic tool selection, or LLM-driven decisions. Use a [coded function](./functions.md) when your logic is deterministic and no LLM is required.
+
+---
+
+## Architecture
+
+Every coded agent is built from two layers:
+
+| Layer | Package | Responsibility |
+|-------|---------|---------------|
+| **Platform** | `uipath` | Auth, assets, buckets, connections, tracing, human-in-the-loop, CLI, packaging |
+| **Framework** | one extension (see below) | LLM calls, tool routing, agent loop, memory |
+
+The `uipath` package is always required. Add one framework extension on top:
+
+| Framework | Package | Best for |
+|-----------|---------|---------|
+| LangChain / LangGraph | `uipath-langchain` | Graph-based agents, complex multi-step flows |
+| LlamaIndex | `uipath-llamaindex` | RAG-heavy agents, document reasoning |
+| OpenAI Agents SDK | `uipath-openai-agents` | OpenAI-native tool use, handoffs |
+| PydanticAI | `uipath-pydantic-ai` | Type-safe agents with Pydantic models |
+| Google ADK | `uipath-google-adk` | Gemini models, Google ecosystem |
+| UiPath Agent Framework | `uipath-agent-framework` | UiPath-native agent primitives |
+
+---
+
+## Quickstart
+
+The example below uses LangChain. Swap `uipath-langchain` for the framework of your choice.
+
+//// tab | uv
+
+<!-- termynal -->
+
+```shell
+> mkdir my-agent && cd my-agent
+> uv init . --python 3.11
+> uv add uipath uipath-langchain
+
+> uipath auth
+⠋ Authenticating with UiPath ...
+✓  Authentication successful.
+
+> uipath new agent
+✓  Created new agent project.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+✓  Created 'bindings.json' file.
+
+> uipath run agent '{"message": "hello"}'
+```
+
+////
+
+//// tab | pip
+
+<!-- termynal -->
+
+```shell
+> mkdir my-agent && cd my-agent
+> python -m venv .venv
+> source .venv/bin/activate
+> pip install uipath uipath-langchain
+
+> uipath auth
+⠋ Authenticating with UiPath ...
+✓  Authentication successful.
+
+> uipath new agent
+✓  Created new agent project.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+✓  Created 'bindings.json' file.
+
+> uipath run agent '{"message": "hello"}'
+```
+
+////
+
+---
+
+## Project Structure
+
+```
+my-agent/
+├── main.py            # agent graph
+├── langgraph.json     # graph entry points (framework-specific)
+├── pyproject.toml     # project metadata and dependencies
+├── entry-points.json  # generated — I/O JSON Schema
+└── bindings.json      # generated — resource binding overrides
+```
+
+### `langgraph.json`
+
+```json
+{
+  "graphs": {
+    "agent": "./main.py:graph"
+  }
+}
+```
+
+Declares the agent's graph entry points. The filename is framework-specific — `langgraph.json` for LangChain/LangGraph, `llamaindex.json` for LlamaIndex, and so on. Its presence, together with the framework dependency below, is what marks the project as a coded agent.
+
+### `pyproject.toml`
+
+```toml
+[project]
+name = "my-agent"
+version = "0.1.0"
+description = "..."
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.11"
+dependencies = ["uipath>=2.0", "uipath-langchain>=2.0"]
+```
+
+Standard metadata plus the framework dependency (`uipath-langchain` here). The framework graph file and this dependency identify the project as a coded agent — `pyproject.toml` needs no UiPath-specific entries, and `uipath.json` carries no agent entry.
+
+---
+
+## Input & Output
+
+Define `Input` and `Output` the same way as [coded functions](./functions.md#input--output) — a stdlib `@dataclass`, a pydantic `BaseModel`, or `pydantic.dataclasses.dataclass`:
+
+```python
+from dataclasses import dataclass
+
+
+@dataclass
+class Input:
+    message: str
+
+
+@dataclass
+class Output:
+    response: str
+
+
+def agent(input: Input) -> Output:
+    ...
+```
+
+---
+
+## Platform Services
+
+The `uipath` SDK gives your agent access to Orchestrator resources at runtime — credentials are injected automatically when running as a job.
+
+```python
+from uipath.platform import UiPath
+
+sdk = UiPath()
+```
+
+The full set of Orchestrator services is available to agents:
+
+- **Assets** — read credentials and configuration: [Assets reference](./assets.md)
+- **Buckets** — download and upload files: [Buckets reference](./buckets.md)
+- **Connections** — Integration Service connections for ERP and SaaS: [Connections reference](./connections.md)
+- **Context Grounding** — semantic search over enterprise data: [Context Grounding reference](./context_grounding.md)
+
+---
+
+## Tracing
+
+Apply `@traced` to custom steps inside your agent to make them visible in the Orchestrator job trace view and Maestro dashboards. Do **not** trace the entry point — the runtime wraps it automatically.
+
+```python
+from uipath.tracing import traced
+
+
+@traced(name="lookup_vendor", run_type="uipath")
+def lookup_vendor(vendor_id: str) -> dict:
+    ...
+```
+
+See [Tracing](./traced.md) for the full decorator reference.
+
+---
+
+## Framework Guides
+
+Each framework extension has its own getting started guide and sample agents:
+
+| Framework | Guide | Samples |
+|-----------|-------|---------|
+| LangChain / LangGraph | [Get Started](../langchain/quick_start.md) | [Samples](https://github.com/UiPath/uipath-langchain-python/tree/main/samples) |
+| LlamaIndex | [Get Started](../llamaindex/quick_start.md) | [Samples](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-llamaindex/samples) |
+| OpenAI Agents SDK | [Get Started](../openai-agents/quick_start.md) | [Samples](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-openai-agents/samples) |
+| PydanticAI | [README](https://github.com/UiPath/uipath-integrations-python/blob/main/packages/uipath-pydantic-ai/README.md) | [Samples](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-pydantic-ai/samples) |
+| Google ADK | [README](https://github.com/UiPath/uipath-integrations-python/blob/main/packages/uipath-google-adk/README.md) | [Samples](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-google-adk/samples) |
+| UiPath Agent Framework | [README](https://github.com/UiPath/uipath-integrations-python/blob/main/packages/uipath-agent-framework/README.md) | [Samples](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-agent-framework/samples) |
+
+
+---
+
+## Pack & Publish
+
+The same CLI workflow applies as for coded functions:
+
+<!-- termynal -->
+
+```shell
+> uipath pack
+⠋ Packaging project ...
+Name       : my-agent
+Version    : 0.1.0
+Description: Add your description here
+Authors    : Your Name
+✓  Project successfully packaged.
+
+> uipath publish
+⠋ Fetching available package feeds...
+Select feed number: 0
+✓  Package published successfully!
+```
+
+After publishing, the agent registers as an Orchestrator Process and can be invoked from Maestro, the Orchestrator API, or the CLI.
+
+See [CLI Reference](../cli/index.md) for full `pack`, `publish`, and `invoke` options.
+
+---
+
+## Studio Web Integration
+
+Connect your agent to a Studio Web solution for cloud debugging, evaluation, and solution packaging.
+
+See [Studio Web Integration](./studio_web.md) for setup and sync details.
+
+---
+
+## Evaluations
+
+Coded agents support evaluations in Studio Web and locally via `uipath eval`. Evaluators cover LLM output quality, tool call correctness, and trajectory analysis.
+
+See the [Evaluations documentation](../eval/index.md) for available evaluators and how to define evaluation sets.
diff --git a/packages/uipath/docs/core/assets.md b/packages/uipath/docs/core/assets.md
new file mode 100644
index 000000000..ae0c8fab6
--- /dev/null
+++ b/packages/uipath/docs/core/assets.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._assets_service
\ No newline at end of file
diff --git a/docs/core/assets/cloud_env_var_dark.gif b/packages/uipath/docs/core/assets/cloud_env_var_dark.gif
similarity index 100%
rename from docs/core/assets/cloud_env_var_dark.gif
rename to packages/uipath/docs/core/assets/cloud_env_var_dark.gif
diff --git a/docs/core/assets/cloud_env_var_light.gif b/packages/uipath/docs/core/assets/cloud_env_var_light.gif
similarity index 100%
rename from docs/core/assets/cloud_env_var_light.gif
rename to packages/uipath/docs/core/assets/cloud_env_var_light.gif
diff --git a/docs/core/assets/cloud_env_var_secret_dark.png b/packages/uipath/docs/core/assets/cloud_env_var_secret_dark.png
similarity index 100%
rename from docs/core/assets/cloud_env_var_secret_dark.png
rename to packages/uipath/docs/core/assets/cloud_env_var_secret_dark.png
diff --git a/docs/core/assets/cloud_env_var_secret_light.png b/packages/uipath/docs/core/assets/cloud_env_var_secret_light.png
similarity index 100%
rename from docs/core/assets/cloud_env_var_secret_light.png
rename to packages/uipath/docs/core/assets/cloud_env_var_secret_light.png
diff --git a/docs/core/assets/copy_path_dark.png b/packages/uipath/docs/core/assets/copy_path_dark.png
similarity index 100%
rename from docs/core/assets/copy_path_dark.png
rename to packages/uipath/docs/core/assets/copy_path_dark.png
diff --git a/docs/core/assets/copy_path_light.png b/packages/uipath/docs/core/assets/copy_path_light.png
similarity index 100%
rename from docs/core/assets/copy_path_light.png
rename to packages/uipath/docs/core/assets/copy_path_light.png
diff --git a/packages/uipath/docs/core/assets/maestro_execution_trace_light.png b/packages/uipath/docs/core/assets/maestro_execution_trace_light.png
new file mode 100644
index 000000000..d3d364168
Binary files /dev/null and b/packages/uipath/docs/core/assets/maestro_execution_trace_light.png differ
diff --git a/packages/uipath/docs/core/assets/maestro_service_task_light.png b/packages/uipath/docs/core/assets/maestro_service_task_light.png
new file mode 100644
index 000000000..314cb383e
Binary files /dev/null and b/packages/uipath/docs/core/assets/maestro_service_task_light.png differ
diff --git a/packages/uipath/docs/core/assets/orchestrator_processes_light.png b/packages/uipath/docs/core/assets/orchestrator_processes_light.png
new file mode 100644
index 000000000..9b17f72cf
Binary files /dev/null and b/packages/uipath/docs/core/assets/orchestrator_processes_light.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_diagram_dark.png b/packages/uipath/docs/core/assets/studio_web_diagram_dark.png
new file mode 100644
index 000000000..aead8460f
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_diagram_dark.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_diagram_light.png b/packages/uipath/docs/core/assets/studio_web_diagram_light.png
new file mode 100644
index 000000000..6fa1c57f4
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_diagram_light.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_select_coded_dark.png b/packages/uipath/docs/core/assets/studio_web_select_coded_dark.png
new file mode 100644
index 000000000..723a41a8d
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_select_coded_dark.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_select_coded_light.png b/packages/uipath/docs/core/assets/studio_web_select_coded_light.png
new file mode 100644
index 000000000..a50f01c0a
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_select_coded_light.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_select_function_dark.png b/packages/uipath/docs/core/assets/studio_web_select_function_dark.png
new file mode 100644
index 000000000..68a66fc92
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_select_function_dark.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_select_function_light.png b/packages/uipath/docs/core/assets/studio_web_select_function_light.png
new file mode 100644
index 000000000..617e30c2f
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_select_function_light.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_sync_from_ide_dark.png b/packages/uipath/docs/core/assets/studio_web_sync_from_ide_dark.png
new file mode 100644
index 000000000..d47a72103
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_sync_from_ide_dark.png differ
diff --git a/packages/uipath/docs/core/assets/studio_web_sync_from_ide_light.png b/packages/uipath/docs/core/assets/studio_web_sync_from_ide_light.png
new file mode 100644
index 000000000..8fafc7493
Binary files /dev/null and b/packages/uipath/docs/core/assets/studio_web_sync_from_ide_light.png differ
diff --git a/packages/uipath/docs/core/attachments.md b/packages/uipath/docs/core/attachments.md
new file mode 100644
index 000000000..7be292379
--- /dev/null
+++ b/packages/uipath/docs/core/attachments.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._attachments_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/buckets.md b/packages/uipath/docs/core/buckets.md
new file mode 100644
index 000000000..d80aa95f5
--- /dev/null
+++ b/packages/uipath/docs/core/buckets.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._buckets_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/connections.md b/packages/uipath/docs/core/connections.md
new file mode 100644
index 000000000..160d455a2
--- /dev/null
+++ b/packages/uipath/docs/core/connections.md
@@ -0,0 +1 @@
+::: uipath.platform.connections._connections_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/context_grounding.md b/packages/uipath/docs/core/context_grounding.md
new file mode 100644
index 000000000..089668d3f
--- /dev/null
+++ b/packages/uipath/docs/core/context_grounding.md
@@ -0,0 +1 @@
+::: uipath.platform.context_grounding._context_grounding_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/documents.md b/packages/uipath/docs/core/documents.md
new file mode 100644
index 000000000..a601aabfb
--- /dev/null
+++ b/packages/uipath/docs/core/documents.md
@@ -0,0 +1 @@
+::: uipath.platform.documents._documents_service
diff --git a/packages/uipath/docs/core/documents_models.md b/packages/uipath/docs/core/documents_models.md
new file mode 100644
index 000000000..65c6df333
--- /dev/null
+++ b/packages/uipath/docs/core/documents_models.md
@@ -0,0 +1,3 @@
+::: uipath.platform.documents
+    options:
+      show_bases: true
diff --git a/packages/uipath/docs/core/entities.md b/packages/uipath/docs/core/entities.md
new file mode 100644
index 000000000..edc4b91d1
--- /dev/null
+++ b/packages/uipath/docs/core/entities.md
@@ -0,0 +1 @@
+::: uipath.platform.entities._entities_service
diff --git a/docs/core/environment_variables.md b/packages/uipath/docs/core/environment_variables.md
similarity index 92%
rename from docs/core/environment_variables.md
rename to packages/uipath/docs/core/environment_variables.md
index 6c88d3532..bcf1bcc8b 100644
--- a/docs/core/environment_variables.md
+++ b/packages/uipath/docs/core/environment_variables.md
@@ -17,12 +17,12 @@ UIPATH_FOLDER_PATH=/default/path
 export UIPATH_FOLDER_PATH=/system/path
 ```
 /// warning
-When deploying your agent to production, ensure that all required environment variables (such as API keys and custom configurations) are properly configured in your process settings. This step is crucial for the successful operation of your published package.
+When deploying your project to production, ensure that all required environment variables (such as API keys and custom configurations) are properly configured in your process settings. This step is crucial for the successful operation of your published package.
 ///
 
 ## Design
 
-Create a `.env` file in your project's root directory to manage environment variables locally. When using the `uipath auth` or `uipath new my-agent` commands, this file is automatically created.
+Create a `.env` file in your project's root directory to manage environment variables locally. When using the `uipath auth` or `uipath new` commands, this file is automatically created.
 
 The `uipath auth` command automatically populates this file with essential variables:
 
diff --git a/packages/uipath/docs/core/functions.md b/packages/uipath/docs/core/functions.md
new file mode 100644
index 000000000..6c073f68f
--- /dev/null
+++ b/packages/uipath/docs/core/functions.md
@@ -0,0 +1,423 @@
+# Python Coded Functions
+
+A coded function is Python code with typed input and output that runs as an Orchestrator job. You write plain Python — no agent framework, no LLM required — package it with the CLI, and invoke it from Maestro processes, Coded Apps, or any UiPath job trigger.
+
+Use coded functions for deterministic compute steps: document extraction, ERP writes, data validation, external API calls. Use a [coded agent](./agents.md) when your logic needs an LLM decision loop or a multi-step reasoning chain.
+
+!!! warning "Preview Feature"
+    This feature is in preview and is subject to changes.
+
+---
+
+## Quickstart
+
+//// tab | uv
+
+<!-- termynal -->
+
+```shell
+> mkdir my-function && cd my-function
+> uv init . --python 3.11
+> uv add uipath
+
+> uipath auth
+⠋ Authenticating with UiPath ...
+✓  Authentication successful.
+
+> uipath new my-function
+✓  Created 'main.py' file.
+✓  Created 'pyproject.toml' file.
+✓  Created 'uipath.json' file.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+✓  Created 'bindings.json' file.
+
+> uipath run main '{"message": "hello"}'
+{"message": "hello"}
+```
+
+////
+
+//// tab | pip
+
+<!-- termynal -->
+
+```shell
+> mkdir my-function && cd my-function
+> python -m venv .venv
+> source .venv/bin/activate
+> pip install uipath
+
+> uipath auth
+⠋ Authenticating with UiPath ...
+✓  Authentication successful.
+
+> uipath new my-function
+✓  Created 'main.py' file.
+✓  Created 'pyproject.toml' file.
+✓  Created 'uipath.json' file.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+✓  Created 'bindings.json' file.
+
+> uipath run main '{"message": "hello"}'
+{"message": "hello"}
+```
+
+////
+
+---
+
+## Project Structure
+
+```
+my-function/
+├── main.py            # function logic
+├── pyproject.toml     # project metadata and dependencies
+├── uipath.json        # entry point declarations
+├── entry-points.json  # generated — I/O JSON Schema
+└── bindings.json      # generated — resource binding overrides
+```
+
+### `uipath.json`
+
+Declares which Python functions are callable entry points:
+
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+The key (`"main"`) is the entry point name used in CLI commands. The value (`"main.py:main"`) is `<file>:<function_name>`.
+
+### `pyproject.toml`
+
+```toml
+[project]
+name = "my-function"
+version = "0.1.0"
+description = "..."
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.11"
+dependencies = ["uipath>=2.0"]
+```
+
+Standard project metadata and dependencies. The `functions` map in `uipath.json` (above) is what marks the project as a coded function — `pyproject.toml` needs no UiPath-specific entries.
+
+### Generated files
+
+| File | Purpose |
+|------|---------|
+| `entry-points.json` | Input/output JSON Schema derived from your `Input`/`Output` models — used by Maestro for variable binding |
+| `bindings.json` | Resource binding overrides (assets, connections, buckets) for local development |
+
+/// warning
+`uipath init` executes your entrypoint Python file(s) (as declared in `uipath.json`, e.g., `main.py`) to derive the I/O schema. Re-run it after every change to your `Input` or `Output` models.
+///
+
+---
+
+## Input & Output
+
+Define `Input` and `Output` as typed Python — a stdlib `@dataclass`, a pydantic `BaseModel`, or `pydantic.dataclasses.dataclass`. The runtime uses these type hints to parse the invocation payload and exports them as JSON Schema for Maestro variable binding. The entry point can be a sync `def` or an `async def` — both are supported.
+
+```python
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Input:
+    document_id: str = ""
+    amount: float = 0.0
+
+
+@dataclass
+class Output:
+    result_id: str = ""
+    status: str = ""
+    error_type: str = ""
+    error_message: str = ""
+
+
+def main(input: Input) -> Output:
+    ...
+```
+
+### Supported types
+
+| Python type | Notes |
+|-------------|-------|
+| `str`, `int`, `float`, `bool` | Primitives |
+| `list[str]`, `list[dict]` | Arrays |
+| `dict[str, Any]` | Freeform object |
+| Nested `@dataclass` | Becomes a nested JSON object |
+| `X \| None`, `Optional[X]` | Nullable field |
+
+### Error output pattern
+
+Return business errors as typed output fields rather than raising exceptions. This lets Maestro inspect the error reason and route the process accordingly:
+
+```python
+@dataclass
+class Output:
+    bill_id: str = ""
+    error_type: str = ""      # e.g. "VENDOR_NOT_FOUND", "VALIDATION_ERROR"
+    error_message: str = ""   # human-readable detail
+
+
+def main(input: Input) -> Output:
+    try:
+        bill_id = create_vendor_bill(input)
+        return Output(bill_id=bill_id)
+    except VendorNotFoundError as exc:
+        return Output(error_type="VENDOR_NOT_FOUND", error_message=str(exc))
+    except Exception as exc:
+        return Output(error_type="FAILED", error_message=str(exc))
+```
+
+Reserve `raise` for unrecoverable infrastructure failures (network timeout, authentication error) that should mark the Orchestrator job as faulted.
+
+---
+
+## Platform Services
+
+`UiPath()` gives your function access to Orchestrator resources at runtime. Credentials are injected automatically when running as a job — no configuration needed.
+
+```python
+from uipath.platform import UiPath
+
+sdk = UiPath()
+```
+
+### Assets
+
+Read credential and configuration values stored in Orchestrator:
+
+```python
+# String asset
+asset = sdk.assets.retrieve("API_BASE_URL", folder_path="Shared")
+base_url = str(asset.string_value or "")
+
+# Credential asset
+creds = sdk.assets.retrieve("ERP_CREDENTIALS", folder_path="Shared")
+username = str(creds.credential_username or "")
+password = str(creds.credential_password or "")
+```
+
+See [Assets](./assets.md) for the full API reference.
+
+### Buckets
+
+Download and upload files:
+
+```python
+# Download
+sdk.buckets.download(
+    name="Invoices",
+    blob_file_path="incoming/acme-001.pdf",
+    destination_path="/tmp/acme-001.pdf",
+    folder_path="Shared",
+)
+
+# Upload
+sdk.buckets.upload(
+    name="Processed",
+    blob_file_path="results/acme-001-result.json",
+    content_file_path="/tmp/result.json",
+    folder_path="Shared",
+)
+```
+
+See [Buckets](./buckets.md) for the full API reference.
+
+### Connections
+
+Access Integration Service connections for ERP and SaaS systems:
+
+```python
+from uipath.platform.connections.connections import ActivityMetadata, ActivityParameterLocationInfo
+
+conn = sdk.connections.retrieve("your-connection-id")
+
+result = sdk.connections.invoke_activity(
+    activity_metadata=ActivityMetadata(
+        object_path="/your-endpoint",
+        method_name="POST",
+        content_type="application/json",
+        parameter_location_info=ActivityParameterLocationInfo(body_fields=["query"]),
+    ),
+    connection_id="your-connection-id",
+    activity_input={"query": "SELECT id FROM records LIMIT 10"},
+)
+```
+
+See [Connections](./connections.md) for the full API reference.
+
+---
+
+## Tracing
+
+Use `@traced` to make individual steps visible as spans in the Orchestrator job trace view and Maestro dashboards.
+
+```python
+from uipath.tracing import traced
+
+
+@traced(name="fetch_document", run_type="uipath")
+def fetch_document(document_id: str) -> bytes:
+    ...
+
+
+@traced(name="extract_fields", run_type="uipath")
+def extract_fields(content: bytes) -> dict:
+    ...
+
+
+@traced(name="post_to_erp", run_type="uipath")
+def post_to_erp(data: dict) -> str:
+    ...
+
+
+def main(input: Input) -> Output:   # entry point — NOT traced
+    content = fetch_document(input.document_id)
+    data = extract_fields(content)
+    result_id = post_to_erp(data)
+    return Output(result_id=result_id)
+```
+
+/// warning
+Do not apply `@traced` to the entry point function. The Orchestrator runtime wraps the entire job in its own span — adding a second trace on the entry point creates a duplicate outer span.
+///
+
+Use `hide_input=True` or `hide_output=True` to redact sensitive data from trace storage:
+
+```python
+@traced(name="get_api_token", run_type="uipath", hide_input=True, hide_output=True)
+def get_api_token(client_id: str, client_secret: str) -> str:
+    ...
+```
+
+<picture>
+  <img src="../assets/maestro_execution_trace_light.png" alt="Maestro execution trail showing @traced sub-step spans (assets_retrieve, ixp_digitize, netsuite_get_vendor, etc.) with durations and parent-child nesting under a Service Task" />
+</picture>
+
+See [Tracing](./traced.md) for the full decorator reference.
+
+---
+
+## Multiple Entry Points
+
+One project can expose several callable functions, each with its own `Input`/`Output`. Define them in `uipath.json`:
+
+```json
+{
+  "functions": {
+    "extract": "main.py:extract_data",
+    "validate": "main.py:validate_data",
+    "post_erp": "main.py:post_to_erp"
+  }
+}
+```
+
+Run `uipath init` after adding new entry points. Each can be invoked independently:
+
+<!-- termynal -->
+
+```shell
+> uipath run extract '{"document_id": "invoice-001.pdf"}'
+> uipath run validate '{"vendor_name": "Acme", "total": 1234.56}'
+> uipath run post_erp '{"bill_id": "12345"}'
+```
+
+Each entry point publishes as a separate invocable function in Orchestrator.
+
+---
+
+## Idempotency
+
+Functions may be retried by Maestro after a transient failure. Always check for an existing result before writing to an external system:
+
+```python
+@traced(name="find_existing", run_type="uipath")
+def find_existing(invoice_number: str) -> str | None:
+    # query external system by stable business key
+    ...
+
+
+def main(input: Input) -> Output:
+    existing_id = find_existing(input.invoice_number)
+    if existing_id:
+        return Output(result_id=existing_id, status="Already Processed")
+
+    result_id = create_record(input)
+    return Output(result_id=result_id, status="Created")
+```
+
+Use a stable, business-meaningful identifier (invoice number, order ID) as the idempotency key — avoid auto-generated IDs that don't exist before the first write.
+
+---
+
+## Pack & Publish
+
+<!-- termynal -->
+
+```shell
+> uipath pack
+⠋ Packaging project ...
+Name       : my-function
+Version    : 0.1.0
+Description: ...
+Authors    : Your Name
+✓  Project successfully packaged.
+
+> uipath publish
+⠋ Fetching available package feeds...
+👇 Select package feed:
+  0: Orchestrator Tenant Processes Feed
+  1: Orchestrator Personal Workspace Feed
+Select feed number: 0
+✓  Package published successfully!
+```
+
+After publishing, the function registers as an **Orchestrator Process**. It can then be:
+
+- Invoked as a **Maestro Service Task** — Maestro binds typed input/output to process variables automatically from the exported JSON Schema
+- Triggered via the **Orchestrator API** (`POST /Jobs/StartJobs`)
+- Run from the CLI: `uipath invoke main '{"..."}'`
+- Started from a **Studio workflow** using the **Run Job** activity
+
+<picture>
+  <img src="../assets/orchestrator_processes_light.png" alt="Coded functions published as Function (python) type in the Orchestrator Processes list" />
+</picture>
+<picture>
+  <img src="../assets/maestro_service_task_light.png" alt="Coded function wired as a Maestro Service Task with typed input/output variable binding" />
+</picture>
+
+See [CLI Reference](../cli/index.md) for full `pack`, `publish`, and `invoke` options.
+
+---
+
+## Studio Web Integration
+
+Connect your function to a Studio Web solution for cloud debugging or solution packaging:
+
+<!-- termynal -->
+
+```shell
+> uipath push
+Pushing UiPath project to Studio Web...
+Uploading 'main.py'
+Uploading 'uipath.json'
+Updating 'pyproject.toml'
+✓  Project pushed successfully
+```
+
+See [Studio Web Integration](./studio_web.md) for setup and sync details.
diff --git a/docs/core/getting_started.md b/packages/uipath/docs/core/getting_started.md
similarity index 71%
rename from docs/core/getting_started.md
rename to packages/uipath/docs/core/getting_started.md
index 388f1a259..50da82107 100644
--- a/docs/core/getting_started.md
+++ b/packages/uipath/docs/core/getting_started.md
@@ -2,7 +2,7 @@
 
 ## Prerequisites
 
--   Python 3.10 or higher
+-   Python 3.11 or higher
 -   `pip` or `uv` package manager
 -   A UiPath Cloud Platform account with appropriate permissions
 
@@ -11,7 +11,6 @@
 //// tab | Linux, macOS, Windows Bash
 
 <!-- termynal -->
-
 ```shell
 > mkdir uipath_coded_process
 > cd uipath_coded_process
@@ -22,7 +21,6 @@
 //// tab | Windows PowerShell
 
 <!-- termynal -->
-
 ```powershell
 > New-Item -ItemType Directory -Path uipath_coded_process
 > Set-Location uipath_coded_process
@@ -34,15 +32,14 @@
     new: true
 
 <!-- termynal -->
-
 ```shell
 # Initialize a new uv project in the current directory
-> uv init . --python 3.10
+> uv init . --python 3.11
 
 # Create a new virtual environment
 # By default, uv creates a virtual environment in a directory called .venv
 > uv venv
-Using CPython 3.10.16 interpreter at: [PATH]
+Using CPython 3.11 interpreter at: [PATH]
 Creating virtual environment at: .venv
 Activate with: source .venv/bin/activate
 
@@ -64,7 +61,6 @@ uipath version 2.0.29
 //// tab | pip
 
 <!-- termynal -->
-
 ```shell
 # Create a new virtual environment
 > python -m venv .venv
@@ -89,7 +85,7 @@ uipath version 2.0.29
 
 ### Telemetry
 
-To help us improve the developer experience, the CLI collects basic usage data about commands invocation. For more details about UiPath’s privacy practices, please review the [privacy statement](https://www.uipath.com/legal/privacy-policy).
+To help us improve the developer experience, the CLI collects basic usage data about commands invocation. For more details about UiPath's privacy practices, please review the [privacy statement](https://www.uipath.com/legal/privacy-policy).
 
 #### Disabling telemetry data
 
@@ -100,7 +96,6 @@ Telemetry is enabled by default, yet it is possible to opt-out by setting to `fa
 To debug your script locally and publish your project, you need to authenticate with UiPath:
 
 <!-- termynal -->
-
 ```shell
 > uipath auth
 ⠋ Authenticating with UiPath ...
@@ -119,18 +114,20 @@ Upon successful authentication, your project will contain a `.env` file with you
 
 ### Writing Your Code
 
-Open `main.py` in your code editor. You can start with this example code:
+/// tip
+This walkthrough creates a **coded function** — plain Python with typed input and output, no LLM required. For a complete reference including platform services, tracing, idempotency, and Maestro integration, see [Python Coded Functions](./functions.md).
+///
 
+Open `main.py` in your code editor. You can start with this example code:
 ```python
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class EchoIn:
     message: str
-    repeat: Optional[int] = 1
-    prefix: Optional[str] = None
+    repeat: int | None = 1
+    prefix: str | None = None
 
 
 @dataclass
@@ -151,14 +148,25 @@ def main(input: EchoIn) -> EchoOut:
 
 ### Initializing the UiPath Project
 
-To create a UiPath project, run the following command in your terminal:
+Before running `uipath init`, you need to create a `uipath.json` file that specifies which functions to expose. Create a `uipath.json` file in your project directory with the following content:
+```json
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
+```
+
+The `functions` object maps function names to their locations in the format `<file>:<function_name>`.
 
-<!-- termynal -->
+Now, run the initialization command:
 
+<!-- termynal -->
 ```shell
 > uipath init
 ⠋ Initializing UiPath project ...
-✓  Created 'uipath.json' file.
+✓  Created 'entry-points.json' file.
+✓  Created 'bindings.json' file.
 ```
 
 /// warning
@@ -166,20 +174,44 @@ To create a UiPath project, run the following command in your terminal:
 The `uipath init` command executes your `main.py` file to analyze its structure and collect information about inputs and outputs.
 ///
 
-This command creates a `uipath.json` file containing the project metadata.
+This command generates two files:
 
-<!-- termynal -->
+- `entry-points.json`: Contains the input/output schema for your functions
+- `bindings.json`: Allows you to configure overridable resource bindings.
 
+<!-- termynal -->
 ```shell
 # Debug your project
-> uipath run main.py '{"message": "test"}'
+> uipath run main '{"message": "test"}'
 [2025-04-11 10:13:58,857][INFO] {'message': 'test'}
 ```
 
+/// warning
+Depending on the shell you are using, it may be necessary to escape the input json:
+
+/// tab | Bash/ZSH/PowerShell
+```console
+uipath run main '{"message": "test"}'
+```
+///
+
+/// tab | Windows CMD
+```console
+uipath run main "{""message"": ""test""}"
+```
+///
+
+/// tab | Windows PowerShell
+```console
+uipath run main '{\"message\":\"test\"}'
+```
+///
+
+///
+
 ### Packaging and Publishing
 
 Before packaging your project, add your details to the `pyproject.toml` file. Add the following line below the `description` field:
-
 ```toml
 authors = [{ name = "Your Name", email = "your.email@uipath.com" }]
 ```
@@ -187,7 +219,6 @@ authors = [{ name = "Your Name", email = "your.email@uipath.com" }]
 Then, package your project:
 
 <!-- termynal -->
-
 ```shell
 > uipath pack
 ⠋ Packaging project ...
@@ -201,7 +232,6 @@ Authors    : Your Name
 Finally, publish your package:
 
 <!-- termynal -->
-
 ```shell
 > uipath publish
 ⠋ Fetching available package feeds...
@@ -216,14 +246,13 @@ Selected feed: Orchestrator Tenant Processes Feed
 
 After selecting your publishing destination (tenant or personal workspace), you'll see details about your package and a confirmation message.
 
-## Getting Started with the SDK
+## Integrating with the UiPath Platform
 
-Create a new project following the same steps as above.
+Create a **new project** (separate from the one you just packaged and published) following the same steps as above. This new project will invoke your previous process using the UiPath SDK.
 
 Open `main.py` in your code editor and add the following code:
-
 ```python
-from uipath import UiPath
+from uipath.platform import UiPath
 
 
 def main():
@@ -239,16 +268,18 @@ def main():
     )
 ```
 
+/// warning
+An agent can invoke itself if needed, but this must be done with caution. Be mindful that using the same name for invocation may lead to unintentional loops. To prevent recursion issues, implement safeguards like exit conditions.
+///
+
 ### Verifying the Execution
 
 <!-- termynal -->
-
 ```shell
 > uipath run main.py
 ```
 
 Open your browser and navigate to UiPath. Go to the specified folder, where you'll see a new job for `uipath_coded_process` has been executed. The output will be:
-
 ```
 [Echo]: Hello, World! Echo: Hello, World! Echo: Hello, World!
 ```
diff --git a/packages/uipath/docs/core/guardrails.md b/packages/uipath/docs/core/guardrails.md
new file mode 100644
index 000000000..4c380c20c
--- /dev/null
+++ b/packages/uipath/docs/core/guardrails.md
@@ -0,0 +1,445 @@
+# Guardrails
+
+Guardrails are safeguards applied before and/or after execution to inspect inputs and outputs for policy violations — PII, harmful content, prompt attacks, intellectual property, and custom rules — and respond by logging, blocking, or modifying the data.
+
+They can be applied at three scopes:
+
+- **Tool** — individual tool functions called by an agent
+- **LLM** — LLM factory functions or chat model objects (e.g. LangChain `BaseChatModel`)
+- **Agent** — agent-level methods and nodes
+
+The `@guardrail` decorator works with plain Python functions, async functions, and any LangChain/LangGraph object recognised by a registered framework adapter.
+
+## Usage
+
+Apply the `@guardrail` decorator to any callable — tool functions, LLM factories, agent factories, or async agent nodes. The decorator intercepts calls at the configured stage and evaluates the data against the provided validator.
+
+**Tool function:**
+
+```python
+from uipath.platform.guardrails import (
+    BlockAction,
+    GuardrailExecutionStage,
+    PIIDetectionEntity,
+    PIIDetectionEntityType,
+    PIIValidator,
+    guardrail,
+)
+
+@guardrail(
+    validator=PIIValidator(
+        entities=[PIIDetectionEntity(PIIDetectionEntityType.EMAIL, threshold=0.5)]
+    ),
+    action=BlockAction(),
+    name="No PII in output",
+    stage=GuardrailExecutionStage.POST,
+)
+def analyze_joke(joke: str) -> str:
+    ...
+```
+
+When using LangChain's `@tool`, `@guardrail` must be placed **above** `@tool`:
+
+```python
+from langchain_core.tools import tool
+
+@guardrail(
+    validator=PIIValidator(
+        entities=[PIIDetectionEntity(PIIDetectionEntityType.EMAIL, threshold=0.5)]
+    ),
+    action=BlockAction(),
+    name="No PII in tool input",
+    stage=GuardrailExecutionStage.PRE,
+)
+@tool  # @guardrail wraps the already-decorated tool object
+def analyze_joke(joke: str) -> str:
+    ...
+```
+
+**LLM factory function:**
+
+```python
+@guardrail(
+    validator=UserPromptAttacksValidator(),
+    action=BlockAction(),
+    name="LLM User Prompt Attacks Detection",
+    stage=GuardrailExecutionStage.PRE,
+)
+def create_llm():
+    return UiPathChat(model="gpt-4o-2024-08-06")
+```
+
+**Agent factory or async node:**
+
+```python
+@guardrail(
+    validator=PIIValidator(
+        entities=[PIIDetectionEntity(PIIDetectionEntityType.PERSON, threshold=0.5)]
+    ),
+    action=BlockAction(
+        title="Person name detection",
+        detail="Person name detected and is not allowed",
+    ),
+    name="Agent PII Detection",
+    stage=GuardrailExecutionStage.PRE,
+)
+async def joke_node(state: Input) -> Output:
+    ...
+```
+
+## Execution Stages
+
+The `stage` parameter controls when the guardrail evaluates. Not all validators support all stages.
+
+| Stage | When evaluated | Supported by |
+|-------|---------------|--------------|
+| `PRE` | Before the function runs | All validators |
+| `POST` | After the function runs | All except `UserPromptAttacksValidator` |
+| `PRE_AND_POST` | Both before and after | `PIIValidator`, `HarmfulContentValidator`, `CustomValidator` |
+
+## Built-in Validators
+
+Built-in validators are backed by the UiPath Guardrails API (powered by Azure Content Safety). They require a UiPath connection with the appropriate entitlements.
+
+### PII Detection
+
+Detects personally identifiable information in text. Supports 18 entity types with per-entity confidence thresholds.
+
+```python
+from uipath.platform.guardrails import (
+    BlockAction,
+    PIIDetectionEntity,
+    PIIDetectionEntityType,
+    PIIValidator,
+    guardrail,
+)
+
+@guardrail(
+    validator=PIIValidator(
+        entities=[
+            PIIDetectionEntity(name=PIIDetectionEntityType.EMAIL, threshold=0.7),
+            PIIDetectionEntity(name=PIIDetectionEntityType.PHONE_NUMBER, threshold=0.5),
+            PIIDetectionEntity(name=PIIDetectionEntityType.US_SOCIAL_SECURITY_NUMBER),
+        ]
+    ),
+    action=BlockAction(),
+    name="No PII",
+)
+def process_document(content: str) -> str:
+    ...
+```
+
+`threshold` is a confidence value between `0.0` and `1.0` (default `0.5`). Lower values increase sensitivity.
+
+### Harmful Content
+
+Detects harmful or unsafe content across four Azure Content Safety categories. Each category has a severity threshold from `0` (most sensitive) to `6` (least sensitive), defaulting to `2`.
+
+```python
+from uipath.platform.guardrails import (
+    BlockAction,
+    HarmfulContentEntity,
+    HarmfulContentEntityType,
+    HarmfulContentValidator,
+    guardrail,
+)
+
+@guardrail(
+    validator=HarmfulContentValidator(
+        entities=[
+            HarmfulContentEntity(name=HarmfulContentEntityType.VIOLENCE, threshold=2),
+            HarmfulContentEntity(name=HarmfulContentEntityType.HATE, threshold=2),
+        ]
+    ),
+    action=BlockAction(),
+    name="Safe content only",
+)
+def generate_response(prompt: str) -> str:
+    ...
+```
+
+### User Prompt Attacks
+
+Detects adversarial user prompt patterns (e.g. jailbreak attempts). No configuration parameters required. Restricted to `PRE` stage only.
+
+```python
+from uipath.platform.guardrails import (
+    BlockAction,
+    GuardrailExecutionStage,
+    UserPromptAttacksValidator,
+    guardrail,
+)
+
+@guardrail(
+    validator=UserPromptAttacksValidator(),
+    action=BlockAction(),
+    name="No prompt attacks",
+    stage=GuardrailExecutionStage.PRE,
+)
+def chat(message: str) -> str:
+    ...
+```
+
+### Intellectual Property
+
+Detects potential intellectual property violations in generated output. Restricted to `POST` stage only — this is an output concern.
+
+```python
+from uipath.platform.guardrails import (
+    BlockAction,
+    GuardrailExecutionStage,
+    IntellectualPropertyEntityType,
+    IntellectualPropertyValidator,
+    guardrail,
+)
+
+@guardrail(
+    validator=IntellectualPropertyValidator(
+        entities=[
+            IntellectualPropertyEntityType.TEXT,
+            IntellectualPropertyEntityType.CODE,
+        ]
+    ),
+    action=BlockAction(),
+    name="No IP violations",
+    stage=GuardrailExecutionStage.POST,
+)
+def generate_code(spec: str) -> str:
+    ...
+```
+
+## Actions
+
+Actions define what happens when a violation is detected.
+
+### LogAction
+
+Logs the violation and lets execution continue. The original data is unchanged.
+
+```python
+from uipath.platform.guardrails import LogAction, LoggingSeverityLevel
+
+action = LogAction(severity_level=LoggingSeverityLevel.WARNING)
+action = LogAction(severity_level=LoggingSeverityLevel.ERROR, message="PII found in output")
+```
+
+### BlockAction
+
+Raises `GuardrailBlockException` to stop execution immediately. Framework adapters (e.g. LangChain) catch this exception and convert it to their own error type.
+
+```python
+from uipath.platform.guardrails import BlockAction
+
+action = BlockAction()
+action = BlockAction(title="PII detected", detail="Email address found in response")
+```
+
+### Custom Actions
+
+Subclass `GuardrailAction` to implement custom behaviour, such as content sanitisation:
+
+```python
+from typing import Any
+from uipath.core.guardrails import GuardrailValidationResult
+from uipath.platform.guardrails import GuardrailAction
+
+class RedactAction(GuardrailAction):
+    def handle_validation_result(
+        self,
+        result: GuardrailValidationResult,
+        data: str | dict[str, Any],
+        guardrail_name: str,
+    ) -> str | dict[str, Any] | None:
+        # Return modified data to replace the original, or None to leave unchanged
+        if isinstance(data, str):
+            return "[REDACTED]"
+        return None
+```
+
+## Custom Validators
+
+`CustomValidator` applies an in-process rule function without any API call. The rule receives the input dict (PRE stage) or both input and output dicts (POST stage), and returns `True` to signal a violation.
+
+```python
+from uipath.platform.guardrails import BlockAction, CustomValidator, guardrail
+
+@guardrail(
+    validator=CustomValidator(rule=lambda data: "forbidden" in str(data).lower()),
+    action=BlockAction(),
+    name="No forbidden words",
+)
+def my_tool(text: str) -> str:
+    ...
+```
+
+For POST-stage rules, accept two parameters to inspect both input and output:
+
+```python
+def check_output(input_data: dict, output_data: dict) -> bool:
+    # Return True to trigger the guardrail
+    return len(output_data.get("response", "")) > 5000
+
+@guardrail(
+    validator=CustomValidator(rule=check_output),
+    action=BlockAction(detail="Response exceeds maximum length"),
+    name="Length limit",
+    stage=GuardrailExecutionStage.POST,
+)
+def summarize(query: str) -> dict:
+    ...
+```
+
+For full control, subclass `CustomGuardrailValidator` directly.
+
+## Excluding Parameters
+
+Use `GuardrailExclude` with `Annotated` to prevent a specific parameter from being included in the guardrail evaluation payload. Useful for internal context objects, credentials, or other data that should never be inspected.
+
+```python
+from typing import Annotated
+from uipath.platform.guardrails import BlockAction, GuardrailExclude, PIIValidator, guardrail
+
+@guardrail(
+    validator=PIIValidator(entities=[PIIDetectionEntity(name=PIIDetectionEntityType.EMAIL)]),
+    action=BlockAction(),
+    name="No PII",
+)
+def process(
+    user_message: str,
+    internal_config: Annotated[dict, GuardrailExclude()],  # excluded from guardrail
+) -> str:
+    ...
+```
+
+## Stacking Guardrails
+
+Multiple `@guardrail` decorators can be stacked on the same function. Each is evaluated independently at its configured stage.
+
+```python
+@guardrail(
+    validator=UserPromptAttacksValidator(),
+    action=BlockAction(),
+    name="No prompt attacks",
+    stage=GuardrailExecutionStage.PRE,
+)
+@guardrail(
+    validator=PIIValidator(entities=[PIIDetectionEntity(name=PIIDetectionEntityType.EMAIL)]),
+    action=LogAction(),
+    name="PII audit",
+    stage=GuardrailExecutionStage.POST,
+)
+def handle_request(user_input: str) -> str:
+    ...
+```
+
+## Low-level API
+
+For direct programmatic use without the decorator, the `GuardrailsService` is available on the `UiPath` client:
+
+```python
+from uipath.platform import UiPath
+from uipath.platform.guardrails import BuiltInValidatorGuardrail
+
+sdk = UiPath()
+result = sdk.guardrails.evaluate_guardrail(
+    input_data="Contact me at user@example.com",
+    guardrail=BuiltInValidatorGuardrail(
+        id="my-guardrail",
+        name="PII check",
+        guardrail_type="builtInValidator",
+        validator_type="pii_detection",
+    ),
+)
+print(result.result, result.reason)
+```
+
+---
+
+## API Reference
+
+### Service
+
+::: uipath.platform.guardrails._guardrails_service
+    options:
+      members:
+        - GuardrailsService
+
+### Decorator
+
+::: uipath.platform.guardrails.decorators._guardrail
+    options:
+      members:
+        - guardrail
+
+### Execution Stage
+
+::: uipath.platform.guardrails.decorators._enums
+    options:
+      members:
+        - GuardrailExecutionStage
+        - PIIDetectionEntityType
+        - HarmfulContentEntityType
+        - IntellectualPropertyEntityType
+
+### Actions
+
+::: uipath.platform.guardrails.decorators._models
+    options:
+      members:
+        - GuardrailAction
+        - PIIDetectionEntity
+        - HarmfulContentEntity
+
+::: uipath.platform.guardrails.decorators._actions
+    options:
+      members:
+        - LoggingSeverityLevel
+        - LogAction
+        - BlockAction
+
+::: uipath.platform.guardrails.decorators._exceptions
+    options:
+      members:
+        - GuardrailBlockException
+
+### Exclude Marker
+
+::: uipath.platform.guardrails.decorators._core
+    options:
+      members:
+        - GuardrailExclude
+
+### Validators
+
+::: uipath.platform.guardrails.decorators.validators._base
+    options:
+      members:
+        - GuardrailValidatorBase
+        - BuiltInGuardrailValidator
+        - CustomGuardrailValidator
+
+::: uipath.platform.guardrails.decorators.validators.pii
+    options:
+      members:
+        - PIIValidator
+
+::: uipath.platform.guardrails.decorators.validators.harmful_content
+    options:
+      members:
+        - HarmfulContentValidator
+
+::: uipath.platform.guardrails.decorators.validators.intellectual_property
+    options:
+      members:
+        - IntellectualPropertyValidator
+
+::: uipath.platform.guardrails.decorators.validators.user_prompt_attacks
+    options:
+      members:
+        - UserPromptAttacksValidator
+
+::: uipath.platform.guardrails.decorators.validators.custom
+    options:
+      members:
+        - CustomValidator
+        - RuleFunction
diff --git a/packages/uipath/docs/core/jobs.md b/packages/uipath/docs/core/jobs.md
new file mode 100644
index 000000000..91660fbaf
--- /dev/null
+++ b/packages/uipath/docs/core/jobs.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._jobs_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/llm_gateway.md b/packages/uipath/docs/core/llm_gateway.md
new file mode 100644
index 000000000..db58ab8c3
--- /dev/null
+++ b/packages/uipath/docs/core/llm_gateway.md
@@ -0,0 +1 @@
+::: uipath.platform.chat._llm_gateway_service
diff --git a/packages/uipath/docs/core/processes.md b/packages/uipath/docs/core/processes.md
new file mode 100644
index 000000000..ab46f3d3c
--- /dev/null
+++ b/packages/uipath/docs/core/processes.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._processes_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/queues.md b/packages/uipath/docs/core/queues.md
new file mode 100644
index 000000000..49e645053
--- /dev/null
+++ b/packages/uipath/docs/core/queues.md
@@ -0,0 +1 @@
+::: uipath.platform.orchestrator._queues_service
\ No newline at end of file
diff --git a/packages/uipath/docs/core/release_notes.md b/packages/uipath/docs/core/release_notes.md
new file mode 100644
index 000000000..3bdbfb4a0
--- /dev/null
+++ b/packages/uipath/docs/core/release_notes.md
@@ -0,0 +1,27 @@
+---
+title: Release Notes
+---
+
+# Release Notes
+
+A catalog of the releases most relevant to UiPath Python SDK users (breaking changes and notable updates). Full details live in each GitHub release, linked below.
+
+## `uipath` (SDK & CLI)
+
+| Release | Date | What's relevant | Notes |
+|---------|------|-----------------|-------|
+| [v2.10.0](https://github.com/UiPath/uipath-python/releases/tag/v2.10.0) | 2026-02-27 | Coded function schema `type` changed from `"agent"` to `"function"` | 🚨 Breaking |
+| [v2.9.0](https://github.com/UiPath/uipath-python/releases/tag/v2.9.0) | 2026-02-23 | `platform` extracted to `uipath-platform`, context grounding contract changes, `uipath dev` defaults to `web` | 🚨 Breaking |
+| [v2.2.0](https://github.com/UiPath/uipath-python/releases/tag/v2.2.0) | 2025-11-26 | Python 3.11+ required, `UiPath` import moved to `uipath.platform`, configuration architecture redesign | 🚨 Breaking |
+
+## `uipath-langchain`
+
+| Release | Date | What's relevant | Notes |
+|---------|------|-----------------|-------|
+| [v0.10.0](https://github.com/UiPath/uipath-langchain-python/releases/tag/v0.10.0) | 2026-04-23 | Transport/auth split into new `uipath-llm-client` and `uipath-langchain-client` packages (legacy preserved) | Non-breaking |
+
+## `uipath-runtime`
+
+| Release | Date | What's relevant | Notes |
+|---------|------|-----------------|-------|
+| [v0.3.0](https://github.com/UiPath/uipath-runtime-python/releases/tag/v0.3.0) | 2025-12-18 | `UiPathDebugBridgeProtocol` renamed to `UiPathDebugProtocol` | 🚨 Breaking (protocol implementers only) |
diff --git a/packages/uipath/docs/core/resource_catalog.md b/packages/uipath/docs/core/resource_catalog.md
new file mode 100644
index 000000000..c84c5eca0
--- /dev/null
+++ b/packages/uipath/docs/core/resource_catalog.md
@@ -0,0 +1 @@
+::: uipath.platform.resource_catalog._resource_catalog_service
diff --git a/packages/uipath/docs/core/studio_web.md b/packages/uipath/docs/core/studio_web.md
new file mode 100644
index 000000000..09286dd73
--- /dev/null
+++ b/packages/uipath/docs/core/studio_web.md
@@ -0,0 +1,354 @@
+# Studio Web Integration
+
+[Studio Web](https://docs.uipath.com/studio-web/automation-cloud/latest/user-guide/overview) is a cloud IDE for building projects such as RPAs, low code agents, and API workflows. It also supports importing coded agents and coded functions built locally. Bringing your project into Studio Web gives you:
+
+- Cloud debugging with dynamic breakpoints
+- Running and defining evaluations directly in the cloud (coded agents only)
+- A unified build experience alongside multiple project types
+- Self contained solution deployment units
+
+!!! warning "Preview Feature"
+    Coded function support is in preview and is subject to changes.
+
+<picture data-light="../assets/studio_web_diagram_light.png" data-dark="../assets/studio_web_diagram_dark.png">
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="
+      ../assets/studio_web_diagram_dark.png
+    "
+  />
+  <img
+    src="../assets/studio_web_diagram_light.png"
+    alt="Coded agent or coded function in Studio Web"
+  />
+</picture>
+
+There are two ways to connect your project to Studio Web: using a [Cloud Workspace](#cloud-workspace) or a [Local Workspace](#local-workspace).
+
+---
+
+## Cloud Workspace
+
+In a Cloud Workspace, your project lives in Studio Web and you sync code between your local IDE and the cloud.
+
+### Importing a Coded Agent or Coded Function
+
+1. Open your solution in Studio Web
+2. Create the project:
+
+    //// tab | Agent
+
+    Create a new Agent and select **Coded**:
+
+    <picture data-light="../assets/studio_web_select_coded_light.png" data-dark="../assets/studio_web_select_coded_dark.png">
+      <source
+        media="(prefers-color-scheme: dark)"
+        srcset="
+          ../assets/studio_web_select_coded_dark.png
+        "
+      />
+      <img
+        src="../assets/studio_web_select_coded_light.png"
+      />
+    </picture>
+
+    ////
+
+    //// tab | Function
+
+    Use the **Initial setup screen** to get started:
+
+    <picture data-light="../assets/studio_web_select_function_light.png" data-dark="../assets/studio_web_select_function_dark.png">
+      <source
+        media="(prefers-color-scheme: dark)"
+        srcset="
+          ../assets/studio_web_select_function_dark.png
+        "
+      />
+      <img
+        src="../assets/studio_web_select_function_light.png"
+      />
+    </picture>
+
+    ////
+
+3. Choose a sample project to start from, or push an existing local project
+
+### Pushing an Existing Project
+
+If you already have a project locally, you can sync it to Studio Web:
+
+1. Copy the `UIPATH_PROJECT_ID` from Studio Web into your `.env` file
+
+ <picture data-light="../assets/studio_web_sync_from_ide_light.png" data-dark="../assets/studio_web_sync_from_ide_dark.png">
+   <source
+     media="(prefers-color-scheme: dark)"
+     srcset="
+       ../assets/studio_web_sync_from_ide_dark.png
+     "
+   />
+   <img
+     src="../assets/studio_web_sync_from_ide_light.png"
+   />
+ </picture>
+
+2. Push your project:
+
+    <!-- termynal -->
+
+    ```shell
+    > uipath push
+    Pushing UiPath project to Studio Web...
+    Uploading 'main.py'
+    Uploading 'uipath.json'
+    Updating 'pyproject.toml'
+    Uploading '.uipath/studio_metadata.json'
+    Importing referenced resources to Studio Web project...
+     🔵 Resource import summary: 3 total resources - 1 created, 1 updated, 1 unchanged, 0 not found
+    ```
+
+    Notice the **Resource import summary** at the end. The push command also imports resources defined in `bindings.json` into the Studio Web solution, just like importing resources for a low code agent. This ensures that all required resources are packaged with the solution, so the project works anywhere the solution is deployed.
+
+    See [`uipath push`](../cli/index.md) in the CLI Reference.
+
+### Pulling Changes
+
+To pull the latest version from Studio Web to your local environment:
+
+<!-- termynal -->
+
+```shell
+> uipath pull
+Pulling UiPath project from Studio Web...
+Processing: main.py
+File 'main.py' is up to date
+Processing: uipath.json
+File 'uipath.json' is up to date
+Processing: bindings.json
+File 'bindings.json' is up to date
+Processing: evaluations\eval-sets\evaluation-set-default.json
+Downloaded 'evaluations\eval-sets\evaluation-set-default.json'
+Processing: evaluations\evaluators\evaluator-default.json
+Downloaded 'evaluations\evaluators\evaluator-default.json'
+✓  Project pulled successfully
+```
+
+See [`uipath pull`](../cli/index.md) in the CLI Reference.
+
+---
+
+## Local Workspace
+
+!!! warning "Preview Feature"
+    The local workspace integration is currently experimental.
+    Behavior is subject to change in future versions.
+
+In a Local Workspace, your project lives on your machine and is linked to a Studio Web solution. See the [Local Workspace documentation](https://docs.uipath.com/studio-web/automation-cloud/latest/user-guide/solutions-in-the-local-workspace) for setup details.
+
+You can either start from a predefined template in Studio Web or set up a new project from scratch.
+
+### Starting from a Template
+
+When creating a new coded agent or coded function in Studio Web with a Local Workspace, you can pick one of the predefined templates. This creates the project files directly on your machine. Templates come with sample code and predefined evaluations you can run immediately.
+
+### Setting Up a New Project
+
+You can also create a project from scratch in your local IDE and have it appear in Studio Web.
+
+#### Coded Agent
+
+First, install the SDK package for the framework you want to use:
+
+//// tab | uv
+
+<!-- termynal -->
+
+```shell
+# Pick the package that matches your framework:
+#   uipath-langchain       - LangChain / LangGraph
+#   uipath-openai-agents   - OpenAI Agents SDK
+#   uipath-llamaindex      - LlamaIndex
+#   uipath-pydantic-ai     - PydanticAI
+#   uipath-google-adk      - Google ADK
+#   uipath-agent-framework - UiPath Agent Framework
+> uv add uipath-langchain
+Resolved 42 packages in 1.2s
+Installed 42 packages in 0.8s
+```
+
+////
+
+//// tab | pip
+
+<!-- termynal -->
+
+```shell
+# Pick the package that matches your framework:
+#   uipath-langchain       - LangChain / LangGraph
+#   uipath-openai-agents   - OpenAI Agents SDK
+#   uipath-llamaindex      - LlamaIndex
+#   uipath-pydantic-ai     - PydanticAI
+#   uipath-google-adk      - Google ADK
+#   uipath-agent-framework - UiPath Agent Framework
+> pip install uipath-langchain
+Successfully installed uipath-langchain
+```
+
+////
+
+Then authenticate, scaffold the agent, and initialize the project:
+
+<!-- termynal -->
+
+```shell
+> uipath auth
+⠋ Authenticating with UiPath ...
+🔗 If a browser window did not open, please open the following URL in your browser: [LINK]
+👇 Select tenant:
+  0: Tenant1
+  1: Tenant2
+Select tenant number: 0
+Selected tenant: Tenant1
+✓  Authentication successful.
+
+> uipath new agent
+✓  Created new agent project.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+```
+
+That's it, your agent should now be visible in Studio Web.
+
+#### Coded Function
+
+A coded function doesn't require an additional framework package. Authenticate, scaffold the project, and initialize it:
+
+<!-- termynal -->
+
+```shell
+> uipath auth
+⠋ Authenticating with UiPath ...
+🔗 If a browser window did not open, please open the following URL in your browser: [LINK]
+👇 Select tenant:
+  0: Tenant1
+  1: Tenant2
+Select tenant number: 0
+Selected tenant: Tenant1
+✓  Authentication successful.
+
+> uipath new my-function
+✓  Created 'main.py' file.
+✓  Created 'pyproject.toml' file.
+✓  Created 'uipath.json' file.
+
+> uipath init
+⠋ Initializing UiPath project ...
+✓  Created 'entry-points.json' file.
+```
+
+That's it, your coded function should now be visible in Studio Web.
+
+---
+
+## Publishing
+
+Once your project is in Studio Web, publishing works the same as any other project. Click **Publish** in Studio Web and it will be packaged and deployed through the standard workflow.
+
+---
+
+## Running and Debugging
+
+Your project can be run both in the cloud (via Studio Web) and locally using the CLI.
+
+The CLI commands below take the entrypoint name as the first argument. For a coded agent, this is the graph name declared in your framework's config (for example, `agent` in `langgraph.json`). For a coded function, this is the key declared in the `functions` map of `uipath.json` (for example, `main`).
+
+### Running Locally
+
+//// tab | Agent
+
+<!-- termynal -->
+
+```shell
+> uipath run agent '{"message": "hello"}'
+```
+
+////
+
+//// tab | Function
+
+<!-- termynal -->
+
+```shell
+> uipath run main '{"message": "hello"}'
+```
+
+////
+
+See [`uipath run`](../cli/index.md) in the CLI Reference.
+
+### Debugging Locally
+
+Use `uipath debug` for an enhanced local debugging experience. Unlike `uipath run`, the debug command:
+
+- Auto polls for trigger responses when the project suspends (e.g., LangGraph interrupts)
+- Fetches binding overwrites from Studio Web (configurable in **Debug > Debug Configuration > Solution resources**)
+
+//// tab | Agent
+
+<!-- termynal -->
+
+```shell
+> uipath debug agent '{"message": "hello"}'
+```
+
+////
+
+//// tab | Function
+
+<!-- termynal -->
+
+```shell
+> uipath debug main '{"message": "hello"}'
+```
+
+////
+
+See [`uipath debug`](../cli/index.md) in the CLI Reference.
+
+### Evaluating Locally
+
+Run evaluations against your project using the CLI:
+
+//// tab | Agent
+
+<!-- termynal -->
+
+```shell
+> uipath eval agent .\evaluations\eval-sets\faithfulness-multi-model.json
+```
+
+////
+
+//// tab | Function
+
+<!-- termynal -->
+
+```shell
+> uipath eval main .\evaluations\eval-sets\default.json
+```
+
+////
+
+See [`uipath eval`](../cli/index.md) in the CLI Reference and the [Evaluations documentation](../eval/index.md).
+
+---
+
+## Syncing Evaluations
+
+Evaluations can be defined either in Studio Web or locally, and sync automatically when you use `uipath pull` and `uipath push`. Defining and running evaluations in Studio Web is supported for coded agents only; coded functions can still be evaluated locally with `uipath eval`.
+
+/// note
+Custom evaluators must be created locally. See [Custom Evaluators](../eval/custom_evaluators.md) for details.
+///
diff --git a/packages/uipath/docs/core/tasks.md b/packages/uipath/docs/core/tasks.md
new file mode 100644
index 000000000..692ae445f
--- /dev/null
+++ b/packages/uipath/docs/core/tasks.md
@@ -0,0 +1 @@
+::: uipath.platform.action_center._tasks_service
diff --git a/docs/core/traced.md b/packages/uipath/docs/core/traced.md
similarity index 77%
rename from docs/core/traced.md
rename to packages/uipath/docs/core/traced.md
index da8dbc5dc..195e5751a 100644
--- a/docs/core/traced.md
+++ b/packages/uipath/docs/core/traced.md
@@ -71,9 +71,47 @@ def sensitive_operation(secret):
 - Regular functions (sync/async)
 - Generator functions (sync/async)
 
-## Example with plain python agents
+## Example with coded functions
 
-When used with plain python agents please call `wait_for_tracers()` at the end of the script to ensure all traces are sent, if this is not called the agent could end without sending all the traces.
+Apply `@traced` to individual steps inside your function. Do **not** trace the entry point — the Orchestrator runtime wraps the job execution in its own span, so decorating the entry point creates a duplicate outer span.
+
+```python hl_lines="4 9 14"
+from uipath.tracing import traced
+
+
+@traced(name="fetch_document", run_type="uipath")
+def fetch_document(document_id: str) -> bytes:
+    ...
+
+
+@traced(name="extract_fields", run_type="uipath")
+def extract_fields(content: bytes) -> dict:
+    ...
+
+
+@traced(name="post_to_erp", run_type="uipath")
+def post_to_erp(data: dict) -> str:
+    ...
+
+
+def main(input: Input) -> Output:   # entry point — NOT traced
+    content = fetch_document(input.document_id)
+    data = extract_fields(content)
+    result_id = post_to_erp(data)
+    return Output(result_id=result_id)
+```
+
+Use `hide_input=True` or `hide_output=True` on steps that handle credentials or PII:
+
+```python hl_lines="1"
+@traced(name="get_api_token", run_type="uipath", hide_input=True, hide_output=True)
+def get_api_token(client_id: str, client_secret: str) -> str:
+    ...
+```
+
+## Example with plain python scripts
+
+When used outside the Orchestrator runtime (e.g. a standalone script), call `wait_for_tracers()` at the end to ensure all traces are flushed before the process exits.
 
 ```python hl_lines="3 8"
 
diff --git a/packages/uipath/docs/eval/contains.md b/packages/uipath/docs/eval/contains.md
new file mode 100644
index 000000000..73a377742
--- /dev/null
+++ b/packages/uipath/docs/eval/contains.md
@@ -0,0 +1,186 @@
+# Contains Evaluator
+
+The Contains Evaluator checks whether the agent's output contains a specific search text. This is useful for validating that certain keywords, phrases, or patterns appear in the output without requiring an exact match.
+
+## Overview
+
+**Evaluator ID**: `contains`
+
+**Use Cases**:
+
+-   Verify specific keywords or phrases appear in output
+-   Check for presence of expected content
+-   Test that error messages or warnings contain specific text
+-   Validate outputs include required information
+
+**Returns**: Binary score (1.0 if found, 0.0 if not found) with `BaseEvaluatorJustification` details containing `expected` and `actual`
+
+## Configuration
+
+!!! note "Agent Output Structure"
+    `agent_output` must always be a dictionary. When comparing, the value (or specific field via `target_output_key`) is converted to a string before checking if it contains the search text.
+
+### ContainsEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ContainsEvaluator"` | The evaluator's name |
+| `case_sensitive` | `bool` | `False` | Whether comparison is case-sensitive |
+| `negated` | `bool` | `False` | If True, passes when text is NOT found |
+| `target_output_key` | `str` | `"*"` | Specific key to extract from output (use "*" for entire output) |
+| `default_evaluation_criteria` | `ContainsEvaluationCriteria or None` | `None` | Default criteria if not specified per test |
+
+## Evaluation Criteria
+
+### ContainsEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `search_text` | `str` | The text to search for in the output |
+
+## Examples
+
+### Basic Usage
+
+```python
+from uipath.eval.evaluators import ContainsEvaluator
+from uipath.eval.models import AgentExecution
+
+# Sample agent execution
+agent_execution = AgentExecution(
+    agent_input={"query": "What is the capital of France?"},
+    agent_output={"response": "The capital of France is Paris."},
+    agent_trace=[],
+)
+
+# Create evaluator - extracts "response" field for comparison
+evaluator = ContainsEvaluator(
+    id="contains-check",
+    config={
+        "name": "ContainsEvaluator",
+        "case_sensitive": False,
+        "target_output_key": "response"  # Extract the "response" field
+    }
+)
+
+# Evaluate - searches in the "response" field value
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"search_text": "Paris"}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Case-Sensitive Search
+
+```python
+# Sample agent execution
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"message": "Hello World"},
+    agent_trace=[],
+)
+
+evaluator = ContainsEvaluator(
+    id="contains-case-sensitive",
+    config={
+        "name": "ContainsEvaluator",
+        "case_sensitive": True,
+        "target_output_key": "message"  # Extract the "message" field
+    }
+)
+
+# This will fail because of case mismatch
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"search_text": "hello"}
+)
+
+print(f"Score: {result.score}")  # Output: 0.0
+```
+
+### Negated Search
+
+Use negation to ensure specific text is NOT present:
+
+```python
+# Sample agent execution
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"status": "Success: Operation completed"},
+    agent_trace=[],
+)
+
+evaluator = ContainsEvaluator(
+    id="contains-negated",
+    config={
+        "name": "ContainsEvaluator",
+        "negated": True,
+        "target_output_key": "status"  # Extract the "status" field
+    }
+)
+
+# Passes because "error" is NOT found
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"search_text": "error"}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Target Specific Output Field
+
+```python
+# Sample agent execution
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "status": "success",
+        "message": "User profile updated successfully"
+    },
+    agent_trace=[],
+)
+
+evaluator = ContainsEvaluator(
+    id="contains-targeted",
+    config={
+        "name": "ContainsEvaluator",
+        "target_output_key": "message"
+    }
+)
+
+# Only searches within the "message" field
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"search_text": "updated"}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+## Result Details
+
+The evaluator returns a `NumericEvaluationResult` with:
+
+- **score** (`float`): 1.0 if search text is found, 0.0 otherwise (inverted when `negated=True`)
+- **details** (`BaseEvaluatorJustification`): Structured justification containing:
+    - `expected` (`str`): The search text (after case normalization if applicable)
+    - `actual` (`str`): The actual output value (after case normalization if applicable)
+
+## Best Practices
+
+1. **Use case-insensitive matching** by default to make tests more robust
+2. **Combine with other evaluators** for comprehensive validation
+3. **Use negated mode** to ensure error messages or sensitive data are NOT present
+4. **Target specific fields** when evaluating structured outputs to reduce false positives
+5. **Remember substring matching** - this evaluator uses substring search, not full-text search
+
+## Related Evaluators
+
+- [Exact Match Evaluator](exact_match.md): For exact string matching
+- [JSON Similarity Evaluator](json_similarity.md): For structural comparison
+- [LLM Judge Output Evaluator](llm_judge_output.md): For semantic similarity
+
+
diff --git a/packages/uipath/docs/eval/custom_evaluators.md b/packages/uipath/docs/eval/custom_evaluators.md
new file mode 100644
index 000000000..e92fbc2c4
--- /dev/null
+++ b/packages/uipath/docs/eval/custom_evaluators.md
@@ -0,0 +1,772 @@
+# Custom Python Evaluators
+
+Custom Python Evaluators enable you to implement domain-specific evaluation logic tailored to your agent's unique requirements. When the built-in evaluators don't cover your specific use case, you can create custom evaluators with full control over the evaluation criteria and scoring logic.
+
+## Overview
+
+**Use Cases**:
+
+- Domain-specific validation (e.g., healthcare data compliance, financial calculations)
+- Complex multi-step verification logic
+- Custom data extraction and comparison from tool calls
+- Specialized scoring algorithms (e.g., Jaccard similarity, Levenshtein distance)
+- Integration with external validation systems
+
+**Returns**: Any `EvaluationResult` type (`NumericEvaluationResult`, `BooleanEvaluationResult`, or `ErrorEvaluationResult`)
+
+## Project Structure
+
+Custom evaluators must follow this directory structure:
+
+```
+your-project/
+├── evals/
+│   ├── evaluators/
+│   │   ├── custom/
+│   │   │   ├── your_evaluator.py       # Your evaluator implementation
+│   │   │   ├── another_evaluator.py    # Additional custom evaluators
+│   │   │   └── types/                  # Auto-generated type schemas
+│   │   │       ├── your-evaluator-types.json
+│   │   │       └── another-evaluator-types.json
+│   │   ├── your-evaluator.json         # Auto-generated evaluator config
+│   │   └── another-evaluator.json
+│   └── eval_sets/
+│       └── your_eval_set.json
+└── ...
+```
+
+!!! important "Required Structure"
+    - Custom evaluator files **must** be placed in `evals/evaluators/custom/` directory
+    - Each file should contain one or more evaluator classes inheriting from `BaseEvaluator`
+    - The directory structure is enforced by the CLI tooling
+
+## Creating a Custom Evaluator
+
+### Step 1: Generate Template
+
+Use the CLI to create a new evaluator template:
+
+```bash
+uipath add evaluator my-custom-evaluator
+```
+
+This creates `evals/evaluators/custom/my_custom_evaluator.py` with a template structure.
+
+### Step 2: Implement Evaluation Logic
+
+A custom evaluator consists of three main components:
+
+#### 1. Evaluation Criteria Class
+
+Define the criteria that will be used to evaluate agent executions. This should contain only test-specific data like expected outputs:
+
+```python
+from pydantic import Field
+from uipath.eval.evaluators import BaseEvaluationCriteria
+
+class MyEvaluationCriteria(BaseEvaluationCriteria):
+    """Criteria for my custom evaluator."""
+
+    expected_values: list[str] = Field(default_factory=list)
+```
+
+#### 2. Evaluator Configuration Class
+
+Define configuration options for your evaluator. This should contain behavioral settings like thresholds, modes, etc.:
+
+```python
+from uipath.eval.evaluators import BaseEvaluatorConfig
+
+class MyEvaluatorConfig(BaseEvaluatorConfig[MyEvaluationCriteria]):
+    """Configuration for my custom evaluator."""
+
+    name: str = "MyCustomEvaluator"
+    threshold: float = 0.8  # Minimum score to consider passing
+    case_sensitive: bool = False  # Whether comparison is case-sensitive
+    # Optional: set default criteria
+    # default_evaluation_criteria: MyEvaluationCriteria | None = None
+```
+
+#### 3. Evaluator Implementation Class
+
+Implement the core evaluation logic:
+
+```python
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+from uipath.eval.models import AgentExecution, NumericEvaluationResult
+
+class MyCustomEvaluator(
+    BaseEvaluator[MyEvaluationCriteria, MyEvaluatorConfig, BaseEvaluatorJustification]
+):
+    """Custom evaluator with domain-specific logic.
+
+    This evaluator performs custom validation on agent outputs
+    by comparing extracted data against expected values.
+    """
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: MyEvaluationCriteria
+    ) -> NumericEvaluationResult:
+        """Evaluate the agent execution against criteria.
+
+        Args:
+            agent_execution: The agent execution containing:
+                - agent_input: Input received by the agent
+                - agent_output: Output produced by the agent
+                - agent_trace: OpenTelemetry spans with execution trace
+                - simulation_instructions: Simulation instructions
+            evaluation_criteria: Criteria to evaluate against
+
+        Returns:
+            EvaluationResult with score and details
+        """
+        # Extract data from agent execution
+        actual_values = self._extract_values(agent_execution)
+        expected_values = evaluation_criteria.expected_values
+
+        # Apply case sensitivity from config
+        if not self.evaluator_config.case_sensitive:
+            actual_values = [v.lower() for v in actual_values]
+            expected_values = [v.lower() for v in expected_values]
+
+        # Compute score
+        score = self._compute_similarity(actual_values, expected_values)
+
+        # Check against threshold from config
+        passed = score >= self.evaluator_config.threshold
+
+        return NumericEvaluationResult(
+            score=score,
+            details=self.validate_justification({
+                "expected": str(expected_values),
+                "actual": str(actual_values),
+            }),
+        )
+
+    def _extract_values(self, agent_execution: AgentExecution) -> list[str]:
+        """Extract values from agent execution (implement your logic)."""
+        # Your custom extraction logic here
+        return []
+
+    def _compute_similarity(
+        self, actual: list[str], expected: list[str]
+    ) -> float:
+        """Compute similarity score (implement your logic)."""
+        # Your custom scoring logic here
+        return 0.0
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the unique evaluator identifier.
+
+        Returns:
+            The evaluator ID (must be unique across all evaluators)
+        """
+        return "MyCustomEvaluator"
+```
+
+### Step 3: Register the Evaluator
+
+Register your evaluator to generate the configuration files:
+
+```bash
+uipath register evaluator my_custom_evaluator.py
+```
+
+This command:
+
+1. Validates your evaluator implementation
+2. Generates `evals/evaluators/custom/types/my-custom-evaluator-types.json` with type schemas
+3. Creates `evals/evaluators/my-custom-evaluator.json` with evaluator configuration
+
+The generated configuration file will contain:
+
+```json
+{
+  "version": "1.0",
+  "id": "MyCustomEvaluator",
+  "evaluatorTypeId": "file://types/my-custom-evaluator-types.json",
+  "evaluatorSchema": "file://my_custom_evaluator.py:MyCustomEvaluator",
+  "description": "Custom evaluator with domain-specific logic...",
+  "evaluatorConfig": {
+    "name": "MyCustomEvaluator",
+    "threshold": 0.8,
+    "caseSensitive": false
+  }
+}
+```
+
+!!! note "Evaluator Schema Format"
+    - `evaluatorTypeId`: Format is `file://types/<kebab-case-name>-types.json` - points to the generated type schema
+    - `evaluatorSchema`: Format is `file://<filename>.py:<ClassName>` - tells the runtime where to load your custom evaluator class from
+
+    The `file://` prefix indicates these are local file references that will be resolved relative to the `evals/evaluators/custom/` directory.
+
+### Step 4: Use in Evaluation Sets
+
+Reference your custom evaluator in evaluation sets:
+
+```json
+{
+  "version": "1.0",
+  "id": "my-eval-set",
+  "evaluatorRefs": ["MyCustomEvaluator"],
+  "evaluationItems": [
+    {
+      "id": "test-1",
+      "agentInput": {"query": "Process data"},
+      "evaluations": [
+        {
+          "evaluatorId": "MyCustomEvaluator",
+          "evaluationCriteria": {
+            "expectedValues": ["value1", "value2"]
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+!!! note "Criteria vs Config"
+    - **evaluationCriteria**: Test-specific data (e.g., `expectedValues`) - varies per test case
+    - **evaluatorConfig**: Behavioral settings (e.g., `threshold`, `caseSensitive`) - set once in the evaluator JSON file
+
+## Working with Agent Traces
+
+Custom evaluators often need to extract information from tool calls in the agent execution trace. The SDK provides helper functions for common operations.
+
+### Extracting Tool Calls
+
+```python
+from uipath.eval._helpers.evaluators_helpers import extract_tool_calls
+
+def _process_tool_calls(self, agent_execution: AgentExecution) -> list[str]:
+    """Extract and process tool calls from the execution trace."""
+    tool_calls = extract_tool_calls(agent_execution.agent_trace)
+
+    results = []
+    for tool_call in tool_calls:
+        # Access tool name
+        tool_name = tool_call.name
+
+        # Access tool arguments
+        args = tool_call.args or {}
+
+        if tool_name == "SpecificTool":
+            # Extract specific data from arguments
+            data = args.get("parameter_name", "")
+            results.append(data)
+
+    return results
+```
+
+### Available Helper Functions
+
+```python
+from uipath.eval._helpers.evaluators_helpers import (
+    extract_tool_calls,          # Extract tool calls with arguments
+    extract_tool_calls_names,     # Extract just tool names
+    extract_tool_calls_outputs,   # Extract tool outputs
+    trace_to_str,                 # Convert trace to string representation
+)
+```
+
+## Complete Example
+
+Here's a complete example based on real-world usage that compares data patterns using Jaccard similarity:
+
+```python
+"""Custom evaluator for pattern comparison."""
+
+from pydantic import Field
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.evaluators.base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.models import EvaluationResult, NumericEvaluationResult
+from uipath.eval.models import AgentExecution
+from uipath.eval._helpers.evaluators_helpers import extract_tool_calls
+
+
+def _compute_jaccard_similarity(expected: list[str], actual: list[str]) -> float:
+    """Compute Jaccard similarity (intersection over union).
+
+    Returns 1.0 when both expected and actual are empty (perfect match).
+    """
+    expected_set = set(expected) if expected else set()
+    actual_set = set(actual) if actual else set()
+
+    # If both are empty, that's a perfect match
+    if len(expected_set) == 0 and len(actual_set) == 0:
+        return 1.0
+
+    intersection = len(expected_set.intersection(actual_set))
+    union = len(expected_set.union(actual_set))
+    return intersection / union if union > 0 else 0.0
+
+
+class PatternEvaluatorCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for pattern evaluator."""
+
+    expected_output: list[str] = Field(default_factory=list)
+
+
+class PatternEvaluatorConfig(BaseEvaluatorConfig[PatternEvaluatorCriteria]):
+    """Configuration for pattern evaluator."""
+
+    name: str = "PatternComparisonEvaluator"
+
+
+class PatternComparisonEvaluator(
+    BaseEvaluator[PatternEvaluatorCriteria, PatternEvaluatorConfig, BaseEvaluatorJustification]
+):
+    """Custom evaluator for pattern comparison.
+
+    Extends BaseEvaluator to extract data from specific tool calls and
+    validates patterns found against expected patterns using Jaccard
+    similarity (intersection over union).
+    """
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: PatternEvaluatorCriteria
+    ) -> EvaluationResult:
+        """Evaluate the pattern comparison.
+
+        Args:
+            agent_execution: The agent execution containing trace data
+            evaluation_criteria: Expected output patterns
+
+        Returns:
+            EvaluationResult with score (0.0 to 1.0) based on Jaccard similarity
+        """
+        expected_output = evaluation_criteria.expected_output
+
+        # Extract actual output from tool calls
+        actual_output = self._extract_patterns(agent_execution)
+
+        # Compute score using intersection over union
+        score = _compute_jaccard_similarity(expected_output, actual_output)
+
+        return NumericEvaluationResult(
+            score=score,
+            details=self.validate_justification({
+                "expected": str(expected_output),
+                "actual": str(actual_output),
+            }),
+        )
+
+    def _extract_patterns(self, agent_execution: AgentExecution) -> list[str]:
+        """Extract patterns from tool calls.
+
+        Args:
+            agent_execution: The agent execution containing trace data
+
+        Returns:
+            List of pattern strings found
+        """
+        # Extract tool calls with arguments using the helper function
+        tool_calls = extract_tool_calls(agent_execution.agent_trace)
+
+        for tool_call in tool_calls:
+            if tool_call.name == "DataProcessingTool":
+                args = tool_call.args or {}
+                file_name = str(args.get("FileName", ""))
+                if file_name.startswith("PatternData"):
+                    input_data = str(args.get("InputData", ""))
+                    if input_data:
+                        lines = input_data.split("\n")
+                        # Extract and process patterns (custom logic)
+                        patterns = [line.strip() for line in lines[1:] if line.strip()]
+                        return patterns
+
+        return []
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator type ID.
+
+        Returns:
+            The evaluator type identifier
+        """
+        return "PatternComparisonEvaluator"
+```
+
+## Best Practices
+
+### 1. Type Annotations and Documentation
+
+Always include complete type annotations and Google-style docstrings:
+
+```python
+def _extract_data(
+    self,
+    agent_execution: AgentExecution,
+    tool_name: str
+) -> list[str]:
+    """Extract data from specific tool calls.
+
+    Args:
+        agent_execution: The agent execution to process
+        tool_name: The name of the tool to extract data from
+
+    Returns:
+        List of extracted data strings
+
+    Raises:
+        ValueError: If the tool call format is invalid
+    """
+    # Implementation
+```
+
+### 2. Error Handling
+
+Use proper error handling and return meaningful results:
+
+```python
+from uipath.eval.models import ErrorEvaluationResult
+
+async def evaluate(
+    self,
+    agent_execution: AgentExecution,
+    evaluation_criteria: MyCriteria
+) -> EvaluationResult:
+    """Evaluate with error handling."""
+    try:
+        # Your evaluation logic
+        score = self._compute_score(agent_execution)
+        return NumericEvaluationResult(score=score)
+    except Exception as e:
+        return ErrorEvaluationResult(
+            error=f"Evaluation failed: {str(e)}"
+        )
+```
+
+### 3. Reusable Helper Methods
+
+Extract common logic into reusable helper methods:
+
+```python
+def _extract_from_tool(
+    self,
+    agent_execution: AgentExecution,
+    tool_name: str,
+    parameter_name: str
+) -> str:
+    """Reusable method to extract parameter from tool calls."""
+    tool_calls = extract_tool_calls(agent_execution.agent_trace)
+    for tool_call in tool_calls:
+        if tool_call.name == tool_name:
+            args = tool_call.args or {}
+            return str(args.get(parameter_name, ""))
+    return ""
+```
+
+### 4. Clear Scoring Logic
+
+Make your scoring logic explicit and well-documented, using config values appropriately:
+
+```python
+def _compute_score(
+    self,
+    actual: list[str],
+    expected: list[str]
+) -> float:
+    """Compute evaluation score.
+
+    Scoring algorithm:
+    - 1.0: Perfect match (all expected items found)
+    - 0.5-0.99: Partial match (some items found)
+    - 0.0: No match (no items found)
+
+    Uses the case_sensitive setting from evaluator config.
+
+    Args:
+        actual: Actual values extracted from execution
+        expected: Expected values from criteria
+
+    Returns:
+        Score between 0.0 and 1.0
+    """
+    if not expected:
+        return 1.0 if not actual else 0.0
+
+    # Apply case sensitivity from config
+    if not self.evaluator_config.case_sensitive:
+        actual = [v.lower() for v in actual]
+        expected = [v.lower() for v in expected]
+
+    matches = len(set(actual).intersection(set(expected)))
+    return matches / len(expected)
+```
+
+### 5. Detailed Results
+
+Provide detailed information in evaluation results using `validate_justification()`. This method uses the generic type annotations to coerce your data into the correct justification type:
+
+```python
+# For BaseEvaluatorJustification (recommended) - pass a dict with expected/actual fields
+return NumericEvaluationResult(
+    score=score,
+    details=self.validate_justification({
+        "expected": str(expected_values),
+        "actual": str(actual_values),
+    }),
+)
+
+# For custom BaseEvaluatorJustification subclass - pass a dict with all fields
+# (requires a BaseEvaluatorJustification subclass as J parameter)
+return NumericEvaluationResult(
+    score=score,
+    details=self.validate_justification({
+        "expected": str(expected_values),
+        "actual": str(actual_values),
+        "matches": matching_items,
+    }),
+)
+
+# For str justification (not recommended) - pass a plain string
+return NumericEvaluationResult(
+    score=score,
+    details=self.validate_justification(
+        f"Found {len(actual_values)}/{len(expected_values)} expected values"
+    ),
+)
+```
+
+## Generic Type Parameters
+
+Custom evaluators use three generic type parameters in the class signature:
+
+```python
+class MyEvaluator(BaseEvaluator[T, C, J]):
+    """
+    T: Evaluation criteria type (subclass of BaseEvaluationCriteria)
+    C: Configuration type (subclass of BaseEvaluatorConfig[T])
+    J: Justification type (BaseEvaluatorJustification, a subclass of it, or str)
+    """
+```
+
+**Common patterns**:
+
+- `BaseEvaluator[MyCriteria, MyConfig, BaseEvaluatorJustification]` - **Recommended.** Returns base justification with `expected` and `actual` fields
+- `BaseEvaluator[MyCriteria, MyConfig, MyJustification]` - Custom justification (subclass of `BaseEvaluatorJustification`) with additional fields beyond `expected`/`actual`
+- `BaseEvaluator[MyCriteria, MyConfig, str]` - Simple string justification (not recommended — prefer typed justifications that carry `expected`/`actual` so evaluation results are self-describing)
+
+!!! tip "Prefer typed justifications"
+    Using `BaseEvaluatorJustification` (or a subclass) instead of `str` ensures every evaluation result contains structured `expected` and `actual` fields, making results easier to interpret and aggregate programmatically.
+
+The justification type is resolved at runtime from the generic annotations and used by `validate_justification()` to coerce raw data (dicts or strings) into the correct type. This means evaluators should pass raw data to `self.validate_justification()` rather than manually instantiating justification types.
+
+## Testing Custom Evaluators
+
+Test your evaluators locally before registration:
+
+```python
+import pytest
+from uipath.eval.models import AgentExecution
+
+@pytest.mark.asyncio
+async def test_custom_evaluator() -> None:
+    """Test custom evaluator logic."""
+    # Create test data
+    agent_execution = AgentExecution(
+        agent_input={"query": "test"},
+        agent_output={"result": "test output"},
+        agent_trace=[],
+    )
+
+    # Create evaluator with config
+    evaluator = MyCustomEvaluator(
+        id="test-evaluator",
+        config={
+            "name": "MyCustomEvaluator",
+            "threshold": 0.8,
+            "case_sensitive": False,
+        }
+    )
+
+    # Evaluate with criteria
+    criteria = MyEvaluationCriteria(expected_values=["value1"])
+    result = await evaluator.evaluate(agent_execution, criteria)
+
+    # Assert
+    assert result.score >= 0.0
+    assert result.score <= 1.0
+```
+
+## Common Patterns
+
+### Pattern 1: Extracting Data from Specific Tools
+
+```python
+def _extract_from_specific_tool(
+    self, agent_execution: AgentExecution
+) -> str:
+    """Extract data from a specific tool call."""
+    tool_calls = extract_tool_calls(agent_execution.agent_trace)
+
+    for tool_call in tool_calls:
+        if tool_call.name == "TargetTool":
+            args = tool_call.args or {}
+            return str(args.get("target_parameter", ""))
+
+    return ""
+```
+
+### Pattern 2: Computing Set-Based Similarity
+
+```python
+def _compute_set_similarity(
+    self, actual: list[str], expected: list[str]
+) -> float:
+    """Compute similarity using set operations."""
+    actual_set = set(actual)
+    expected_set = set(expected)
+
+    if not expected_set:
+        return 1.0 if not actual_set else 0.0
+
+    intersection = len(actual_set.intersection(expected_set))
+    return intersection / len(expected_set)
+```
+
+### Pattern 3: Multi-Step Validation
+
+```python
+async def evaluate(
+    self,
+    agent_execution: AgentExecution,
+    evaluation_criteria: MyCriteria
+) -> EvaluationResult:
+    """Multi-step validation using config settings."""
+    # Step 1: Validate structure (use strict mode from config)
+    if not self._validate_structure(agent_execution, self.evaluator_config.strict):
+        return NumericEvaluationResult(
+            score=0.0,
+            details=self.validate_justification({
+                "expected": str(evaluation_criteria.expected_data),
+                "actual": "Invalid structure",
+            }),
+        )
+
+    # Step 2: Extract data
+    data = self._extract_data(agent_execution)
+
+    # Step 3: Compare and score
+    score = self._compare_data(data, evaluation_criteria.expected_data)
+
+    # Step 4: Check against threshold from config
+    passed = score >= self.evaluator_config.threshold
+
+    return NumericEvaluationResult(
+        score=score,
+        details=self.validate_justification({
+            "expected": str(evaluation_criteria.expected_data),
+            "actual": str(data),
+        }),
+    )
+```
+
+## Troubleshooting
+
+### Evaluator Not Found
+
+**Error**: `Could not find '<filename>' in evals/evaluators/custom folder`
+
+**Solution**: Ensure your evaluator file is in the correct directory:
+
+```bash
+# Check file location
+ls evals/evaluators/custom/
+
+# File should be: evals/evaluators/custom/my_evaluator.py
+```
+
+### Class Not Inheriting from BaseEvaluator
+
+**Error**: `Could not find a class inheriting from BaseEvaluator in <filename>`
+
+**Solution**: Verify your class properly inherits from `BaseEvaluator`:
+
+```python
+from uipath.eval.evaluators import BaseEvaluator
+
+class MyEvaluator(BaseEvaluator[...]):  # ✓ Correct
+    pass
+
+class MyEvaluator:  # ✗ Wrong - missing inheritance
+    pass
+```
+
+### Missing get_evaluator_id Method
+
+**Error**: `Error getting evaluator ID`
+
+**Solution**: Implement the required `get_evaluator_id` class method:
+
+```python
+@classmethod
+def get_evaluator_id(cls) -> str:
+    """Get the evaluator ID."""
+    return "MyUniqueEvaluatorId"
+```
+
+### Type Inconsistency
+
+**Error**: `Type inconsistency in evaluator: Config expects criteria type X`
+
+**Solution**: Ensure your config's generic parameter matches your evaluator's criteria type:
+
+```python
+# ✓ Correct - matching types
+class MyCriteria(BaseEvaluationCriteria):
+    pass
+
+class MyConfig(BaseEvaluatorConfig[MyCriteria]):  # Uses MyCriteria
+    pass
+
+class MyEvaluator(BaseEvaluator[MyCriteria, MyConfig, BaseEvaluatorJustification]):  # Also uses MyCriteria
+    pass
+
+# ✗ Wrong - mismatched types
+class MyEvaluator(BaseEvaluator[OtherCriteria, MyConfig, BaseEvaluatorJustification]):  # Mismatch!
+    pass
+```
+
+## CLI Commands Reference
+
+### Create New Evaluator
+
+```bash
+uipath add evaluator <evaluator-name>
+```
+
+Creates a new evaluator template in `evals/evaluators/custom/`.
+
+### Register Evaluator
+
+```bash
+uipath register evaluator <evaluator-file.py>
+```
+
+Validates and generates configuration files for the evaluator.
+
+## Running Your Custom Evaluators
+
+Once registered, your custom evaluators can be used in evaluation sets just like built-in evaluators. See the [Evaluation Overview - Running Evaluations](index.md#running-evaluations) section for details on using the `uipath eval` command.
+
+## Related Documentation
+
+- [Evaluation Overview](index.md): Understanding the evaluation framework and running evaluations
+- [Exact Match Evaluator](exact_match.md): Example of a deterministic evaluator
+- [Tool Call Args Evaluator](tool_call_args.md): Working with tool call data
+- [LLM Judge Output](llm_judge_output.md): LLM-based evaluation patterns
+
diff --git a/packages/uipath/docs/eval/exact_match.md b/packages/uipath/docs/eval/exact_match.md
new file mode 100644
index 000000000..afc11d619
--- /dev/null
+++ b/packages/uipath/docs/eval/exact_match.md
@@ -0,0 +1,251 @@
+# Exact Match Evaluator
+
+The Exact Match Evaluator performs exact string matching between the agent's output and expected output. This is the most strict deterministic evaluator, useful for scenarios where output must match exactly.
+
+## Overview
+
+**Evaluator ID**: `exact-match`
+
+**Use Cases**:
+
+-   Validate exact responses (e.g., status codes, IDs)
+-   Test deterministic outputs
+-   Ensure precise formatting is maintained
+-   Verify exact data values
+
+**Returns**: Binary score (1.0 if exact match, 0.0 otherwise) with `BaseEvaluatorJustification` details containing `expected` and `actual`
+
+## Configuration
+
+!!! note "Agent Output Structure"
+    `agent_output` must always be a dictionary (e.g., `{"result": "value"}`). To evaluate simple values like strings or numbers, wrap them in a dict and use `target_output_key` to extract the specific field.
+
+### ExactMatchEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ExactMatchEvaluator"` | The evaluator's name |
+| `case_sensitive` | `bool` | `False` | Whether comparison is case-sensitive |
+| `negated` | `bool` | `False` | If True, passes when outputs do NOT match |
+| `target_output_key` | `str` | `"*"` | Specific key to extract from output (use "*" for entire output) |
+| `default_evaluation_criteria` | `OutputEvaluationCriteria or None` | `None` | Default criteria if not specified per test |
+
+## Evaluation Criteria
+
+### OutputEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `expected_output` | `dict[str, Any] or str` | The expected output to match exactly |
+
+## Examples
+
+### Basic Usage
+
+```python
+from uipath.eval.evaluators import ExactMatchEvaluator
+from uipath.eval.models import AgentExecution
+
+# agent_output must be a dict
+agent_execution = AgentExecution(
+    agent_input={"query": "What is 2+2?"},
+    agent_output={"result": "4"},
+    agent_trace=[]
+)
+
+# Create evaluator - extracts "result" field for comparison
+evaluator = ExactMatchEvaluator(
+    id="exact-match-1",
+    config={
+        "name": "ExactMatchEvaluator",
+        "case_sensitive": False,
+        "target_output_key": "result"  # Extract the "result" field
+    }
+)
+
+# Evaluate - compares just the "result" field value
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"result": "4"}}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Case-Sensitive Matching
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"status": "SUCCESS"},
+    agent_trace=[]
+)
+
+evaluator = ExactMatchEvaluator(
+    id="exact-match-case",
+    config={
+        "name": "ExactMatchEvaluator",
+        "case_sensitive": True,
+        "target_output_key": "status"  # Extract the "status" field
+    }
+)
+
+# Fails due to case mismatch
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"status": "success"}}
+)
+
+print(f"Score: {result.score}")  # Output: 0.0
+
+# This would pass
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"status": "SUCCESS"}}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Matching Structured Outputs
+
+When `target_output_key` is `"*"` (default), the entire output dict is compared:
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"status": "success", "code": 200},
+    agent_trace=[]
+)
+
+evaluator = ExactMatchEvaluator(
+    id="exact-match-dict",
+    config={
+        "name": "ExactMatchEvaluator",
+        "target_output_key": "*"  # Compare entire output (default)
+    }
+)
+
+# Entire dict structure must match
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"status": "success", "code": 200}}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Target Specific Field
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "result": "approved",
+        "timestamp": "2024-01-01T12:00:00Z"
+    },
+    agent_trace=[]
+)
+
+evaluator = ExactMatchEvaluator(
+    id="exact-match-field",
+    config={
+        "name": "ExactMatchEvaluator",
+        "target_output_key": "result"
+    }
+)
+
+# Only checks the "result" field
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"result": "approved"}}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Negated Mode
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"result": "error"},
+    agent_trace=[]
+)
+
+evaluator = ExactMatchEvaluator(
+    id="exact-match-negated",
+    config={
+        "name": "ExactMatchEvaluator",
+        "negated": True,
+        "target_output_key": "result"  # Extract the "result" field
+    }
+)
+
+# Passes because outputs do NOT match
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"result": "success"}}
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Using Default Criteria
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"status": "OK"},
+    agent_trace=[]
+)
+
+evaluator = ExactMatchEvaluator(
+    id="exact-match-default",
+    config={
+        "name": "ExactMatchEvaluator",
+        "target_output_key": "status",  # Extract the "status" field
+        "default_evaluation_criteria": {"expected_output": {"status": "OK"}}
+    }
+)
+
+# Use default criteria
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution, evaluation_criteria=None
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+## Result Details
+
+The evaluator returns a `NumericEvaluationResult` with:
+
+- **score** (`float`): 1.0 for match, 0.0 for mismatch
+- **details** (`BaseEvaluatorJustification`): Structured justification containing:
+    - `expected` (`str`): The expected output value (after case normalization if applicable)
+    - `actual` (`str`): The actual output value (after case normalization if applicable)
+
+## Best Practices
+
+1. **Use for deterministic outputs** where exact matches are expected
+2. **Consider case sensitivity** based on your use case
+3. **Use case-insensitive mode** by default for more robust tests
+4. **For structured data**, consider using [JSON Similarity Evaluator](json_similarity.md) instead
+5. **Combine with other evaluators** for comprehensive testing
+6. **Be careful with whitespace** - exact match includes all whitespace characters
+
+## When NOT to Use
+
+- When output can vary slightly but still be correct
+- For natural language outputs (use [LLM Judge](llm_judge_output.md) instead)
+- When comparing complex JSON structures (use [JSON Similarity](json_similarity.md))
+- When partial matches are acceptable (use [Contains](contains.md))
+
+## Related Evaluators
+
+- [Contains Evaluator](contains.md): For partial string matching
+- [JSON Similarity Evaluator](json_similarity.md): For flexible JSON comparison
+- [LLM Judge Output Evaluator](llm_judge_output.md): For semantic similarity
+
+
diff --git a/packages/uipath/docs/eval/index.md b/packages/uipath/docs/eval/index.md
new file mode 100644
index 000000000..465fcd96a
--- /dev/null
+++ b/packages/uipath/docs/eval/index.md
@@ -0,0 +1,323 @@
+# Agent Evaluations
+
+The UiPath SDK provides a comprehensive evaluation framework for assessing agent performance and behavior. This framework enables you to systematically measure and validate agent outputs, execution trajectories, and tool usage patterns.
+
+## Overview
+
+The evaluation framework consists of two main categories of evaluators, organized by what they evaluate:
+
+### Output-Based Evaluators
+
+These evaluators assess the final output/result produced by an agent:
+
+-   **[Contains Evaluator](contains.md)**: Checks if the output contains specific text
+-   **[Exact Match Evaluator](exact_match.md)**: Verifies exact string matching
+-   **[JSON Similarity Evaluator](json_similarity.md)**: Measures structural similarity between JSON outputs
+-   **[LLM Judge Output Evaluator](llm_judge_output.md)**: Uses LLM for semantic output evaluation and quality assessment
+
+### Trajectory-Based Evaluators
+
+These evaluators assess the execution path, decision-making process, and tool usage patterns during agent execution:
+
+-   **[Tool Call Order Evaluator](tool_call_order.md)**: Validates the sequence in which tools are called
+-   **[Tool Call Count Evaluator](tool_call_count.md)**: Verifies the frequency of tool calls
+-   **[Tool Call Args Evaluator](tool_call_args.md)**: Checks tool call arguments for correctness
+-   **[Tool Call Output Evaluator](tool_call_output.md)**: Validates the outputs returned by tool calls
+-   **[LLM Judge Trajectory Evaluator](llm_judge_trajectory.md)**: Evaluates agent execution trajectories and decision-making with LLM judgment
+
+### Custom Evaluators
+
+When built-in evaluators don't meet your specific needs, you can create custom evaluators with your own logic.
+
+Custom evaluators enable:
+
+-   **Domain-specific validation**: Implement validation logic tailored to your industry or use case
+-   **Complex scoring algorithms**: Use specialized algorithms like Jaccard similarity, Levenshtein distance, or custom metrics
+-   **Tool call inspection**: Extract and validate data from specific tool calls in the agent trace
+-   **Integration with external systems**: Connect to databases, APIs, or other validation services
+
+See **[Custom Python Evaluators](custom_evaluators.md)** for detailed implementation guide, including:
+
+-   Creating evaluator classes with proper type annotations
+-   Implementing custom evaluation criteria and configuration
+-   Extracting data from agent traces and tool calls
+-   Registering evaluators with the CLI
+-   Complete examples and best practices
+
+## Core Concepts
+
+### Evaluation Criteria
+
+Each evaluator uses specific criteria to define what should be evaluated. Criteria can be specified per test case or set as defaults in the evaluator configuration.
+
+### Evaluation Results
+
+Evaluators return a score (typically between 0 and 1) along with structured justification details. The justification type is determined by the evaluator's generic type parameter `J` and is always a `BaseEvaluatorJustification` subclass. The base class provides `expected` and `actual` fields, while specific evaluators extend it with additional fields (e.g., `LLMJudgeJustification` adds a `justification` field, `JsonSimilarityJustification` adds `matched_leaves`/`total_leaves`).
+
+### Configuration
+
+Each evaluator has a configuration class that defines:
+
+-   **name**: The evaluator's identifier
+-   **default_evaluation_criteria**: Default criteria if not specified per test
+-   Evaluator-specific settings (e.g., `case_sensitive`, `strict`, `temperature`)
+
+## Getting Started
+
+To use an evaluator, you typically:
+
+1. Import the evaluator class
+2. Create an evaluator instance with configuration
+3. Call the `evaluate()` method with agent execution data and criteria
+
+```python
+from uipath.eval.evaluators import ExactMatchEvaluator
+from uipath.eval.models import AgentExecution
+
+# Sample agent execution (this should be replaced with your agent run data)
+agent_execution = AgentExecution(
+    agent_input={"query": "Greet the world"},
+    agent_output={"result": "hello, world!"},
+    agent_trace=[],
+)
+
+# Create evaluator
+evaluator = ExactMatchEvaluator(
+    id="exact-match-1",
+    config={
+        "name": "ExactMatchEvaluator",
+        "case_sensitive": False,
+        "target_output_key": "result",
+    }
+)
+
+# Evaluate
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={"expected_output": {"result": "Hello, World!"}}
+)
+
+print(f"Score: {result.score}")
+```
+
+## Best Practices
+
+1. **Choose the right category**:
+   - Use **Output-Based Evaluators** to validate what the agent produces (final results)
+   - Use **Trajectory-Based Evaluators** to validate how the agent achieves results (decision-making and tool usage)
+
+2. **Select appropriate evaluators within categories**:
+   - For outputs: Use deterministic evaluators (exact match, contains, JSON similarity) for predictable outputs and LLM judges for semantic/quality assessment
+   - For trajectories: Use tool call evaluators for specific validations and LLM judges for holistic behavior assessment
+
+3. **Combine multiple evaluators**: Use different evaluators together for comprehensive evaluation (e.g., exact match for output + tool call order for trajectory)
+
+4. **Set appropriate thresholds**: Define minimum acceptable scores based on your use case
+
+5. **Evaluate both outputs and trajectories**: For complex agents, validate both what they produce and how they produce it
+
+6. **Create custom evaluators when needed**: If built-in evaluators don't cover your use case, implement custom evaluators with domain-specific logic
+
+## Running Evaluations
+
+The UiPath SDK provides a CLI command to run evaluations against your agents. The evaluation framework automatically discovers your agent and evaluation sets, or you can specify them explicitly.
+
+### Basic Usage
+
+```bash
+# Auto-discover entrypoint and evaluation set
+uipath eval
+
+# Specify entrypoint and evaluation set
+uipath eval <entrypoint> <eval-set-path>
+
+# Run with parallel workers
+uipath eval --workers 4
+
+# Save results to file
+uipath eval --output-file results.json
+
+# Run specific evaluation IDs
+uipath eval --eval-ids "['eval-1', 'eval-2']"
+
+# Disable reporting to Studio Web
+uipath eval --no-report
+```
+
+### Command Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `entrypoint` | Positional | Path to agent script (optional, auto-discovered if not specified) |
+| `eval_set` | Positional | Path to evaluation set JSON file (optional, auto-discovered if not specified) |
+| `--eval-ids` | List | Specific evaluation IDs to run from the eval set |
+| `--eval-set-run-id` | String | Custom evaluation run ID (UUID generated if not provided) |
+| `--workers` | Integer | Number of parallel workers (default: 1) |
+| `--output-file` | Path | File path to save evaluation results |
+| `--no-report` | Flag | Disable reporting results to Studio Web |
+| `--input-overrides` | JSON | Can be used to override any input parameter, but most often used for file inputs (see below) |
+
+### Running Multimodal Evaluations with Input Overrides
+
+You can use the `--input-overrides` parameter to override any input parameter at runtime. This is most commonly used for file attachments inputs.
+
+#### Input Overrides Format
+
+The `--input-overrides` parameter accepts a JSON object where:
+- Keys are evaluation IDs
+- Values are objects containing input parameter names mapped to their override values
+
+#### How File Attachment Overrides Work
+
+**At Design Time:**
+Evaluation sets define file attachments using **relative studioweb local paths**:
+```json
+{
+  "filePath": {
+    "ID": "evaluationFiles/document.pdf",
+    "FullName": "Document.pdf",
+    "MimeType": "application/pdf"
+  }
+}
+```
+
+**At Runtime (with `--input-overrides`):**
+When running evaluations, you override the local path with an **attachmentId** obtained by uploading the file to your personal workspace:
+```json
+{
+  "filePath": {
+    "ID": "550e8400-e29b-41d4-a716-446655440000"
+  }
+}
+```
+
+The system automatically merges this override with the original definition, preserving `FullName` and `MimeType` fields. The final input passed to your agent becomes:
+```json
+{
+  "filePath": {
+    "ID": "550e8400-e29b-41d4-a716-446655440000",
+    "FullName": "Document.pdf",
+    "MimeType": "application/pdf"
+  }
+}
+```
+
+**Key Points:**
+- Only the `ID` field needs to be specified in the override
+- `FullName` and `MimeType` are automatically preserved from the evaluation set definition
+- You can override any field, but typically only `ID` changes at runtime
+
+#### Example: Single File Attachment
+
+```bash
+uipath eval agent.py eval_set.json \
+  --eval-ids '["eval-001"]' \
+  --eval-set-run-id e4d8f9a2-1234-5678-9abc-def012345678 \
+  --input-overrides '{
+    "eval-001": {
+      "filePath": {
+        "ID": "550e8400-e29b-41d4-a716-446655440000"
+      }
+    }
+  }'
+```
+
+#### Example: Multiple Files (Array)
+
+```bash
+uipath eval agent.py eval_set.json \
+  --eval-ids '["eval-002"]' \
+  --eval-set-run-id e4d8f9a2-1234-5678-9abc-def012345678 \
+  --input-overrides '{
+    "eval-002": {
+      "documents": [
+        {
+          "ID": "550e8400-e29b-41d4-a716-446655440001"
+        },
+        {
+          "ID": "550e8400-e29b-41d4-a716-446655440002"
+        }
+      ]
+    }
+  }'
+```
+
+#### Example: Multiple Evaluations
+
+```bash
+uipath eval agent.py eval_set.json \
+  --eval-ids '["eval-001", "eval-002", "eval-003"]' \
+  --eval-set-run-id e4d8f9a2-1234-5678-9abc-def012345678 \
+  --input-overrides '{
+    "eval-001": {
+      "image": {
+        "ID": "550e8400-e29b-41d4-a716-446655440003"
+      }
+    },
+    "eval-002": {
+      "document": {
+        "ID": "550e8400-e29b-41d4-a716-446655440004"
+      }
+    },
+    "eval-003": {
+      "files": [
+        {"ID": "550e8400-e29b-41d4-a716-446655440005"},
+        {"ID": "550e8400-e29b-41d4-a716-446655440006"}
+      ]
+    }
+  }'
+```
+
+
+
+### Evaluation Sets
+
+Evaluation sets are JSON files that define test cases and specify which evaluators to use:
+
+```json
+{
+  "version": "1.0",
+  "id": "my-eval-set",
+  "evaluatorRefs": ["exact-match-1", "MyCustomEvaluator"],
+  "evaluationItems": [
+    {
+      "id": "test-1",
+      "agentInput": {"query": "What is 2+2?"},
+      "evaluations": [
+        {
+          "evaluatorId": "exact-match-1",
+          "evaluationCriteria": {
+            "expectedOutput": {"result": "4"}
+          }
+        },
+        {
+          "evaluatorId": "MyCustomEvaluator",
+          "evaluationCriteria": {
+            "expectedValues": ["value1", "value2"]
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Results
+
+Evaluation results include:
+
+-   **Score**: Numeric score (typically 0.0 to 1.0) or boolean pass/fail
+-   **Details**: Structured justification for the evaluation (e.g., `BaseEvaluatorJustification` with `expected`/`actual` for deterministic evaluators, `JsonSimilarityJustification` with `matched_leaves`/`total_leaves`, or `LLMJudgeJustification` with `expected`/`actual`/`justification` for LLM judges)
+-   **Metrics**: Token usage, latency, and other execution metrics
+-   **Trace**: Full execution trace including tool calls and outputs
+
+Results can be viewed in:
+
+-   **Console output**: Real-time progress and summary
+-   **Output file**: JSON file with detailed results (use `--output-file`)
+-   **Studio Web**: Automatically reported if running in a Studio project (unless `--no-report` is specified)
+
+## Reference Documentation
+
+See the individual evaluator pages for detailed information on configuration, usage, and examples.
+
diff --git a/packages/uipath/docs/eval/json_similarity.md b/packages/uipath/docs/eval/json_similarity.md
new file mode 100644
index 000000000..19bf60739
--- /dev/null
+++ b/packages/uipath/docs/eval/json_similarity.md
@@ -0,0 +1,326 @@
+# JSON Similarity Evaluator
+
+The JSON Similarity Evaluator performs flexible structural comparison of JSON-like outputs using a tree-based matching algorithm. It recursively traverses the JSON structure as a tree and compares leaf nodes (actual values) with type-specific similarity measures.
+
+## Overview
+
+**Evaluator ID**: `json-similarity`
+
+**Use Cases**:
+
+-   Compare complex nested JSON structures
+-   Validate API responses with tolerance for minor differences
+-   Test structured outputs where exact matches are too strict
+-   Measure similarity when numeric values may vary slightly
+
+**Returns**: Continuous score from 0.0 to 1.0 (0-100% similarity)
+
+## Configuration
+
+!!! note "Agent Output Structure"
+    `agent_output` must always be a dictionary. The evaluator compares dictionary structures recursively, making it ideal for complex nested JSON-like outputs.
+
+### JsonSimilarityEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"JsonSimilarityEvaluator"` | The evaluator's name |
+| `target_output_key` | `str` | `"*"` | Specific key to extract from output (use "*" for entire output) |
+| `default_evaluation_criteria` | `OutputEvaluationCriteria or None` | `None` | Default criteria if not specified per test |
+
+## Evaluation Criteria
+
+### OutputEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `expected_output` | `dict[str, Any] or str` | The expected JSON structure to compare against |
+
+## How It Works
+
+The evaluator uses a **tree-based matching algorithm**:
+
+1. **Tree Structure**: The JSON/dictionary structure is treated as a tree, with nested objects and arrays forming branches
+2. **Leaf Comparison**: Only leaf nodes (actual values) are compared, using type-specific similarity measures:
+   - **Strings**: Levenshtein distance (edit distance) to measure textual similarity
+   - **Numbers**: Absolute difference with tolerance (within 1% considered similar)
+   - **Booleans**: Exact match required (binary comparison)
+3. **Structural Recursion**:
+   - **Objects**: Recursively traverses and compares all expected keys
+   - **Arrays**: Compares elements by position (index-based matching)
+
+**Score Calculation**: `matched_leaves / total_leaves`
+
+The final score represents the percentage of matching leaf nodes in the tree structure.
+
+## Examples
+
+### Basic JSON Comparison
+
+```python
+from uipath.eval.evaluators import JsonSimilarityEvaluator
+from uipath.eval.models import AgentExecution
+
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"name": "John Doe", "age": 30, "city": "New York"},
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-1",
+    config={
+        "name": "JsonSimilarityEvaluator"
+        # target_output_key defaults to "*" - compares entire output dict
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"name": "John Doe", "age": 30, "city": "New York"}
+    }
+)
+
+print(f"Score: {result.score}")  # Output: 1.0 (perfect match)
+print(f"Matched: {result.details.matched_leaves}")  # 3.0
+print(f"Total: {result.details.total_leaves}")  # 3.0
+```
+
+### Numeric Tolerance
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"temperature": 20.5, "humidity": 65},
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-numeric",
+    config={"name": "JsonSimilarityEvaluator"}
+)
+
+# Slightly different numbers
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"temperature": 20.3, "humidity": 65}
+    }
+)
+
+# High similarity despite numeric difference
+print(f"Score: {result.score}")  # ~0.99 (very high similarity)
+```
+
+### String Similarity
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"status": "completed successfully"},
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-string",
+    config={"name": "JsonSimilarityEvaluator"}
+)
+
+# Similar but not exact string
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"status": "completed sucessfully"}  # typo
+    }
+)
+
+# High but not perfect similarity
+print(f"Score: {result.score}")  # ~0.95 (high similarity despite typo)
+```
+
+### Nested Structures
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "user": {
+            "name": "Alice",
+            "profile": {
+                "age": 25,
+                "location": "Paris"
+            }
+        },
+        "status": "active"
+    },
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-nested",
+    config={"name": "JsonSimilarityEvaluator"}
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {
+            "user": {
+                "name": "Alice",
+                "profile": {
+                    "age": 25,
+                    "location": "Paris"
+                }
+            },
+            "status": "active"
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+### Array Comparison
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"items": ["apple", "banana", "orange"]},
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-array",
+    config={"name": "JsonSimilarityEvaluator"}
+)
+
+# Partial match (2 out of 3 correct)
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"items": ["apple", "banana", "grape"]}
+    }
+)
+
+print(f"Score: {result.score}")  # ~0.67 (2/3 correct)
+```
+
+### Handling Extra Keys in Actual Output
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "name": "Bob",
+        "age": 30,
+        "extra_field": "ignored"  # Extra field in actual output
+    },
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-extra",
+    config={"name": "JsonSimilarityEvaluator"}
+)
+
+# Only expected keys are evaluated
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {
+            "name": "Bob",
+            "age": 30
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # Output: 1.0 (extra fields ignored)
+```
+
+### Target Specific Field
+
+```python
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "result": {"score": 95, "passed": True},
+        "metadata": {"timestamp": "2024-01-01"}
+    },
+    agent_trace=[]
+)
+
+evaluator = JsonSimilarityEvaluator(
+    id="json-sim-targeted",
+    config={
+        "name": "JsonSimilarityEvaluator",
+        "target_output_key": "result"
+    }
+)
+
+# Only compares the "result" field
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"result": {"score": 95, "passed": True}}
+    }
+)
+
+print(f"Score: {result.score}")  # Output: 1.0
+```
+
+## Scoring Details
+
+The evaluator returns a `NumericEvaluationResult` with:
+
+- **score** (`float`): Value between 0.0 and 1.0
+- **details** (`JsonSimilarityJustification`): Structured justification containing:
+    - `expected` (`str`): String representation of the expected output
+    - `actual` (`str`): String representation of the actual output
+    - `matched_leaves` (`float`): Number of matching leaf nodes
+    - `total_leaves` (`float`): Total number of leaf nodes compared
+
+### Score Interpretation
+
+| Score Range | Interpretation |
+|-------------|----------------|
+| 1.0 | Perfect match |
+| 0.9 - 0.99 | Very high similarity (minor differences) |
+| 0.7 - 0.89 | Good similarity (some differences) |
+| 0.5 - 0.69 | Moderate similarity (significant differences) |
+| 0.0 - 0.49 | Low similarity (major differences) |
+
+## Best Practices
+
+1. **Use for structured data** like JSON, dictionaries, or objects
+2. **Set score thresholds** based on your tolerance for differences (e.g., require score ≥ 0.9)
+3. **Combine with exact match** for critical fields that must match exactly
+4. **Only expected keys matter** - extra keys in actual output are ignored
+5. **Consider array order** - elements are compared by position
+6. **Useful for API testing** where responses may have minor variations
+
+## When to Use vs Other Evaluators
+
+**Use JSON Similarity when**:
+- Comparing complex nested structures
+- Minor numeric differences are acceptable
+- String typos shouldn't cause complete failure
+- You need a granular similarity score
+
+**Use Exact Match when**:
+- Output must match precisely
+- No tolerance for any differences
+- Simple string comparison needed
+
+**Use LLM Judge when**:
+- Semantic meaning matters more than structure
+- Natural language comparison needed
+- Context and intent should be considered
+
+## Related Evaluators
+
+- [Exact Match Evaluator](exact_match.md): For strict matching
+- [Contains Evaluator](contains.md): For substring matching
+- [LLM Judge Output Evaluator](llm_judge_output.md): For semantic comparison
+
+
diff --git a/packages/uipath/docs/eval/llm_judge_output.md b/packages/uipath/docs/eval/llm_judge_output.md
new file mode 100644
index 000000000..c987a835c
--- /dev/null
+++ b/packages/uipath/docs/eval/llm_judge_output.md
@@ -0,0 +1,365 @@
+# LLM Judge Output Evaluators
+
+LLM Judge Output Evaluators use Language Models to assess the quality and semantic similarity of agent outputs. These evaluators are ideal for scenarios where deterministic comparison is insufficient and human-like judgment is needed.
+
+## Overview
+
+There are two variants of LLM Judge Output Evaluators:
+
+1. **LLM Judge Output Evaluator** (`llm-judge-output-semantic-similarity`): General semantic similarity evaluation
+2. **LLM Judge Strict JSON Similarity Output Evaluator** (`llm-judge-output-strict-json-similarity`): Strict JSON structure comparison with LLM judgment
+
+**Use Cases**:
+
+-   Evaluate natural language outputs
+-   Assess semantic similarity beyond exact matching
+-   Judge output quality based on intent and meaning
+-   Validate structured outputs with flexible criteria
+
+**Returns**: Continuous score from 0.0 to 1.0 with `LLMJudgeJustification` containing `expected`, `actual`, and `justification` fields
+
+## LLM Service Integration
+
+LLM Judge evaluators require an LLM service to perform evaluations. By default, the evaluators use the **UiPathLlmService** to handle LLM requests, which automatically integrates with your configured LLM providers through the UiPath platform.
+
+### Custom LLM Service
+
+You can supply a custom LLM service that supports the following request format:
+
+```python
+{
+    "model": "model-name",
+    "messages": [
+        {"role": "system", "content": "system prompt"},
+        {"role": "user", "content": "evaluation prompt"}
+    ],
+    "response_format": {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "evaluation_response",
+            "schema": {
+                # JSON schema for structured output
+            }
+        }
+    },
+    "max_tokens": 1000,  # or None
+    "temperature": 0.0
+}
+```
+
+The LLM service must:
+
+- Accept messages with `system` and `user` roles
+- Support structured output via `response_format` with JSON schema
+- Return responses conforming to the specified schema
+- Handle `temperature` and `max_tokens` parameters
+
+### Model Selection
+
+When configuring the evaluator, specify the model name according to your LLM service's conventions:
+
+```python
+evaluator = LLMJudgeOutputEvaluator(
+    id="llm-judge-1",
+    config={
+        "name": "LLMJudgeOutputEvaluator",
+        "model": "gpt-4o-2024-11-20",  # Use your service's model naming
+        "temperature": 0.0
+    }
+)
+```
+
+!!! note "UiPathLlmService"
+    The default `UiPathLlmService` supports multiple LLM providers configured through the UiPath platform. Model names follow the provider's conventions (e.g., `gpt-4o-2024-11-20` for OpenAI, `claude-3-5-sonnet-20241022` for Anthropic).
+
+## LLM Judge Output Evaluator
+
+### Configuration
+
+#### LLMJudgeOutputEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"LLMJudgeOutputEvaluator"` | The evaluator's name |
+| `prompt` | `str` | Default user prompt | Custom evaluation prompt |
+| `model` | `str` | `""` | LLM model to use for judgment |
+| `temperature` | `float` | `0.0` | LLM temperature (0.0 for minimal non-determinism) |
+| `max_tokens` | `int or None` | `None` | Maximum tokens for LLM response |
+| `target_output_key` | `str` | `"*"` | Specific key to extract from output |
+| `default_evaluation_criteria` | `OutputEvaluationCriteria or None` | `None` | Default criteria |
+
+### Evaluation Criteria
+
+#### OutputEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `expected_output` | `dict[str, Any] or str` | The expected output for comparison |
+
+### Prompt Placeholders
+
+The prompt template supports these placeholders:
+
+- `{{ActualOutput}}`: Replaced with the agent's actual output
+- `{{ExpectedOutput}}`: Replaced with the expected output from criteria
+
+### Examples
+
+#### Basic Semantic Similarity
+
+```python
+from uipath.eval.evaluators import LLMJudgeOutputEvaluator
+from uipath.eval.models import AgentExecution
+
+agent_execution = AgentExecution(
+    agent_input={"query": "What is the capital of France?"},
+    agent_output={"answer": "Paris is the capital city of France."},
+    agent_trace=[]
+)
+
+evaluator = LLMJudgeOutputEvaluator(
+    id="llm-judge-1",
+    config={
+        "name": "LLMJudgeOutputEvaluator",
+        # Use the UiPathLlmChatService convention for model names; should be changed according to selected service
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0,
+        "target_output_key": "answer"  # Extract the "answer" field
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"answer": "The capital of France is Paris."}
+    }
+)
+
+print(f"Score: {result.score}")  # e.g., 0.95
+print(f"Justification: {result.details.justification}")  # LLM's reasoning
+```
+
+#### Custom Evaluation Prompt
+
+```python
+custom_prompt = """
+Compare the actual output with the expected output.
+Focus on semantic meaning and intent rather than exact wording.
+
+Actual Output: {{ActualOutput}}
+Expected Output: {{ExpectedOutput}}
+
+Provide a score from 0-100 based on semantic similarity.
+"""
+
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={"message": "The product has been successfully added to your cart."},
+    agent_trace=[]
+)
+
+evaluator = LLMJudgeOutputEvaluator(
+    id="llm-judge-custom",
+    config={
+        "name": "LLMJudgeOutputEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "prompt": custom_prompt,
+        "temperature": 0.0,
+        "target_output_key": "message"  # Extract the "message" field
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"message": "Item added to shopping cart."}
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+#### Evaluating Natural Language Quality
+
+```python
+agent_execution = AgentExecution(
+    agent_input={"task": "Write a professional email"},
+    agent_output={"email": """Dear Customer,
+
+Thank you for your inquiry. We have reviewed your request
+and are pleased to inform you that we can accommodate your
+needs. Please let us know if you have any questions.
+
+Best regards,
+Support Team"""},
+    agent_trace=[]
+)
+
+evaluator = LLMJudgeOutputEvaluator(
+    id="llm-judge-quality",
+    config={
+        "name": "LLMJudgeOutputEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0,
+        "target_output_key": "email"  # Extract the "email" field
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {"email": "A professional, courteous response addressing the customer's inquiry"}
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+## LLM Judge Strict JSON Similarity Output Evaluator
+
+This variant performs **per-key matching** on JSON structures with penalty-based scoring. The LLM evaluates each top-level key individually and calculates a final score based on key-level matches.
+
+### How It Works
+
+1. **Key Inventory**: Identifies all top-level keys in expected and actual outputs
+2. **Per-Key Matching**: For each expected key, checks if it exists in actual output
+3. **Content Assessment**: For matching keys, evaluates content similarity (identical/similar/different)
+4. **Penalty-Based Scoring**: Calculates score using these penalties per key:
+   - **Missing key** (not in actual): `100/N` penalty
+   - **Wrong key** (exists but significantly different content): `100/N` penalty
+   - **Similar key** (exists with similar content): `50/N` penalty
+   - **Identical key** (exists with identical content): `0` penalty
+   - **Extra key** (in actual but not expected): `10/N` penalty
+
+   Where `N` = total number of expected keys
+
+**Final Score**: `100 - total_penalty` (scale 0-100)
+
+### Why "Strict"?
+
+Unlike the standard `LLMJudgeOutputEvaluator` which evaluates semantic similarity holistically, this evaluator:
+
+-   **Enforces structural matching**: Each expected key must be present
+-   **Penalizes missing keys heavily**: Same as wrong content (100/N penalty)
+-   **Evaluates per-key**: Independence between key evaluations
+-   **Deterministic scoring formula**: Mechanical calculation based on key-level assessments
+
+### Configuration
+
+#### LLMJudgeStrictJSONSimilarityOutputEvaluatorConfig
+
+Same as `LLMJudgeOutputEvaluatorConfig` but with:
+
+- **name**: `"LLMJudgeStrictJSONSimilarityOutputEvaluator"`
+- **prompt**: Specialized prompt enforcing per-key matching and penalty calculations
+
+### Examples
+
+#### Strict JSON Structure Evaluation
+
+```python
+from uipath.eval.evaluators import LLMJudgeStrictJSONSimilarityOutputEvaluator
+
+evaluator = LLMJudgeStrictJSONSimilarityOutputEvaluator(
+    id="llm-json-strict",
+    config={
+        "name": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0
+    }
+)
+
+agent_execution = AgentExecution(
+    agent_input={},
+    agent_output={
+        "status": "success",
+        "user_id": 12345,
+        "name": "John Doe",
+        "email": "john@example.com"
+    },
+    agent_trace=[]
+)
+
+result = await evaluator.evaluate(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_output": {
+            "status": "success",
+            "user_id": 12345,
+            "name": "John Doe",
+            "email": "john@example.com"
+        }
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+## Understanding LLM Judge Response
+
+The LLM returns a structured response:
+
+```python
+# Result structure
+{
+    "score": 0.85,  # 0.0 to 1.0 (normalized from 0-100)
+    "details": {
+        "expected": "The expected output...",
+        "actual": "The actual output...",
+        "justification": "The outputs convey the same meaning..."  # LLM justification
+    }
+}
+```
+
+## Best Practices
+
+1. **Use temperature 0.0** for deterministic evaluations
+2. **Craft clear prompts** - Be specific about evaluation criteria
+3. **Include both placeholders** - Always use `{{ActualOutput}}` and `{{ExpectedOutput}}`
+4. **Set score thresholds** - Define minimum acceptable scores (e.g., ≥ 0.8)
+5. **Review justifications** - Use LLM explanations to understand scores
+6. **Cost awareness** - LLM evaluations use API calls, consider token costs
+
+## When to Use vs Other Evaluators
+
+**Use LLM Judge Output when**:
+
+-   Semantic meaning matters more than exact wording
+-   Natural language outputs need human-like judgment
+-   Context and intent are important
+-   Flexible evaluation criteria needed
+
+**Use Deterministic Evaluators when**:
+- Exact matches are required
+- Output format is predictable
+- Speed and cost are priorities
+- No ambiguity in correctness
+
+## Configuration Tips
+
+### Temperature Settings
+
+- **0.0**: Deterministic, consistent results (recommended)
+- **0.1**: Slight variation for nuanced judgment
+- **>0.3**: Not recommended (too inconsistent)
+
+## Error Handling
+
+The evaluator will raise `UiPathEvaluationError` if:
+
+- LLM service is unavailable
+- Prompt doesn't contain required placeholders
+- LLM response cannot be parsed
+- Model returns invalid JSON
+
+## Related Evaluators
+
+- [LLM Judge Trajectory Evaluator](llm_judge_trajectory.md): For evaluating agent execution paths
+- [JSON Similarity Evaluator](json_similarity.md): For deterministic JSON comparison
+- [Exact Match Evaluator](exact_match.md): For strict string matching
+- [Contains Evaluator](contains.md): For substring matching
+
+
diff --git a/packages/uipath/docs/eval/llm_judge_trajectory.md b/packages/uipath/docs/eval/llm_judge_trajectory.md
new file mode 100644
index 000000000..8705f1a29
--- /dev/null
+++ b/packages/uipath/docs/eval/llm_judge_trajectory.md
@@ -0,0 +1,438 @@
+# LLM Judge Trajectory Evaluators
+
+LLM Judge Trajectory Evaluators use Language Models to assess the quality of agent execution trajectories - the sequence of decisions and actions an agent takes. These evaluators are good options for validating that agents follow expected execution behaviors when standard trajectory evaluators do not weigh specific mistakes too well or are too hard to configure. However, the recommended practice for most use cases involves acquiring comprehensive trajectory annotations and adopting deterministic trajectory evaluators.
+
+## Overview
+
+We provide two variants of LLM Judge Trajectory Evaluators:
+
+1. **LLM Judge Trajectory Evaluator** (`llm-judge-trajectory-similarity`): General trajectory evaluation
+2. **LLM Judge Trajectory Simulation Evaluator** (`llm-judge-trajectory-simulation`): Specialized for tool simulation scenarios
+
+**Use Cases**:
+
+-   Validate agent decision-making processes
+-   Ensure agents follow expected execution paths
+-   Evaluate tool usage patterns and sequencing
+-   Assess agent behavior in complex scenarios
+-   Validate tool simulation accuracy (where tool responses are mocked)
+
+**Returns**: Continuous score from 0.0 to 1.0 with `LLMJudgeJustification` containing `expected`, `actual`, and `justification` fields
+
+## LLM Service Integration
+
+LLM Judge evaluators require an LLM service to perform evaluations. By default, the evaluators use the **UiPathLlmService** to handle LLM requests, which automatically integrates with your configured LLM providers through the UiPath platform.
+
+### Custom LLM Service
+
+You can supply a custom LLM service that supports the following request format:
+
+```python
+{
+    "model": "model-name",
+    "messages": [
+        {"role": "system", "content": "system prompt"},
+        {"role": "user", "content": "evaluation prompt"}
+    ],
+    "response_format": {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "evaluation_response",
+            "schema": {
+                # JSON schema for structured output
+            }
+        }
+    },
+    "max_tokens": 1000,  # or None
+    "temperature": 0.0
+}
+```
+
+The LLM service must:
+
+- Accept messages with `system` and `user` roles
+- Support structured output via `response_format` with JSON schema
+- Return responses conforming to the specified schema
+- Handle `temperature` and `max_tokens` parameters
+
+### Model Selection
+
+When configuring the evaluator, specify the model name according to your LLM service's conventions:
+
+```python
+evaluator = LLMJudgeTrajectoryEvaluator(
+    id="trajectory-judge-1",
+    config={
+        "name": "LLMJudgeTrajectoryEvaluator",
+        "model": "gpt-4o-2024-11-20",  # Use your service's model naming
+        "temperature": 0.0
+    }
+)
+```
+
+!!! note "UiPathLlmService"
+    The default `UiPathLlmService` supports multiple LLM providers configured through the UiPath platform. Model names follow the provider's conventions (e.g., `gpt-4o-2024-11-20` for OpenAI, `claude-3-5-sonnet-20241022` for Anthropic).
+
+## LLM Judge Trajectory Evaluator
+
+### Configuration
+
+#### LLMJudgeTrajectoryEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"LLMJudgeTrajectoryEvaluator"` | The evaluator's name |
+| `prompt` | `str` | Default trajectory prompt | Custom evaluation prompt |
+| `model` | `str` | `""` | LLM model to use for judgment |
+| `temperature` | `float` | `0.0` | LLM temperature (0.0 for deterministic) |
+| `max_tokens` | `int or None` | `None` | Maximum tokens for LLM response |
+| `default_evaluation_criteria` | `TrajectoryEvaluationCriteria or None` | `None` | Default criteria |
+
+### Evaluation Criteria
+
+#### TrajectoryEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `expected_agent_behavior` | `str` | Description of the expected agent behavior |
+
+### Prompt Placeholders
+
+The prompt template supports these placeholders:
+
+- `{{AgentRunHistory}}`: The agent's execution trace/trajectory
+- `{{ExpectedAgentBehavior}}`: The expected behavior description
+- `{{UserOrSyntheticInput}}`: The input provided to the agent
+- `{{SimulationInstructions}}`: Tool simulation instructions specifying how tools should respond (for simulation variant only)
+
+### Examples
+
+#### Basic Trajectory Evaluation
+
+```python
+from uipath.eval.evaluators import LLMJudgeTrajectoryEvaluator
+from uipath.eval.models import AgentExecution
+
+agent_execution = AgentExecution(
+    agent_input={"user_query": "Book a flight to Paris"},
+    agent_output={"booking_id": "FL123", "status": "confirmed"},
+    agent_trace=[
+        # Trace contains spans showing the agent's execution path
+        # Each span represents a step in the agent's decision-making
+    ]
+)
+
+evaluator = LLMJudgeTrajectoryEvaluator(
+    id="trajectory-judge-1",
+    config={
+        "name": "LLMJudgeTrajectoryEvaluator",
+        # Use the UiPathLlmChatService convention for model names; this should be changed according to selected service
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_agent_behavior": """
+        The agent should:
+        1. Search for available flights to Paris
+        2. Present options to the user
+        3. Process the booking
+        4. Confirm the reservation
+        """
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+#### Validating Tool Usage Sequence
+
+```python
+agent_execution = AgentExecution(
+    agent_input={"task": "Update user profile and send notification"},
+    agent_output={"status": "completed"},
+    agent_trace=[
+        # Spans showing: validate_user -> update_profile -> send_notification
+    ]
+)
+
+evaluator = LLMJudgeTrajectoryEvaluator(
+    id="trajectory-tools",
+    config={
+        "name": "LLMJudgeTrajectoryEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_agent_behavior": """
+        The agent must:
+        1. First validate the user exists
+        2. Update the profile in the database
+        3. Send a confirmation notification
+        This sequence must be followed to ensure data integrity.
+        """
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+#### Custom Evaluation Prompt
+
+```python
+custom_prompt = """
+Analyze the agent's execution path and compare it with the expected behavior.
+
+Agent Run History:
+{{AgentRunHistory}}
+
+Expected Agent Behavior:
+{{ExpectedAgentBehavior}}
+
+User Input:
+{{UserOrSyntheticInput}}
+
+Evaluate:
+1. Did the agent follow the expected sequence?
+2. Were all necessary steps completed?
+3. Was the decision-making logical and efficient?
+
+Provide a score from 0-100.
+"""
+
+evaluator = LLMJudgeTrajectoryEvaluator(
+    id="trajectory-custom",
+    config={
+        "name": "LLMJudgeTrajectoryEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "prompt": custom_prompt,
+        "temperature": 0.0
+    }
+)
+
+# ... use evaluator
+```
+
+## LLM Judge Trajectory Simulation Evaluator
+
+This variant is specialized for evaluating agent behavior in **tool simulation scenarios**, where tool responses are mocked/simulated during agent execution.
+
+### What is Tool Simulation?
+
+In tool simulation:
+
+1. **Simulation Engine**: Mocks tool responses based on simulation instructions
+2. **Agent Unawareness**: The agent doesn't know tool responses are simulated
+3. **Controlled Testing**: Allows testing agent behavior with predictable tool responses
+4. **Evaluation Focus**: Assesses whether the agent behaves correctly given the simulated tool responses
+
+The evaluator checks if:
+- The simulation was successful (tools responded as instructed)
+- The agent behaved according to expectations given the simulated responses
+- The agent's decision-making aligns with expected behavior in the simulated scenario
+
+### Configuration
+
+#### LLMJudgeTrajectorySimulationEvaluatorConfig
+
+Same as `LLMJudgeTrajectoryEvaluatorConfig` but with:
+
+- **name**: `"LLMJudgeTrajectorySimulationEvaluator"`
+- **prompt**: Specialized prompt for tool simulation evaluation that considers:
+  - Simulation instructions (how tools should respond)
+  - Whether the simulated tool responses matched instructions
+  - Agent behavior given the simulated responses
+
+### Examples
+
+#### Tool Simulation Trajectory Evaluation
+
+```python
+from uipath.eval.evaluators import LLMJudgeTrajectorySimulationEvaluator
+
+agent_execution = AgentExecution(
+    agent_input={"query": "Book a flight to Paris for tomorrow"},
+    agent_output={"booking_id": "FL123", "status": "confirmed"},
+    agent_trace=[
+        # Execution spans showing tool calls and their simulated responses
+    ],
+    simulation_instructions="""
+    Simulate the following tool responses:
+    - search_flights tool: Return 3 available flights with prices
+    - book_flight tool: Return booking confirmation with ID "FL123"
+    - send_confirmation_email tool: Return success status
+    Mock the tools to respond as if it's a Tuesday in March with normal availability.
+    """
+)
+
+evaluator = LLMJudgeTrajectorySimulationEvaluator(
+    id="sim-trajectory-1",
+    config={
+        "name": "LLMJudgeTrajectorySimulationEvaluator",
+        "model": "gpt-4o-2024-11-20",
+        "temperature": 0.0
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "expected_agent_behavior": """
+        The agent should:
+        1. Call search_flights to find available options
+        2. Present flight options to the user (simulated in conversation)
+        3. Call book_flight with appropriate parameters
+        4. Confirm the booking with the user
+        5. Call send_confirmation_email to notify the user
+        """
+    }
+)
+
+print(f"Score: {result.score}")
+print(f"Justification: {result.details}")
+```
+
+## Understanding Agent Traces
+
+The `agent_trace` contains execution spans that show:
+
+- Tool calls made by the agent
+- LLM reasoning steps
+- Decision points
+- Action sequences
+- Intermediate results
+
+Example trace structure:
+```python
+agent_trace = [
+    {
+        "name": "search_flights",
+        "type": "tool",
+        "inputs": {"destination": "Paris"},
+        "output": {"flights": [...]}
+    },
+    {
+        "name": "llm_reasoning",
+        "type": "llm",
+        "content": "User wants cheapest option..."
+    },
+    {
+        "name": "book_flight",
+        "type": "tool",
+        "inputs": {"flight_id": "FL123"},
+        "output": {"status": "confirmed"}
+    }
+]
+```
+
+## Best Practices
+
+1. **Write clear behavior descriptions** - Be specific about expected sequences and decision logic
+2. **Use temperature 0.0** for consistent evaluations
+3. **Include context** - Provide enough detail in expected behavior
+4. **Consider partial credit** - LLM can give partial scores for mostly correct trajectories
+5. **Review justifications** - Understand why trajectories scored high or low
+6. **Combine with tool evaluators** - Use [Tool Call Evaluators](tool_call_order.md) for strict ordering requirements
+
+## When to Use vs Other Evaluators
+
+**Use LLM Judge Trajectory when**:
+- Decision-making process matters more than just output
+- Agent behavior patterns need validation
+- Tool usage sequence is complex but somewhat flexible
+- Human-like judgment of execution quality is needed
+
+**Use Tool Call Evaluators when**:
+- Strict tool call sequences must be enforced
+- Deterministic validation is sufficient
+- Exact argument values must match
+- Performance and cost are priorities
+
+## Configuration Tips
+
+### Temperature Settings
+
+- **0.0**: Deterministic, consistent results (recommended)
+- **0.1**: Slight variation for nuanced judgment
+- **>0.3**: Not recommended (too inconsistent)
+
+## Evaluation Criteria Guidelines
+
+When writing `expected_agent_behavior`, include:
+
+1. **Sequential steps**: Numbered or ordered list of expected actions
+2. **Decision points**: When the agent should make choices
+3. **Conditional logic**: "If X, then Y" scenarios
+4. **Success criteria**: What constitutes good behavior
+5. **Error handling**: How agent should handle failures
+
+### Good Example
+
+```python
+evaluation_criteria = {
+    "expected_agent_behavior": """
+    The agent should follow this sequence:
+
+    1. Validate user authentication status
+       - If not authenticated, request login
+       - If authenticated, proceed to step 2
+
+    2. Fetch user's order history
+       - Use the get_orders tool with user_id
+
+    3. Identify the problematic order
+       - Search for orders with "delayed" status
+
+    4. Provide explanation to user
+       - Include order details and delay reason
+
+    5. Offer resolution
+       - Present refund or expedited shipping options
+
+    The agent should maintain a helpful tone throughout
+    and adapt responses based on user reactions.
+    """
+}
+```
+
+### Poor Example (Too Vague)
+
+```python
+evaluation_criteria = {
+    "expected_agent_behavior": "Help the user with their order problem"
+}
+```
+
+## Error Handling
+
+The evaluator will raise `UiPathEvaluationError` if:
+
+- LLM service is unavailable
+- Prompt doesn't contain required placeholders
+- Agent trace cannot be converted to readable format
+- LLM response cannot be parsed
+
+## Performance Considerations
+
+- **Token usage**: Trajectories can be long, increasing token costs
+- **Evaluation time**: LLM calls take longer than deterministic evaluators
+- **Caching**: Consider caching evaluations for repeated test runs
+- **Batch processing**: Evaluate multiple trajectories in parallel when possible
+
+## Related Evaluators
+
+- [LLM Judge Output Evaluator](llm_judge_output.md): For evaluating outputs instead of processes
+- [Tool Call Order Evaluator](tool_call_order.md): For strict deterministic sequence validation
+- [Tool Call Count Evaluator](tool_call_count.md): For validating tool usage frequencies
+- [Tool Call Args Evaluator](tool_call_args.md): For validating tool arguments
+
+
diff --git a/packages/uipath/docs/eval/tool_call_args.md b/packages/uipath/docs/eval/tool_call_args.md
new file mode 100644
index 000000000..ced1c63fd
--- /dev/null
+++ b/packages/uipath/docs/eval/tool_call_args.md
@@ -0,0 +1,525 @@
+# Tool Call Args Evaluator
+
+The Tool Call Args Evaluator validates that an agent calls tools with the correct arguments. This is essential for ensuring proper data flow, correct API usage, and validating that agents pass the right information to functions.
+
+## Overview
+
+**Evaluator ID**: `tool-call-args`
+
+**Use Cases**:
+
+-   Validate tool parameters are correct
+-   Ensure proper data flow between tools
+-   Test argument transformation logic
+-   Verify API parameter usage
+-   Check data type correctness
+
+**Returns**: Continuous score from 0.0 to 1.0 based on argument accuracy
+
+## Configuration
+
+### ToolCallArgsEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ToolCallArgsEvaluator"` | The evaluator's name |
+| `strict` | `bool` | `False` | Controls scoring when multiple tools expected: True = all-or-nothing (1.0 or 0.0), False = proportional (ratio of matched tools) |
+| `subset` | `bool` | `False` | If True, actual args can be a subset of expected; if False, must match all expected args |
+| `default_evaluation_criteria` | `ToolCallArgsEvaluationCriteria or None` | `None` | Default criteria |
+
+### Evaluation Modes
+
+| Mode | Description |
+|------|-------------|
+| `strict=False, subset=False` | Proportional scoring (e.g., 2/3 tools matched = 0.66), exact arg matching required |
+| `strict=True, subset=False` | All-or-nothing scoring (1.0 or 0.0), exact arg matching required |
+| `strict=False, subset=True` | Proportional scoring, expected args must be subset of actual (extra args allowed) |
+| `strict=True, subset=True` | All-or-nothing scoring, expected args must be subset of actual (extra args allowed) |
+
+## Evaluation Criteria
+
+### ToolCallArgsEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tool_calls` | `list[ToolCall]` | List of expected tool calls with their arguments |
+
+### ToolCall Structure
+
+```python
+{
+    "name": "tool_name",           # Tool name
+    "args": {"key": "value"}  # Expected arguments
+}
+```
+
+## Scoring Algorithm
+
+For each tool call:
+1. Match tool calls by name
+2. Compare arguments based on mode (strict or JSON similarity)
+3. Calculate score based on match quality
+
+**Final score**: Average across all expected tool calls
+
+## Examples
+
+### Basic Argument Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallArgsEvaluator
+from uipath.eval.models import AgentExecution
+
+# Sample agent execution with tool calls and arguments
+mock_spans = [
+    ReadableSpan(
+        name="update_user",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "update_user",
+            "input.value": "{'user_id': 123, 'fields': {'email': 'user@example.com'}, 'notify': True}",
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"user_id": 123, "action": "update"},
+    agent_output={"status": "success"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-check-1",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": False,
+        "subset": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "update_user",
+                "args": {
+                    "user_id": 123,
+                    "fields": {"email": "user@example.com"},
+                    "notify": True
+                }
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (exact match)
+print(f"Details: {result.details}")
+```
+
+### Strict Mode - Exact Matching
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="api_request",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "api_request",
+            "input.value": "{'endpoint': '/api/users', 'method': 'GET', 'headers': {'Authorization': 'Bearer token123'}}",
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"action": "fetch_users"},
+    agent_output={"status": "success"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-strict",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": True,
+        "subset": False
+    }
+)
+
+# Arguments must match exactly
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "api_request",
+                "args": {
+                    "endpoint": "/api/users",
+                    "method": "GET",
+                    "headers": {"Authorization": "Bearer token123"}
+                }
+            }
+        ]
+    }
+)
+
+# Score is 1.0 only if arguments match exactly
+print(f"Score: {result.score}")  # 1.0
+```
+
+### Non-Strict Mode - Proportional Scoring
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallArgsEvaluator
+from uipath.eval.models import AgentExecution
+
+# Agent called 3 tools, but only 2 match the expected args
+mock_spans = [
+    ReadableSpan(
+        name="validate_input",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "validate_input",
+            "input.value": "{'data': {'user_id': 123}}",  # ✓ Matches
+        },
+    ),
+    ReadableSpan(
+        name="fetch_user",
+        start_time=1,
+        end_time=2,
+        attributes={
+            "tool.name": "fetch_user",
+            "input.value": "{'user_id': 999}",  # ✗ Wrong ID!
+        },
+    ),
+    ReadableSpan(
+        name="update_profile",
+        start_time=2,
+        end_time=3,
+        attributes={
+            "tool.name": "update_profile",
+            "input.value": "{'user_id': 123, 'updates': {'name': 'John Doe'}}",  # ✓ Matches
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Update user profile"},
+    agent_output={"status": "updated"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-proportional",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": False,  # Proportional scoring
+        "subset": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "validate_input",
+                "args": {"data": {"user_id": 123}}  # ✓ Matches
+            },
+            {
+                "name": "fetch_user",
+                "args": {"user_id": 123}  # ✗ Actual was 999
+            },
+            {
+                "name": "update_profile",
+                "args": {
+                    "user_id": 123,
+                    "updates": {"name": "John Doe"}  # ✓ Matches
+                }
+            }
+        ]
+    }
+)
+
+# Score is 2/3 = 0.66 (2 out of 3 tools matched)
+print(f"Score: {result.score}")  # 0.66 (proportional!)
+```
+
+### Subset Mode - Partial Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent included extra arguments beyond what we're validating
+mock_spans = [
+    ReadableSpan(
+        name="send_email",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "send_email",
+            "input.value": "{'to': 'user@example.com', 'subject': 'Welcome', 'cc': 'admin@example.com', 'body': 'Welcome to our platform!'}",
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"action": "send_welcome"},
+    agent_output={"status": "sent"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-subset",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": False,
+        "subset": True
+    }
+)
+
+# Only validate specific arguments, allow extras
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "send_email",
+                "args": {
+                    "to": "user@example.com",
+                    "subject": "Welcome"
+                    # Agent can include additional args like "cc", "bcc", "body", etc.
+                }
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (subset matches)
+```
+
+### Multiple Tool Calls
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent called multiple tools in sequence
+mock_spans = [
+    ReadableSpan(
+        name="validate_input",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "validate_input",
+            "input.value": "{'data': {'user_id': 123}}",
+        },
+    ),
+    ReadableSpan(
+        name="fetch_user",
+        start_time=1,
+        end_time=2,
+        attributes={
+            "tool.name": "fetch_user",
+            "input.value": "{'user_id': 123}",
+        },
+    ),
+    ReadableSpan(
+        name="update_profile",
+        start_time=2,
+        end_time=3,
+        attributes={
+            "tool.name": "update_profile",
+            "input.value": "{'user_id': 123, 'updates': {'name': 'John Doe'}}",
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Update user profile"},
+    agent_output={"status": "updated"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-multiple",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": False,
+        "subset": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "validate_input",
+                "args": {"data": {"user_id": 123}}
+            },
+            {
+                "name": "fetch_user",
+                "args": {"user_id": 123}
+            },
+            {
+                "name": "update_profile",
+                "args": {
+                    "user_id": 123,
+                    "updates": {"name": "John Doe"}
+                }
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (all tools match)
+```
+
+### Nested Arguments
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="create_order",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "create_order",
+            "input.value": "{'customer': {'id': 123, 'name': 'John Doe', 'address': {'street': '123 Main St', 'city': 'New York', 'zip': '10001'}}, 'items': [{'product_id': 1, 'quantity': 2}, {'product_id': 2, 'quantity': 1}], 'total': 99.99}",
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Create order"},
+    agent_output={"status": "created"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallArgsEvaluator(
+    id="args-nested",
+    config={
+        "name": "ToolCallArgsEvaluator",
+        "strict": False,
+        "subset": False
+    }
+)
+
+# Validate complex nested structures
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls": [
+            {
+                "name": "create_order",
+                "args": {
+                    "customer": {
+                        "id": 123,
+                        "name": "John Doe",
+                        "address": {
+                            "street": "123 Main St",
+                            "city": "New York",
+                            "zip": "10001"
+                        }
+                    },
+                    "items": [
+                        {"product_id": 1, "quantity": 2},
+                        {"product_id": 2, "quantity": 1}
+                    ],
+                    "total": 99.99
+                }
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (nested structure matches)
+```
+
+## Justification Details
+
+The evaluator returns a `ToolCallArgsEvaluatorJustification` with:
+
+```python
+{
+    "explained_tool_calls_args": {
+        "update_user_0": "Actual: {'user_id': 123, 'status': 'active'}, Expected: {'user_id': 123, 'status': 'active'}, Score: 1.0",
+        "send_email_0": "Actual: {'to': 'user@example.com', 'subject': 'Hello'}, Expected: {'to': 'user@example.com'}, Score: 1.0",
+        "log_event_0": "Actual: {'type': 'info', 'message': 'Success'}, Expected: {'type': 'info'}, Score: 1.0"
+    }
+}
+```
+
+## Best Practices
+
+1. **Use non-strict mode by default** - Allows for minor numeric or string variations
+2. **Use subset mode for flexibility** - When some arguments are optional or variable
+3. **Combine with order validation** - Use with [Tool Call Order Evaluator](tool_call_order.md)
+4. **Test critical parameters in strict mode** - For security, authentication, or business-critical params
+5. **Validate data types** - Ensure strings, numbers, booleans are used correctly
+6. **Test edge cases** - Empty strings, null values, zero, negative numbers
+7. **Consider partial matches** - Non-strict mode gives partial credit for similar values
+
+## When to Use vs Other Evaluators
+
+**Use Tool Call Args when**:
+
+- Argument values matter
+- Testing data flow correctness
+- Validating parameter transformation
+- Ensuring API contract compliance
+
+**Use Tool Call Order when**:
+
+- Sequence matters more than arguments
+- Testing workflow steps
+
+**Use Tool Call Output when**:
+
+- Validating what tools return
+- Testing tool response handling
+
+**Use JSON Similarity when**:
+
+- Comparing complex outputs (not tool args)
+- General data structure comparison
+
+## Limitations
+
+1. **Tool name matching** - Must match exact tool names from trace
+2. **Order matters for multiple calls** - First expected call matches first actual call of that name
+3. **No cross-tool validation** - Each tool evaluated independently
+4. **Case-sensitive** - Keys and values are case-sensitive
+
+## Error Handling
+
+The evaluator handles:
+
+- **Missing tools**: Score 0.0 for that tool
+- **Extra tools not in criteria**: Ignored
+- **Missing arguments**: Scored based on mode
+- **Type mismatches**: Scored based on mode (strict vs non-strict)
+
+## Performance Considerations
+
+- **Fast evaluation**: O(n*m) where n = expected calls, m = actual calls
+- **No LLM calls**: Deterministic and quick
+- **JSON similarity overhead**: Slightly slower than exact match
+
+## Related Evaluators
+
+- [Tool Call Order Evaluator](tool_call_order.md): Validates tool call sequences
+- [Tool Call Count Evaluator](tool_call_count.md): Validates tool usage frequencies
+- [Tool Call Output Evaluator](tool_call_output.md): Validates tool outputs
+- [JSON Similarity Evaluator](json_similarity.md): For general JSON comparison
+
+
diff --git a/packages/uipath/docs/eval/tool_call_count.md b/packages/uipath/docs/eval/tool_call_count.md
new file mode 100644
index 000000000..e72e30c2d
--- /dev/null
+++ b/packages/uipath/docs/eval/tool_call_count.md
@@ -0,0 +1,559 @@
+# Tool Call Count Evaluator
+
+The Tool Call Count Evaluator validates that an agent calls tools the expected number of times. This is useful for ensuring proper tool usage patterns, avoiding redundant calls, and verifying workflow completeness.
+
+## Overview
+
+**Evaluator ID**: `tool-call-count`
+
+**Use Cases**:
+
+-   Ensure tools are called the correct number of times
+-   Validate no redundant or missing tool calls
+-   Test resource usage efficiency
+-   Verify loop and retry logic
+-   Check API call frequency
+
+**Returns**: Continuous score from 0.0 to 1.0 based on count accuracy
+
+## Configuration
+
+### ToolCallCountEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ToolCallCountEvaluator"` | The evaluator's name |
+| `strict` | `bool` | `False` | Controls scoring: True = all-or-nothing (1.0 or 0.0), False = proportional (ratio of matched counts) |
+| `default_evaluation_criteria` | `ToolCallCountEvaluationCriteria or None` | `None` | Default criteria |
+
+### Strict vs Non-Strict Mode
+
+- **Strict mode** (`strict=True`): All-or-nothing - returns 1.0 if ALL counts match, 0.0 if ANY count doesn't match
+- **Non-strict mode** (`strict=False`): Proportional scoring - returns ratio of matched counts (e.g., 2/3 match = 0.66)
+
+## Evaluation Criteria
+
+### ToolCallCountEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tool_calls_count` | `dict[str, tuple[str, int]]` | Dictionary mapping tool names to (operator, count) tuples |
+
+### Supported Operators
+
+- `"="` or `"=="`: Exactly equal to count
+- `">"`: Greater than count
+- `"<"`: Less than count
+- `">="`: Greater than or equal to count
+- `"<="`: Less than or equal to count
+
+## Scoring Algorithm
+
+### Non-Strict Mode
+
+```
+score = correct_tools / total_expected_tools
+```
+
+Each tool is evaluated independently:
+- Correct count match = 1.0 for that tool
+- Incorrect count = 0.0 for that tool
+- Final score is average across all tools
+
+### Strict Mode
+
+- Returns `1.0` if ALL tools match their count criteria
+- Returns `0.0` if ANY tool fails its count criteria
+
+## Examples
+
+### Basic Count Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallCountEvaluator
+from uipath.eval.models import AgentExecution
+
+# Sample agent execution with tool calls
+mock_spans = [
+    ReadableSpan(name="fetch_data", start_time=0, end_time=1,
+                 attributes={"tool.name": "fetch_data"}),
+    ReadableSpan(name="process_item", start_time=1, end_time=2,
+                 attributes={"tool.name": "process_item"}),
+    ReadableSpan(name="process_item", start_time=2, end_time=3,
+                 attributes={"tool.name": "process_item"}),
+    ReadableSpan(name="process_item", start_time=3, end_time=4,
+                 attributes={"tool.name": "process_item"}),
+    ReadableSpan(name="process_item", start_time=4, end_time=5,
+                 attributes={"tool.name": "process_item"}),
+    ReadableSpan(name="process_item", start_time=5, end_time=6,
+                 attributes={"tool.name": "process_item"}),
+    ReadableSpan(name="send_notification", start_time=6, end_time=7,
+                 attributes={"tool.name": "send_notification"}),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Fetch and process data"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="count-check-1",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "fetch_data": ("=", 1),      # Called exactly once
+            "process_item": ("=", 5),    # Called exactly 5 times
+            "send_notification": ("=", 1)  # Called exactly once
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (all counts match)
+print(f"Details: {result.details}")
+```
+
+### Non-Strict Mode - Proportional Scoring
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent called fetch_data 1x, process_item 3x (expected 5), send_notification 1x
+mock_spans = [
+    ReadableSpan(
+        name="fetch_data",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "fetch_data"},
+    ),
+]
+# Add 3 process_item calls (but we expect 5)
+for i in range(3):
+    mock_spans.append(
+        ReadableSpan(
+            name="process_item",
+            start_time=1 + i,
+            end_time=2 + i,
+            attributes={"tool.name": "process_item"},
+        )
+    )
+mock_spans.append(
+    ReadableSpan(
+        name="send_notification",
+        start_time=4,
+        end_time=5,
+        attributes={"tool.name": "send_notification"},
+    )
+)
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Fetch and process data"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="count-proportional",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False  # Proportional scoring
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "fetch_data": ("=", 1),           # ✓ Matches (1 call)
+            "process_item": ("=", 5),         # ✗ Doesn't match (3 calls, expected 5)
+            "send_notification": ("=", 1)     # ✓ Matches (1 call)
+        }
+    }
+)
+
+# Score is 2/3 = 0.66 (2 out of 3 counts matched)
+print(f"Score: {result.score}")  # 0.66 (proportional!)
+```
+
+### Strict Mode - All or Nothing
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent made 2 calls but expected 1
+mock_spans = [
+    ReadableSpan(
+        name="authenticate",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "authenticate"},
+    ),
+    ReadableSpan(
+        name="fetch_records",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "fetch_records"},
+    ),
+    ReadableSpan(
+        name="fetch_records",  # DUPLICATE call
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "fetch_records"},
+    ),
+    ReadableSpan(
+        name="close_connection",
+        start_time=3,
+        end_time=4,
+        attributes={"tool.name": "close_connection"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Database operation"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="count-strict",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": True  # All-or-nothing scoring
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "authenticate": ("=", 1),      # ✓ Matches (1 call)
+            "fetch_records": ("=", 1),     # ✗ Doesn't match (2 calls)
+            "close_connection": ("=", 1)   # ✓ Matches (1 call)
+        }
+    }
+)
+
+# Score is 0.0 because ONE count didn't match (strict mode)
+print(f"Score: {result.score}")  # 0.0 (not 0.66!)
+```
+
+### Preventing Redundant Calls
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Only one expensive call
+mock_spans = [
+    ReadableSpan(
+        name="expensive_api_call",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "expensive_api_call"},
+    ),
+    ReadableSpan(
+        name="database_query",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "database_query"},
+    ),
+    ReadableSpan(
+        name="database_query",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "database_query"},
+    ),
+    ReadableSpan(
+        name="llm_call",
+        start_time=3,
+        end_time=4,
+        attributes={"tool.name": "llm_call"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Optimize resource usage"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="prevent-redundant",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False
+    }
+)
+
+# Ensure expensive operations aren't called too many times
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "expensive_api_call": ("<=", 1),  # Should not be called more than once
+            "database_query": ("<=", 3),      # At most 3 queries
+            "llm_call": ("<=", 2)             # At most 2 LLM calls
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (all within limits)
+```
+
+### Loop Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Create 10 process_item, 10 validate_item, 10 save_result calls
+mock_spans = []
+for i in range(10):
+    mock_spans.extend([
+        ReadableSpan(
+            name="process_item",
+            start_time=i * 3,
+            end_time=i * 3 + 1,
+            attributes={"tool.name": "process_item"},
+        ),
+        ReadableSpan(
+            name="validate_item",
+            start_time=i * 3 + 1,
+            end_time=i * 3 + 2,
+            attributes={"tool.name": "validate_item"},
+        ),
+        ReadableSpan(
+            name="save_result",
+            start_time=i * 3 + 2,
+            end_time=i * 3 + 3,
+            attributes={"tool.name": "save_result"},
+        ),
+    ])
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Process 10 items"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="loop-validation",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False
+    }
+)
+
+# Verify loop processed correct number of items
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "process_item": ("=", 10),  # Should process 10 items
+            "validate_item": ("=", 10), # Each item should be validated
+            "save_result": ("=", 10)    # Each result should be saved
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (all counts correct)
+```
+
+### Retry Logic Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent attempted operation 2 times, logged retry, got final result
+mock_spans = [
+    ReadableSpan(
+        name="attempt_operation",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "attempt_operation"},
+    ),
+    ReadableSpan(
+        name="log_retry",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "log_retry"},
+    ),
+    ReadableSpan(
+        name="attempt_operation",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "attempt_operation"},
+    ),
+    ReadableSpan(
+        name="final_result",
+        start_time=3,
+        end_time=4,
+        attributes={"tool.name": "final_result"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Retry operation"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="retry-logic",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False
+    }
+)
+
+# Verify retry logic doesn't exceed limits
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "attempt_operation": ("<=", 3),  # Max 3 retries
+            "log_retry": (">=", 1),          # Should log retries
+            "final_result": ("=", 1)         # Only one final result
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (retry logic correct)
+```
+
+### Ensuring Minimum Calls
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Agent called all required security checks
+mock_spans = [
+    ReadableSpan(
+        name="validate_input",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "validate_input"},
+    ),
+    ReadableSpan(
+        name="check_security",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "check_security"},
+    ),
+    ReadableSpan(
+        name="audit_log",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "audit_log"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Secure operation"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallCountEvaluator(
+    id="minimum-calls",
+    config={
+        "name": "ToolCallCountEvaluator",
+        "strict": False
+    }
+)
+
+# Ensure agent calls important tools
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_count": {
+            "validate_input": (">=", 1),    # Must validate at least once
+            "check_security": (">=", 1),    # Security check required
+            "audit_log": (">", 0)           # Must create audit logs
+        }
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (minimum calls met)
+```
+
+## Justification Details
+
+The evaluator returns a `ToolCallCountEvaluatorJustification` with:
+
+```python
+{
+    "explained_tool_calls_count": {
+        "fetch_data": "Actual: 1, Expected: 1, Score: 1.0",
+        "process_item": "Actual: 3, Expected: 5, Score: 0.0",
+        "send_notification": "Actual: 1, Expected: 1, Score: 1.0"
+    }
+}
+```
+
+## Best Practices
+
+1. **Use for resource-sensitive operations** - Database queries, API calls, expensive computations
+2. **Combine with order validation** - Use with [Tool Call Order Evaluator](tool_call_order.md) for complete validation
+3. **Set realistic bounds** - Use `<=` and `>=` for flexible but bounded behavior
+4. **Use strict mode sparingly** - Non-strict provides better debugging information
+5. **Consider variability** - Use ranges (`>=`, `<=`) when exact counts might vary
+6. **Test efficiency** - Ensure agents don't make redundant calls
+
+## When to Use vs Other Evaluators
+
+**Use Tool Call Count when**:
+
+- Tool usage frequency matters
+- Testing efficiency and optimization
+- Validating retry logic
+- Ensuring resource constraints
+
+**Use Tool Call Order when**:
+
+- Sequence matters more than count
+- Workflow has specific steps
+- Dependencies exist between tools
+
+**Use Tool Call Args when**:
+
+- Tool parameters need validation
+- Specific argument values matter
+- Testing data flow through tools
+
+## Limitations
+
+1. **Case-sensitive tool names** - Must match exactly
+2. **No temporal information** - Doesn't know when calls happened
+3. **No context awareness** - Doesn't understand why counts differ
+4. **All tools independent** - Each tool evaluated separately
+
+## Error Handling
+
+The evaluator handles:
+
+- **Missing tools in actual calls**: Count as 0
+- **Extra tools not in criteria**: Ignored
+- **Invalid operators**: Raises validation error
+- **Negative counts**: Raises validation error
+
+## Performance Considerations
+
+- **Fast evaluation**: O(n) where n is number of tools
+- **No LLM calls**: Deterministic and instant
+- **Low memory**: Efficient for large call counts
+
+## Related Evaluators
+
+- [Tool Call Order Evaluator](tool_call_order.md): Validates tool call sequences
+- [Tool Call Args Evaluator](tool_call_args.md): Validates tool arguments
+- [Tool Call Output Evaluator](tool_call_output.md): Validates tool outputs
+- [LLM Judge Trajectory Evaluator](llm_judge_trajectory.md): For semantic evaluation
+
+
diff --git a/packages/uipath/docs/eval/tool_call_order.md b/packages/uipath/docs/eval/tool_call_order.md
new file mode 100644
index 000000000..886f8be41
--- /dev/null
+++ b/packages/uipath/docs/eval/tool_call_order.md
@@ -0,0 +1,490 @@
+# Tool Call Order Evaluator
+
+The Tool Call Order Evaluator validates that an agent calls tools in the expected sequence. This is crucial for workflows where the order of operations matters for correctness, data integrity, or business logic.
+
+## Overview
+
+**Evaluator ID**: `tool-call-order`
+
+**Use Cases**:
+
+-   Validate critical operation sequences (e.g., authenticate before access)
+-   Ensure workflow steps follow business logic
+-   Test that agents follow prescribed procedures
+-   Verify proper data pipeline execution order
+
+**Returns**: Continuous score from 0.0 to 1.0 based on sequence match
+
+## Configuration
+
+### ToolCallOrderEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ToolCallOrderEvaluator"` | The evaluator's name |
+| `strict` | `bool` | `False` | If True, requires exact sequence match; if False, uses LCS (Longest Common Subsequence) |
+| `default_evaluation_criteria` | `ToolCallOrderEvaluationCriteria or None` | `None` | Default criteria |
+
+### Strict vs Non-Strict Mode
+
+- **Strict mode** (`strict=True`): Requires exact sequence match, score is 1.0 or 0.0
+- **Non-strict mode** (`strict=False`): Uses LCS algorithm, allows partial credit for subsequences
+
+## Evaluation Criteria
+
+### ToolCallOrderEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tool_calls_order` | `list[str]` | Ordered list of expected tool names |
+
+## Scoring Algorithm
+
+### Non-Strict Mode (LCS-based)
+
+The score is calculated as:
+
+```
+score = length(LCS) / length(expected_sequence)
+```
+
+Where LCS is the Longest Common Subsequence between expected and actual tool call sequences.
+
+**Example**:
+- Expected: `["A", "B", "C", "D"]`
+- Actual: `["A", "X", "B", "D"]`
+- LCS: `["A", "B", "D"]` (length 3)
+- Score: `3/4 = 0.75`
+
+### Strict Mode
+
+- Returns `1.0` if sequences match exactly
+- Returns `0.0` if any difference exists
+
+## Examples
+
+### Basic Tool Call Order Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallOrderEvaluator
+from uipath.eval.models import AgentExecution
+
+# Create mock spans representing tool calls in execution trace
+mock_spans = [
+    ReadableSpan(
+        name="validate_user",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "validate_user"},
+    ),
+    ReadableSpan(
+        name="check_inventory",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "check_inventory"},
+    ),
+    ReadableSpan(
+        name="create_order",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "create_order"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Process user order"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="order-check-1",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_order": [
+            "validate_user",
+            "check_inventory",
+            "create_order"
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (perfect match)
+print(f"Details: {result.details}")
+# Details includes: actual order, expected order, and LCS
+```
+
+### Strict Order Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Critical security sequence
+mock_spans = [
+    ReadableSpan(
+        name="authenticate_user",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "authenticate_user"},
+    ),
+    ReadableSpan(
+        name="verify_permissions",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "verify_permissions"},
+    ),
+    ReadableSpan(
+        name="access_resource",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "access_resource"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Access secured resource"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="order-strict",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": True
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_order": [
+            "authenticate_user",
+            "verify_permissions",
+            "access_resource"
+        ]
+    }
+)
+
+# Score is either 1.0 (perfect match) or 0.0 (any mismatch)
+print(f"Score: {result.score}")  # 1.0
+```
+
+### Partial Credit with LCS
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Actual execution (missing "sort")
+mock_spans = [
+    ReadableSpan(
+        name="search",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "search"},
+    ),
+    ReadableSpan(
+        name="filter",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "filter"},
+    ),
+    ReadableSpan(
+        name="display",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "display"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Search and display"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="order-lcs",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": False  # Use LCS for partial credit
+    }
+)
+
+# Expected sequence
+expected = ["search", "filter", "sort", "display"]
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_order": expected
+    }
+)
+
+# Score: 3/4 = 0.75 (3 tools in correct order out of 4 expected)
+print(f"Score: {result.score}")  # 0.75
+print(f"LCS: {result.details.lcs}")  # ["search", "filter", "display"]
+```
+
+### Database Transaction Sequence
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="begin_transaction",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "begin_transaction"},
+    ),
+    ReadableSpan(
+        name="validate_data",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "validate_data"},
+    ),
+    ReadableSpan(
+        name="update_records",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "update_records"},
+    ),
+    ReadableSpan(
+        name="commit_transaction",
+        start_time=3,
+        end_time=4,
+        attributes={"tool.name": "commit_transaction"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Update database"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="db-transaction",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": True  # Transactions must be exact
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_order": [
+            "begin_transaction",
+            "validate_data",
+            "update_records",
+            "commit_transaction"
+        ]
+    }
+)
+
+# Must match exactly for data integrity
+print(f"Score: {result.score}")  # 1.0
+```
+
+### API Integration Workflow
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="get_api_token",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "get_api_token"},
+    ),
+    ReadableSpan(
+        name="fetch_user_data",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "fetch_user_data"},
+    ),
+    ReadableSpan(
+        name="enrich_data",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "enrich_data"},
+    ),
+    ReadableSpan(
+        name="post_to_webhook",
+        start_time=3,
+        end_time=4,
+        attributes={"tool.name": "post_to_webhook"},
+    ),
+    ReadableSpan(
+        name="log_result",
+        start_time=4,
+        end_time=5,
+        attributes={"tool.name": "log_result"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "API integration"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="api-workflow",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_calls_order": [
+            "get_api_token",
+            "fetch_user_data",
+            "enrich_data",
+            "post_to_webhook",
+            "log_result"
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0
+```
+
+### Using Default Criteria
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="init",
+        start_time=0,
+        end_time=1,
+        attributes={"tool.name": "init"},
+    ),
+    ReadableSpan(
+        name="process",
+        start_time=1,
+        end_time=2,
+        attributes={"tool.name": "process"},
+    ),
+    ReadableSpan(
+        name="cleanup",
+        start_time=2,
+        end_time=3,
+        attributes={"tool.name": "cleanup"},
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Standard workflow"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOrderEvaluator(
+    id="order-default",
+    config={
+        "name": "ToolCallOrderEvaluator",
+        "strict": False,
+        "default_evaluation_criteria": {
+            "tool_calls_order": ["init", "process", "cleanup"]
+        }
+    }
+)
+
+# Use default criteria
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria=None  # Uses default
+)
+
+print(f"Score: {result.score}")  # 1.0
+```
+
+## Justification Details
+
+The evaluator returns a `ToolCallOrderEvaluatorJustification` (inherits from `BaseEvaluatorJustification`) with:
+
+```python
+{
+    "expected": "['tool1', 'tool2', 'tool3', 'tool4']",  # What was expected
+    "actual": "['tool1', 'tool2', 'tool3']",  # What the agent called
+    "lcs": ["tool1", "tool2", "tool3"]  # Longest common subsequence (non-strict mode)
+}
+```
+
+## Best Practices
+
+1. **Use strict mode for critical sequences** - Authentication, transactions, data integrity workflows
+2. **Use non-strict mode for flexible workflows** - When some steps might be optional or reorderable
+3. **Combine with other evaluators** - Use with [Tool Call Count](tool_call_count.md) and [Tool Call Args](tool_call_args.md)
+4. **Be specific with tool names** - Ensure tool names in criteria match exactly (case-sensitive)
+5. **Consider repeated calls** - If a tool should be called multiple times, list it multiple times
+6. **Test partial workflows** - Use non-strict mode during development, strict in production
+
+## When to Use vs Other Evaluators
+
+**Use Tool Call Order when**:
+
+- Sequence of operations is important
+- Workflow has defined steps
+- Business logic requires specific order
+- Data dependencies exist between steps
+
+**Use Tool Call Count when**:
+
+- Order doesn't matter, only frequency
+- Testing tool usage patterns
+- Ensuring tools are called correct number of times
+
+**Use LLM Judge Trajectory when**:
+
+- More flexible, semantic evaluation needed
+- Decision-making process is complex
+- Exact sequences are less important than overall behavior
+
+## Limitations
+
+1. **Case-sensitive matching** - Tool names must match exactly
+2. **No argument validation** - Only checks tool names, not arguments (use [Tool Call Args Evaluator](tool_call_args.md))
+3. **Position-based** - Doesn't consider parallel execution
+4. **Multiple calls** - Each call is treated as separate position in sequence
+
+## Error Handling
+
+The evaluator handles these scenarios gracefully:
+
+-   **Empty actual calls**: Score 0.0
+-   **Empty expected calls**: Error (invalid criteria)
+-   **Missing tools in trace**: Extracts only tool calls found
+-   **Extra tools called**: In non-strict mode, uses LCS; in strict mode, score 0.0
+
+## Performance Considerations
+
+-   **Fast evaluation**: O(n*m) for LCS algorithm
+-   **No LLM calls**: Deterministic and quick
+-   **Low memory**: Efficient for large sequences
+
+## Related Evaluators
+
+-   [Tool Call Count Evaluator](tool_call_count.md): Validates tool usage frequencies
+-   [Tool Call Args Evaluator](tool_call_args.md): Validates tool arguments
+-   [Tool Call Output Evaluator](tool_call_output.md): Validates tool outputs
+-   [LLM Judge Trajectory Evaluator](llm_judge_trajectory.md): For semantic trajectory evaluation
+
+
diff --git a/packages/uipath/docs/eval/tool_call_output.md b/packages/uipath/docs/eval/tool_call_output.md
new file mode 100644
index 000000000..9b3cd29f2
--- /dev/null
+++ b/packages/uipath/docs/eval/tool_call_output.md
@@ -0,0 +1,450 @@
+# Tool Call Output Evaluator
+
+The Tool Call Output Evaluator validates that tools return the expected outputs. This is crucial for testing tool integrations, verifying data transformations, and ensuring that agents correctly handle tool responses.
+
+## Overview
+
+**Evaluator ID**: `tool-call-output`
+
+**Use Cases**:
+
+-   Validate tool return values
+-   Test tool integration correctness
+-   Verify data processing results
+-   Ensure proper error handling
+-   Check API response handling
+
+**Returns**: Continuous score from 0.0 to 1.0 based on output accuracy
+
+## Configuration
+
+### ToolCallOutputEvaluatorConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | `str` | `"ToolCallOutputEvaluator"` | The evaluator's name |
+| `strict` | `bool` | `False` | Controls scoring when multiple tools expected: True = all-or-nothing (1.0 or 0.0), False = proportional (ratio of matched outputs) |
+| `default_evaluation_criteria` | `ToolCallOutputEvaluationCriteria or None` | `None` | Default criteria |
+
+### Evaluation Modes
+
+- **Strict mode** (`strict=True`): All-or-nothing - returns 1.0 if ALL outputs match, 0.0 if ANY output doesn't match
+- **Non-strict mode** (`strict=False`): Proportional scoring - returns ratio of matched outputs (e.g., 2/3 match = 0.66)
+
+## Evaluation Criteria
+
+### ToolCallOutputEvaluationCriteria
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tool_outputs` | `list[ToolOutput]` | List of expected tool outputs |
+
+### ToolOutput Structure
+
+```python
+{
+    "name": "tool_name",        # Tool name
+    "output": {...}             # Expected output value
+}
+```
+
+## Scoring Algorithm
+
+For each expected tool output:
+1. Find matching tool calls by name in the trace
+2. Compare actual output with expected output
+3. Use strict or JSON similarity comparison based on mode
+
+**Final score**: Average across all expected tool outputs
+
+## Examples
+
+### Basic Output Validation
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallOutputEvaluator
+from uipath.eval.models import AgentExecution
+
+# Sample agent execution with tool calls and outputs
+mock_spans = [
+    ReadableSpan(
+        name="get_user",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "get_user",
+            "output.value": '{"content": "{\\"user_id\\": 123, \\"name\\": \\"John Doe\\", \\"email\\": \\"john@example.com\\", \\"status\\": \\"active\\"}"}',
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"user_id": 123},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOutputEvaluator(
+    id="output-check-1",
+    config={
+        "name": "ToolCallOutputEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_outputs": [
+            {
+                "name": "get_user",
+                "output": '{"user_id": 123, "name": "John Doe", "email": "john@example.com", "status": "active"}'
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (exact match)
+print(f"Details: {result.details}")
+```
+
+### Strict Mode - Exact Output Matching
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="calculate_total",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "calculate_total",
+            "output.value": '{"content": "{\\"total\\": 99.99, \\"currency\\": \\"USD\\"}"}',
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"items": ["item1", "item2"]},
+    agent_output={"status": "calculated"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOutputEvaluator(
+    id="output-strict",
+    config={
+        "name": "ToolCallOutputEvaluator",
+        "strict": True
+    }
+)
+
+# Outputs must match exactly
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_outputs": [
+            {
+                "name": "calculate_total",
+                "output": {"total": 99.99, "currency": "USD"}
+            }
+        ]
+    }
+)
+
+# Score is 1.0 only if output matches exactly
+print(f"Score: {result.score}")  # 1.0
+```
+
+### Non-Strict Mode - Proportional Scoring
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+from uipath.eval.evaluators import ToolCallOutputEvaluator
+from uipath.eval.models import AgentExecution
+
+# Agent produced 3 outputs, but only 2 match expected
+mock_spans = [
+    ReadableSpan(
+        name="fetch_data",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "fetch_data",
+            "output.value": '{"content": "{\\"records\\": 150, \\"status\\": \\"success\\"}"}',  # ✓ Matches
+        },
+    ),
+    ReadableSpan(
+        name="process_data",
+        start_time=1,
+        end_time=2,
+        attributes={
+            "tool.name": "process_data",
+            "output.value": '{"content": "{\\"processed\\": 100, \\"errors\\": 5}"}',  # ✗ Wrong values
+        },
+    ),
+    ReadableSpan(
+        name="save_results",
+        start_time=2,
+        end_time=3,
+        attributes={
+            "tool.name": "save_results",
+            "output.value": '{"content": "{\\"saved\\": 150, \\"location\\": \\"/data/results.csv\\"}"}',  # ✓ Matches
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Process data pipeline"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOutputEvaluator(
+    id="output-proportional",
+    config={
+        "name": "ToolCallOutputEvaluator",
+        "strict": False  # Proportional scoring
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_outputs": [
+            {
+                "name": "fetch_data",
+                "output": '{"records": 150, "status": "success"}'  # ✓ Matches
+            },
+            {
+                "name": "process_data",
+                "output": '{"processed": 150, "errors": 0}'  # ✗ Actual had errors: 5
+            },
+            {
+                "name": "save_results",
+                "output": '{"saved": 150, "location": "/data/results.csv"}'  # ✓ Matches
+            }
+        ]
+    }
+)
+
+# Score is 2/3 = 0.66 (2 out of 3 outputs matched)
+print(f"Score: {result.score}")  # 0.66 (proportional!)
+```
+
+### Multiple Tool Outputs
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+# Multiple tools called in sequence
+mock_spans = [
+    ReadableSpan(
+        name="fetch_data",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "fetch_data",
+            "output.value": '{"content": "{\\"records\\": 150, \\"status\\": \\"success\\"}"}',
+        },
+    ),
+    ReadableSpan(
+        name="process_data",
+        start_time=1,
+        end_time=2,
+        attributes={
+            "tool.name": "process_data",
+            "output.value": '{"content": "{\\"processed\\": 150, \\"errors\\": 0}"}',
+        },
+    ),
+    ReadableSpan(
+        name="save_results",
+        start_time=2,
+        end_time=3,
+        attributes={
+            "tool.name": "save_results",
+            "output.value": '{"content": "{\\"saved\\": 150, \\"location\\": \\"/data/results.csv\\"}"}',
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Process data pipeline"},
+    agent_output={"status": "completed"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOutputEvaluator(
+    id="output-multiple",
+    config={
+        "name": "ToolCallOutputEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_outputs": [
+            {
+                "name": "fetch_data",
+                "output": {"records": 150, "status": "success"}
+            },
+            {
+                "name": "process_data",
+                "output": {"processed": 150, "errors": 0}
+            },
+            {
+                "name": "save_results",
+                "output": {"saved": 150, "location": "/data/results.csv"}
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (all outputs match)
+```
+
+### Complex Nested Outputs
+
+```python
+from opentelemetry.sdk.trace import ReadableSpan
+
+mock_spans = [
+    ReadableSpan(
+        name="generate_report",
+        start_time=0,
+        end_time=1,
+        attributes={
+            "tool.name": "generate_report",
+            "output.value": '{"content": "{\\"report_id\\": \\"RPT-001\\", \\"summary\\": {\\"total_records\\": 1000, \\"processed\\": 950, \\"errors\\": 50}, \\"details\\": [{\\"category\\": \\"A\\", \\"count\\": 400}, {\\"category\\": \\"B\\", \\"count\\": 350}, {\\"category\\": \\"C\\", \\"count\\": 200}], \\"metadata\\": {\\"generated_at\\": \\"2024-01-01T12:00:00Z\\", \\"version\\": \\"1.0\\"}}"}',
+        },
+    ),
+]
+
+agent_execution = AgentExecution(
+    agent_input={"task": "Generate report"},
+    agent_output={"status": "generated"},
+    agent_trace=mock_spans,
+)
+
+evaluator = ToolCallOutputEvaluator(
+    id="nested-output",
+    config={
+        "name": "ToolCallOutputEvaluator",
+        "strict": False
+    }
+)
+
+result = await evaluator.validate_and_evaluate_criteria(
+    agent_execution=agent_execution,
+    evaluation_criteria={
+        "tool_outputs": [
+            {
+                "name": "generate_report",
+                "output": {
+                    "report_id": "RPT-001",
+                    "summary": {
+                        "total_records": 1000,
+                        "processed": 950,
+                        "errors": 50
+                    },
+                    "details": [
+                        {"category": "A", "count": 400},
+                        {"category": "B", "count": 350},
+                        {"category": "C", "count": 200}
+                    ],
+                    "metadata": {
+                        "generated_at": "2024-01-01T12:00:00Z",
+                        "version": "1.0"
+                    }
+                }
+            }
+        ]
+    }
+)
+
+print(f"Score: {result.score}")  # 1.0 (nested output matches)
+```
+
+## Justification Details
+
+The evaluator returns a `ToolCallOutputEvaluatorJustification` with:
+
+```python
+{
+    "explained_tool_calls_outputs": {
+        "get_user_0": "Actual: {'user_id': 123, 'name': 'John Doe'}, Expected: {'user_id': 123, 'name': 'John Doe'}, Score: 1.0",
+        "calculate_total_0": "Actual: {'total': 99.99}, Expected: {'total': 99.99}, Score: 1.0",
+        "api_request_0": "Actual: {'status': 200, 'data': {}}, Expected: {'status': 200, 'data': {}}, Score: 1.0"
+    }
+}
+```
+
+## Best Practices
+
+1. **Use non-strict mode by default** - Allows for minor variations in outputs
+2. **Use strict mode for critical outputs** - Boolean flags, status codes, exact values
+3. **Validate key fields** - Focus on important output fields
+4. **Test error scenarios** - Verify tools return proper error outputs
+5. **Consider data types** - Ensure strings, numbers, booleans are correct
+6. **Test edge cases** - Empty responses, null values, error conditions
+7. **Combine with other evaluators** - Use with [Tool Call Args](tool_call_args.md) for complete validation
+
+
+## When to Use vs Other Evaluators
+
+**Use Tool Call Output when**:
+
+- Tool return values need validation
+- Testing tool integration correctness
+- Verifying data processing results
+- Ensuring proper error handling
+
+**Use Tool Call Args when**:
+
+- Validating inputs to tools (not outputs)
+- Testing parameter passing
+
+**Use Output Evaluator when**:
+
+- Validating final agent output (not tool outputs)
+- Testing overall result
+
+**Use JSON Similarity when**:
+
+- Comparing general data structures
+- Not specifically tool outputs
+
+## Limitations
+
+1. **Tool name matching** - Must match exact tool names from trace
+2. **Order matters** - First expected output matches first actual call of that tool
+3. **No temporal validation** - Doesn't verify when outputs occurred
+4. **Case-sensitive** - Keys and values are case-sensitive
+
+## Error Handling
+
+The evaluator handles:
+
+- **Missing tools**: Score 0.0 for that tool
+- **Extra tool calls not in criteria**: Ignored
+- **Null/empty outputs**: Compared based on mode
+- **Type mismatches**: Scored based on mode
+
+## Performance Considerations
+
+- **Fast evaluation**: O(n*m) where n = expected outputs, m = actual tool calls
+- **No LLM calls**: Deterministic and quick
+- **JSON similarity overhead**: Slightly slower than exact match
+
+## Related Evaluators
+
+- [Tool Call Args Evaluator](tool_call_args.md): Validates tool arguments (inputs)
+- [Tool Call Order Evaluator](tool_call_order.md): Validates tool call sequences
+- [Tool Call Count Evaluator](tool_call_count.md): Validates tool usage frequencies
+- [Output Evaluator](../eval/index.md#output-based-evaluators): For final agent outputs
+- [JSON Similarity Evaluator](json_similarity.md): For general JSON comparison
+
+
diff --git a/docs/hooks.py b/packages/uipath/docs/hooks.py
similarity index 100%
rename from docs/hooks.py
rename to packages/uipath/docs/hooks.py
diff --git a/packages/uipath/docs/index.md b/packages/uipath/docs/index.md
new file mode 100644
index 000000000..1a88e6b2a
--- /dev/null
+++ b/packages/uipath/docs/index.md
@@ -0,0 +1,68 @@
+---
+title: Getting Started
+---
+
+<h2>What do you want to build?</h2>
+
+<div class="grid cards" markdown>
+-   __Python Coded Functions__
+
+    ---
+
+    Deterministic Python automation with typed input/output. No LLM required. Runs as an Orchestrator job, invokable from Maestro, Studio, or the CLI.
+
+    **Requires:** `uipath`
+
+    [Build a Function](./core/functions.md)
+
+-   __Python Coded Agents__
+
+    ---
+
+    AI-driven automation with LLM reasoning loops. Uses the `uipath` SDK for platform services plus a framework extension of your choice.
+
+    **Requires:** `uipath` + one of the extensions below
+
+    [Build an Agent](./core/agents.md)
+
+</div>
+
+<h2>Agent Framework Extensions</h2>
+<div class="grid cards" markdown>
+-   __UiPath Langchain SDK__
+
+    ---
+
+    Build enterprise-grade UiPath agents using the LangChain framework, with seamless integration from build to run.
+
+    [Get Started](./langchain/quick_start.md)
+
+-   __UiPath LlamaIndex SDK__
+
+    ---
+
+    Build enterprise-grade UiPath agents using the LlamaIndex framework, with seamless integration from build to run.
+
+    [Get Started](./llamaindex/quick_start.md)
+
+-   __UiPath OpenAI Agents SDK__
+
+    ---
+
+    Build enterprise-grade UiPath agents using the OpenAI Agents SDK framework, with seamless integration from build to run.
+
+    [Get Started](./openai-agents/quick_start.md)
+
+</div>
+
+<h2>Other SDKs</h2>
+<div class="grid cards" markdown>
+-   __UiPath MCP SDK__
+
+    ---
+
+    Build and host Coded MCP Servers within UiPath.
+
+    [Start Building](./mcp/quick_start.md)
+
+</div>
diff --git a/docs/javascripts/extra.js b/packages/uipath/docs/javascripts/extra.js
similarity index 100%
rename from docs/javascripts/extra.js
rename to packages/uipath/docs/javascripts/extra.js
diff --git a/docs/overrides/main.html b/packages/uipath/docs/overrides/main.html
similarity index 100%
rename from docs/overrides/main.html
rename to packages/uipath/docs/overrides/main.html
diff --git a/docs/overrides/partials/actions.html b/packages/uipath/docs/overrides/partials/actions.html
similarity index 100%
rename from docs/overrides/partials/actions.html
rename to packages/uipath/docs/overrides/partials/actions.html
diff --git a/docs/overrides/partials/logo.html b/packages/uipath/docs/overrides/partials/logo.html
similarity index 100%
rename from docs/overrides/partials/logo.html
rename to packages/uipath/docs/overrides/partials/logo.html
diff --git a/docs/release_policy.md b/packages/uipath/docs/release_policy.md
similarity index 99%
rename from docs/release_policy.md
rename to packages/uipath/docs/release_policy.md
index 811f29306..278f9577c 100644
--- a/docs/release_policy.md
+++ b/packages/uipath/docs/release_policy.md
@@ -112,7 +112,7 @@ Breaking changes are introduced in minor releases (X.Y.0) and follow these guide
 
 The SDK maintains compatibility with:
 
-- Python 3.10+
+- Python 3.11+
 - Key dependencies as specified in `pyproject.toml`
 - Regular updates to dependencies are performed in minor releases
 
diff --git a/docs/sample_images/google-ADK-agent/agent-output.png b/packages/uipath/docs/sample_images/google-ADK-agent/agent-output.png
similarity index 100%
rename from docs/sample_images/google-ADK-agent/agent-output.png
rename to packages/uipath/docs/sample_images/google-ADK-agent/agent-output.png
diff --git a/packages/uipath/docs/sample_images/resource-overrides/package-requirements.png b/packages/uipath/docs/sample_images/resource-overrides/package-requirements.png
new file mode 100644
index 000000000..dde452122
Binary files /dev/null and b/packages/uipath/docs/sample_images/resource-overrides/package-requirements.png differ
diff --git a/docs/stylesheets/extra.css b/packages/uipath/docs/stylesheets/extra.css
similarity index 100%
rename from docs/stylesheets/extra.css
rename to packages/uipath/docs/stylesheets/extra.css
diff --git a/justfile b/packages/uipath/justfile
similarity index 69%
rename from justfile
rename to packages/uipath/justfile
index 407423b55..a9304f8ca 100644
--- a/justfile
+++ b/packages/uipath/justfile
@@ -9,7 +9,12 @@ lint:
 format:
     ruff format --check .
 
-build:
+validate: lint format
+
+update-agents-md: validate
+    python scripts/update_agents_md.py
+
+build: update-agents-md
     uv build
 
 install:
diff --git a/mkdocs.yml b/packages/uipath/mkdocs.yml
similarity index 65%
rename from mkdocs.yml
rename to packages/uipath/mkdocs.yml
index 46a511b49..382e0fdd5 100644
--- a/mkdocs.yml
+++ b/packages/uipath/mkdocs.yml
@@ -53,21 +53,48 @@ theme:
     - toc.follow
 
 nav:
+  - Home: index.md
   - UiPath SDK:
         - Getting Started: core/getting_started.md
-        - Environment Variables: core/environment_variables.md
+        - Python Coded Functions: core/functions.md
+        - Python Coded Agents: core/agents.md
         - CLI Reference: cli/index.md
         - Tracing: core/traced.md
+        - Studio Web Integration: core/studio_web.md
+        - Environment Variables: core/environment_variables.md
+        - Release Notes: core/release_notes.md
         - Services:
-            - Actions: core/actions.md
             - Assets: core/assets.md
+            - Attachments: core/attachments.md
             - Buckets: core/buckets.md
             - Connections: core/connections.md
             - Context Grounding: core/context_grounding.md
+            - Documents: core/documents.md
+            - Entities: core/entities.md
             - Jobs: core/jobs.md
+            - Guardrails: core/guardrails.md
             - LLM Gateway: core/llm_gateway.md
             - Queues: core/queues.md
             - Processes: core/processes.md
+            - Resource Catalog: core/resource_catalog.md
+            - Tasks: core/tasks.md
+        - Models:
+            - Documents: core/documents_models.md
+        - Evaluations:
+            - Overview: eval/index.md
+            - Output Evaluators:
+                - Contains: eval/contains.md
+                - Exact Match: eval/exact_match.md
+                - JSON Similarity: eval/json_similarity.md
+                - LLM Judge Output: eval/llm_judge_output.md
+            - Trajectory Evaluators:
+                - Tool Call Order: eval/tool_call_order.md
+                - Tool Call Count: eval/tool_call_count.md
+                - Tool Call Args: eval/tool_call_args.md
+                - Tool Call Output: eval/tool_call_output.md
+                - LLM Judge Trajectory: eval/llm_judge_trajectory.md
+            - Custom Evaluators: eval/custom_evaluators.md
+
   - UiPath MCP SDK:
       - Getting Started: mcp/quick_start.md
       - How To Pack Binary: mcp/how_to_pack_binary.md
@@ -76,6 +103,7 @@ nav:
       - Getting Started: langchain/quick_start.md
       - Chat Models: langchain/chat_models.md
       - Context Grounding: langchain/context_grounding.md
+      - Guardrails: langchain/guardrails.md
       - Human In The Loop: langchain/human_in_the_loop.md
       - Sample Agents: https://github.com/UiPath/uipath-langchain-python/tree/main/samples
   - UiPath LlamaIndex SDK:
@@ -83,13 +111,35 @@ nav:
       - LLMs and Embeddings: llamaindex/llms_and_embeddings.md
       - Context Grounding: llamaindex/context_grounding.md
       - Human In The Loop: llamaindex/human_in_the_loop.md
-      - Sample Agents: https://github.com/UiPath/uipath-llamaindex-python/tree/main/samples
+      - Sample Agents: https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-llamaindex/samples
+  - UiPath OpenAI Agents SDK:
+      - Getting Started: openai-agents/quick_start.md
+      - Sample Agents: https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-openai-agents/samples
   - How To Contribute: CONTRIBUTING.md
   - FAQ: FAQ.md
+  - Automation Suite: AutomationSuite.md
   - Release Policy: release_policy.md
 
 plugins:
   - search
+  - llmstxt:
+      full_output: llms-full.txt
+      sections:
+        "UiPath SDK":
+          - core/*.md
+          - cli/*.md
+          - eval/*.md
+        "UiPath MCP SDK":
+          - mcp/*.md
+        "UiPath LangChain SDK":
+          - langchain/*.md
+        "UiPath LlamaIndex SDK":
+          - llamaindex/*.md
+        "UiPath OpenAI Agents SDK":
+          - openai-agents/*.md
+        "Contributing & Resources":
+          - CONTRIBUTING.md
+          - FAQ.md
   - mkdocstrings:
       default_handler: python
       handlers:
diff --git a/packages/uipath/py.typed b/packages/uipath/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/pyproject.toml b/packages/uipath/pyproject.toml
new file mode 100644
index 000000000..7acd8465d
--- /dev/null
+++ b/packages/uipath/pyproject.toml
@@ -0,0 +1,181 @@
+[project]
+name = "uipath"
+version = "2.11.12"
+description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.11"
+dependencies = [
+  "uipath-core>=0.5.21, <0.6.0",
+  "uipath-runtime>=0.11.0, <0.12.0",
+  "uipath-platform>=0.1.76, <0.2.0",
+  "click>=8.3.1",
+  "httpx>=0.28.1",
+  "pyjwt>=2.10.1",
+  "python-dotenv>=1.0.1",
+  "tenacity>=9.0.0",
+  "pathlib>=1.0.1",
+  "rich>=14.2.0",
+  "truststore>=0.10.1",
+  "mockito>=1.5.4",
+  "pydantic-function-models>=0.1.11",
+  "pysignalr==1.3.0",
+  "python-socketio>=5.15.0, <6.0.0",
+  "coverage>=7.8.2",
+  "mermaid-builder==0.0.3",
+  "graphtty==0.1.8",
+  "applicationinsights>=0.11.10",
+]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Build Tools",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+maintainers = [
+  { name = "Marius Cosareanu", email = "marius.cosareanu@uipath.com" },
+  { name = "Cristian Pufu", email = "cristian.pufu@uipath.com" },
+]
+
+[project.urls]
+Homepage = "https://uipath.com"
+Repository = "https://github.com/UiPath/uipath-python"
+Documentation = "https://uipath.github.io/uipath-python/"
+
+[project.scripts]
+uipath = "uipath._cli:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+  "bandit>=1.8.2",
+  "mypy>=1.14.1",
+  "ruff>=0.9.4",
+  "rust-just>=1.39.0",
+  "pytest>=7.4.0",
+  "pytest-asyncio>=1.0.0",
+  "pytest-httpx>=0.35.0",
+  "pytest-trio>=0.8.0",
+  "pytest-cov>=4.1.0",
+  "pytest-mock>=3.11.1",
+  "pre-commit>=4.5.1",
+  "filelock>=3.20.3",
+  "virtualenv>=20.36.1",
+  "mkdocs>=1.6.1",
+  "mkdocs-material[imaging]>=9.7.0",
+  "mkdocstrings[python]>=0.30.1",
+  "termynal>=0.13.1",
+  "tomli-w>=1.2.0",
+  "mkdocs-simple-hooks>=0.1.5",
+  "mkdocs-click>=0.9.0",
+  "mkdocs-open-in-new-tab>=1.0.8",
+  "mkdocs-llmstxt>=0.5.0",
+  "inflection>=0.5.1",
+  "types-toml>=0.10.8",
+  "pytest-timeout>=2.4.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/uipath"]
+include = ["src/uipath/_resources"]
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+exclude = ["samples/**", "testcases/**"]
+
+[tool.ruff.lint]
+select = ["E", "F", "B", "I", "D"]
+ignore = ["D417"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["uipath"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+ignore-decorators = []
+
+[tool.ruff.lint.per-file-ignores]
+"*" = ["E501"]
+"tests/**" = ["D"]
+"*_test.py" = ["D"]
+"docs/**" = ["D"]
+# TODO: Remove this once the documentation for CLI is updated
+"uipath/_cli/**" = ["D"]
+# TODO: Remove this once model documentation is added
+"src/uipath/models/**" = ["D101", "D100", "D104", "D102", "D107"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.mypy]
+mypy_path = "src"
+plugins = ["pydantic.mypy"]
+exclude = ["samples/.*", "testcases/.*"]
+files = ["src", "tests"]
+namespace_packages = true
+explicit_package_bases = true
+follow_imports = "silent"
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+check_untyped_defs = true
+no_implicit_reexport = true
+disallow_untyped_defs = false
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+addopts = "-ra -q --cov=src --cov-report=term-missing"
+asyncio_default_fixture_loop_scope = "function"
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["src"]
+relative_files = true
+omit = [
+  "*/tests/*",
+  "*/__pycache__/*",
+  "*/site-packages/*",
+  "*/conftest.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+precision = 2
+exclude_lines = [
+  "pragma: no cover",
+  "def __repr__",
+  "raise NotImplementedError",
+  "if TYPE_CHECKING:",
+  "@(abc\\.)?abstractmethod",
+]
+
+[tool.uv]
+exclude-newer = "2 days"
+
+[tool.uv.exclude-newer-package]
+uipath-core = false
+uipath-runtime = false
+uipath-platform = false
+
+[tool.uv.sources]
+uipath-core = { path = "../uipath-core", editable = true }
+uipath-platform = { path = "../uipath-platform", editable = true }
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
diff --git a/packages/uipath/samples/asset-modifier-agent/.env.example b/packages/uipath/samples/asset-modifier-agent/.env.example
new file mode 100644
index 000000000..e2ac4969b
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/.env.example
@@ -0,0 +1 @@
+UIPATH_CLIENT_SECRET=
diff --git a/packages/uipath/samples/asset-modifier-agent/README.md b/packages/uipath/samples/asset-modifier-agent/README.md
new file mode 100644
index 000000000..b2c533955
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/README.md
@@ -0,0 +1,112 @@
+# UiPath Coded Agent: Asset Value Checker
+
+This project demonstrates how to create a Python-based UiPath Coded Agent that connects as an External Application to UiPath Orchestrator, retrieves an asset, and validates its IntValue against custom rules.
+
+## Overview
+
+The agent uses the UiPath Python SDK to:
+
+* Connect to UiPath Orchestrator as an external application
+* Authenticate via the Client Credentials flow (Client ID + Client Secret)
+* Retrieve a specific asset from a given folder
+* Check whether the asset has an integer value and validate it against a range (100–1000)
+* Return a descriptive message with the validation result
+
+## Prerequisites
+
+* [UV package manager](https://docs.astral.sh/uv/) installed
+* UiPath Orchestrator access
+* An External Application configured in UiPath with the `OR.Assets` scope
+
+You can learn how to create and setup your own External Application from the [UiPath documentation](https://docs.uipath.com/automation-cloud/automation-cloud/latest/admin-guide/managing-external-applications).
+
+## Setup
+
+### Step 1: Create and Activate Virtual Environment
+
+```bash
+uv venv
+```
+
+Activate the virtual environment:
+- **Windows**: `.venv\Scripts\activate`
+- **Linux/Mac**: `source .venv/bin/activate`
+
+### Step 2: Install Dependencies
+
+```bash
+uv sync
+```
+
+### Step 3: Configure the Application
+
+1. **Edit `main.py`** (lines 13, 16) and replace the placeholder values:
+   - `UIPATH_CLIENT_ID`: Replace `"EXTERNAL_APP_CLIENT_ID_HERE"` with your External Application's Client ID
+   - `UIPATH_URL`: Replace `"base_url"` with your Orchestrator URL (e.g., `"https://cloud.uipath.com/your_org/your_tenant"`)
+
+2. **Set Environment Variables**
+
+   Create a `.env` file in the project directory or set the environment variable:
+   ```bash
+   UIPATH_CLIENT_SECRET=your-client-secret-here
+   ```
+
+### Step 4: Initialize the Agent
+
+```bash
+uv run uipath init
+```
+
+### Step 5: Prepare Input Data
+
+Format your `input.json` file with the following structure:
+
+```json
+{
+  "asset_name": "test-asset",
+  "folder_path": "TestFolder"
+}
+```
+
+**Input Parameters:**
+- `asset_name`: The name of the UiPath asset to validate
+- `folder_path`: The folder path in Orchestrator where the asset is located
+
+### Step 6: Run the Agent
+
+Execute the agent locally:
+
+```bash
+uipath run main --input-file input.json
+```
+
+## How It Works
+
+When this agent runs, it will:
+
+1. Load input values (`asset_name` and `folder_path`)
+2. Connect to Orchestrator using Client Credentials authentication
+3. Retrieve the specified asset from the given folder
+4. Validate the asset's IntValue against the allowed range (100–1000)
+5. Return a descriptive message with the validation result
+
+**Possible Outputs:**
+- "Asset not found." — Asset doesn't exist
+- "Asset does not have an IntValue." — Asset exists but has no integer value
+- "Asset '<name>' has a valid IntValue: <value>" — IntValue is within range
+- "Asset '<name>' has an out-of-range IntValue: <value>" — IntValue is outside range
+
+## Publish Your Coded Agent
+
+Once tested locally, publish your agent to Orchestrator:
+
+1. Pack the agent:
+   ```bash
+   uipath pack
+   ```
+
+2. Publish to Orchestrator:
+   ```bash
+   uipath publish
+   ```
+
diff --git a/packages/uipath/samples/asset-modifier-agent/bindings.json b/packages/uipath/samples/asset-modifier-agent/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/asset-modifier-agent/input.json b/packages/uipath/samples/asset-modifier-agent/input.json
new file mode 100644
index 000000000..17f999b57
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/input.json
@@ -0,0 +1,4 @@
+{
+  "asset_name": "test-asset",
+  "folder_path": "TestFolder"
+}
diff --git a/packages/uipath/samples/asset-modifier-agent/main.py b/packages/uipath/samples/asset-modifier-agent/main.py
new file mode 100644
index 000000000..f41965dd2
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/main.py
@@ -0,0 +1,85 @@
+import dataclasses
+import dotenv
+import logging
+import os
+from typing import Any
+from uipath.platform import UiPath
+from uipath.tracing import traced
+
+dotenv.load_dotenv()
+logger = logging.getLogger(__name__)
+
+def get_uipath_client() -> UiPath:
+    """Initialize and return a UiPath client using environment variables.
+
+    Returns:
+        UiPath: An instance of the UiPath client.
+    """
+    UIPATH_CLIENT_ID = "EXTERNAL_APP_CLIENT_ID_HERE"
+    UIPATH_CLIENT_SECRET = os.getenv("UIPATH_CLIENT_SECRET")
+    UIPATH_SCOPE = "OR.Assets"
+    UIPATH_URL = "base_url"
+    return UiPath(
+        client_id=UIPATH_CLIENT_ID,
+        client_secret=UIPATH_CLIENT_SECRET,
+        scope=UIPATH_SCOPE,
+        base_url=UIPATH_URL
+    )
+
+@dataclasses.dataclass
+class AgentInput:
+    """Input data structure for the UiPath agent.
+
+    Attributes:
+        asset_name (str): The name of the UiPath asset.
+        folder_path (str): The folder path where the asset is located.
+    """
+    asset_name: str
+    folder_path: str
+
+def get_asset(client: UiPath, name: str, folder_path: str) -> Any:
+    """Retrieve an asset from UiPath.
+
+    Args:
+        name (str): The asset name.
+        folder_path (str): The UiPath folder path.
+
+    Returns:
+        Any: The asset object if found, else None.
+    """
+    return client.assets.retrieve(name=name, folder_path=folder_path)
+
+def check_asset(asset: object) -> str:
+    """Check if an asset's IntValue is within a valid range.
+
+    Args:
+        asset (object): The asset object.
+
+    Returns:
+        str: Result message depending on asset state.
+    """
+    if asset is None:
+        return "Asset not found."
+
+    int_value = getattr(asset, "int_value", None)
+    if int_value is None:
+        return "Asset does not have an IntValue."
+
+    if 100 <= int_value <= 1000:
+        return f"Asset '{asset.name}' has a valid IntValue: {int_value}"
+    else:
+        return f"Asset '{asset.name}' has an out-of-range IntValue: {int_value}"
+
+@traced()
+def main(input: AgentInput) -> str:
+    """Main entry point for the agent.
+
+    Args:
+        input (AgentInput): The input containing asset details.
+
+    Returns:
+        str: Message with the result of the asset check.
+    """
+    client = get_uipath_client()
+    asset = get_asset(client, input.asset_name, input.folder_path)
+    return check_asset(asset)
diff --git a/packages/uipath/samples/asset-modifier-agent/pyproject.toml b/packages/uipath/samples/asset-modifier-agent/pyproject.toml
new file mode 100644
index 000000000..8937dfa7a
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "asset-checker-agent"
+version = "0.0.1"
+description = "UiPath agent to validate asset values via External Application integration with Orchestrator."
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/asset-modifier-agent/uipath.json b/packages/uipath/samples/asset-modifier-agent/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/asset-modifier-agent/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/QUICKSTART.md b/packages/uipath/samples/attachment_evaluation_test/QUICKSTART.md
new file mode 100644
index 000000000..a3b2fa84f
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/QUICKSTART.md
@@ -0,0 +1,162 @@
+# Quick Start Guide
+
+Get up and running with the attachment evaluation sample in 5 minutes!
+
+## Step 1: Install Dependencies
+
+```bash
+cd samples/attachment_evaluation_test
+uv sync
+```
+
+## Step 2: Set Up UiPath Credentials
+
+Choose one of these methods:
+
+### Option A: Environment Variables
+
+```bash
+export UIPATH_URL="https://your-tenant.uipath.com"
+export UIPATH_ACCESS_TOKEN="your-access-token"
+```
+
+### Option B: Interactive Auth
+
+```bash
+uv run uipath auth
+```
+
+Follow the prompts to authenticate.
+
+## Step 3: Run the Agent
+
+```bash
+# Generate a sales report
+uv run uipath run main '{"task": "Generate sales report"}'
+```
+
+**Expected output:**
+```json
+{
+  "report": "urn:uipath:cas:file:orchestrator:abc12345-...",
+  "task": "Generate sales report",
+  "status": "completed"
+}
+```
+
+The `report` field contains the attachment URI!
+
+## Step 4: Run Evaluations
+
+```bash
+uv run uipath eval main evaluations/eval-sets/default.json --workers 1
+```
+
+**Expected output:**
+```
+Running evaluations...
+✓ Test sales report exact match - PASSED (2/2 evaluators)
+✓ Test inventory report contains - PASSED (1/1 evaluator)
+✓ Test employee report line-by-line - PASSED (1/1 evaluator)
+✓ Test generic report exact match - PASSED (2/2 evaluators)
+✓ Test partial match with contains - PASSED (1/1 evaluator)
+
+Summary: 5/5 tests passed
+```
+
+## What's Happening?
+
+1. **Agent runs** and generates report content
+2. **Content is uploaded** as a job attachment to UiPath
+3. **Attachment URI** is returned in agent output
+4. **Evaluators detect** the URI automatically
+5. **Attachment is downloaded** and content is evaluated
+6. **Results are displayed** showing pass/fail
+
+## Try Different Reports
+
+```bash
+# Inventory report
+uv run uipath run main '{"task": "Generate inventory report"}'
+
+# Employee report
+uv run uipath run main '{"task": "Generate employee report"}'
+
+# Generic report
+uv run uipath run main '{"task": "Complete project review"}'
+```
+
+## View Attachment Content
+
+After running the agent, you can manually download the attachment to see its content:
+
+```bash
+# Extract the UUID from the output
+# urn:uipath:cas:file:orchestrator:YOUR-UUID-HERE
+
+# Or check in UiPath Orchestrator UI:
+# Orchestrator > Jobs > Job Details > Attachments
+```
+
+## Customize
+
+### Add New Report Types
+
+Edit `main.py` and add a new condition:
+
+```python
+elif "financial" in task.lower():
+    content = """Your report content here"""
+```
+
+### Add New Evaluators
+
+Create a new evaluator config in `evaluations/evaluators/`:
+
+```json
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "MyEvaluator",
+    "targetOutputKey": "report"
+  }
+}
+```
+
+### Add New Test Cases
+
+Edit `evaluations/eval-sets/default.json` and add:
+
+```json
+{
+  "name": "My test case",
+  "input": {"task": "..."},
+  "evaluationCriteria": {
+    "MyEvaluator": {...}
+  }
+}
+```
+
+## Troubleshooting
+
+### "Attachment not found"
+- Check your credentials point to the correct tenant
+- Verify the attachment wasn't deleted
+
+### "Permission denied"
+- Ensure your access token has attachment read/write permissions
+
+### "Module not found"
+- Run `uv sync` to install dependencies
+
+## Next Steps
+
+- Read the full [README.md](./README.md) for detailed documentation
+- Check [../../src/uipath/_resources/eval.md](../../src/uipath/_resources/eval.md) for evaluation framework details
+- See [../line_by_line_test/](../line_by_line_test/) for line-by-line evaluation examples
+
+## Need Help?
+
+- [UiPath Python SDK Documentation](https://docs.uipath.com/)
+- [GitHub Issues](https://github.com/UiPath/uipath-python-sdk/issues)
diff --git a/packages/uipath/samples/attachment_evaluation_test/README.md b/packages/uipath/samples/attachment_evaluation_test/README.md
new file mode 100644
index 000000000..ab6a35366
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/README.md
@@ -0,0 +1,300 @@
+# Job Attachment Evaluation Sample
+
+This sample demonstrates end-to-end evaluation of agent outputs stored as job attachments.
+
+## Overview
+
+When an agent produces large outputs (reports, documents, data files), it's more efficient to store them as job attachments rather than returning them directly. This sample shows how to:
+
+1. **Create and upload job attachments** from an agent
+2. **Return attachment URIs** as agent output
+3. **Automatically download and evaluate** attachment content
+
+The evaluation framework automatically detects attachment URIs (pattern: `urn:uipath:cas:file:orchestrator:{uuid}`), downloads the content, and evaluates it against expected criteria.
+
+## Features Demonstrated
+
+- **Attachment Upload**: Upload text content as a job attachment
+- **Attachment URI Output**: Return the attachment URI in agent output
+- **Automatic Download**: Evaluators automatically download and read attachment content
+- **Multiple Evaluator Types**: ExactMatch, Contains, and LineByLine evaluation
+- **Different Report Types**: Sales, inventory, employee, and generic reports
+
+## Prerequisites
+
+```bash
+# Ensure you have UiPath credentials configured
+export UIPATH_URL="https://your-tenant.uipath.com"
+export UIPATH_ACCESS_TOKEN="your-access-token"
+
+# Or use the auth command
+uipath auth
+```
+
+## Installation
+
+```bash
+cd samples/attachment_evaluation_test
+
+# Install dependencies
+uv sync
+
+# Verify installation
+uv run uipath --version
+```
+
+## Usage
+
+### Run the Agent Manually
+
+```bash
+# Generate a sales report
+uv run uipath run main '{"task": "Generate sales report"}'
+
+# Generate an inventory report
+uv run uipath run main '{"task": "Generate inventory report"}'
+
+# Generate an employee report
+uv run uipath run main '{"task": "Generate employee report"}'
+
+# Generate a generic report
+uv run uipath run main '{"task": "Complete project review"}'
+```
+
+**Output format:**
+```json
+{
+  "report": "urn:uipath:cas:file:orchestrator:12345678-1234-1234-1234-123456789abc",
+  "task": "Generate sales report",
+  "status": "completed"
+}
+```
+
+The `report` field contains the attachment URI which evaluators will automatically download and evaluate.
+
+### Run Evaluations
+
+```bash
+# Run all evaluation test cases
+uv run uipath eval main evaluations/eval-sets/default.json --workers 1
+
+# Run with detailed output
+uv run uipath eval main evaluations/eval-sets/default.json --workers 1 --verbose
+```
+
+## Evaluation Results
+
+The sample includes 5 test cases with 3 evaluators:
+
+### Evaluators
+
+1. **ReportContentMatch** - ExactMatch evaluator that compares full attachment content
+2. **ReportContainsKeyword** - Contains evaluator that checks for specific keywords
+3. **LineByLineContains** - LineByLine Contains evaluator for multiline validation
+
+### Test Cases
+
+| Test Case | Input | Evaluators | Expected Result |
+|-----------|-------|------------|-----------------|
+| Test sales report exact match | "Generate sales report" | ReportContentMatch, ReportContainsKeyword | Both pass (1.0) |
+| Test inventory report contains keywords | "Generate inventory report" | ReportContainsKeyword | Pass (1.0) |
+| Test employee report line-by-line | "Generate employee report" | LineByLineContains | Pass (1.0) |
+| Test generic report exact match | "Complete project review" | ReportContentMatch, ReportContainsKeyword | Both pass (1.0) |
+| Test partial match with contains | "Generate sales report" | ReportContainsKeyword | Pass (1.0) |
+
+Expected output:
+```
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+┃  Evaluation                        ┃  ReportContentMatch  ┃  ReportContainsKeyword  ┃  LineByLineContains  ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩
+│  Test sales report exact match     │                 1.0  │                     1.0  │                  -   │
+│  Test inventory report contains    │                  -   │                     1.0  │                  -   │
+│  Test employee report line-by-line │                  -   │                      -   │                1.0   │
+│  Test generic report exact match   │                 1.0  │                     1.0  │                  -   │
+│  Test partial match with contains  │                  -   │                     1.0  │                  -   │
+├────────────────────────────────────┼──────────────────────┼──────────────────────────┼──────────────────────┤
+│  Average                           │                 1.0  │                     1.0  │                1.0   │
+└────────────────────────────────────┴──────────────────────┴──────────────────────────┴──────────────────────┘
+```
+
+## How It Works
+
+### 1. Agent Creates Attachment
+
+```python
+from uipath.platform import UiPath
+
+# Generate content
+content = "Sales Report Q4 2024\n\nTotal Revenue: $1,250,000\n..."
+
+# Upload as attachment
+client = UiPath()
+attachment_id = client.attachments.upload(
+    name="report_sales.txt",
+    content=content,
+)
+
+# Return URI
+return {
+    "report": f"urn:uipath:cas:file:orchestrator:{attachment_id}"
+}
+```
+
+### 2. Evaluator Configuration
+
+```json
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ReportContentMatch",
+    "targetOutputKey": "report",
+    "caseSensitive": false
+  }
+}
+```
+
+The `targetOutputKey` points to the field containing the attachment URI.
+
+### 3. Automatic Download and Evaluation
+
+When the evaluator runs:
+1. Extracts value from `agent_output["report"]`
+2. Detects it's an attachment URI (matches pattern)
+3. Downloads the attachment content automatically
+4. Evaluates the downloaded content against expected criteria
+
+## File Structure
+
+```
+attachment_evaluation_test/
+├── main.py                                # Agent that creates attachments
+├── uipath.json                            # Agent configuration
+├── pyproject.toml                         # Dependencies
+├── README.md                              # Full documentation
+├── QUICKSTART.md                          # Quick start guide
+└── evaluations/
+    ├── evaluators/
+    │   ├── exact-match.json               # ExactMatch evaluator config
+    │   ├── contains-keyword.json          # Contains evaluator config
+    │   └── line-by-line-contains.json     # LineByLine evaluator config
+    └── eval-sets/
+        └── default.json                   # Test cases with evaluation criteria
+```
+
+## Key Concepts
+
+### Attachment URI Pattern
+
+```
+urn:uipath:cas:file:orchestrator:{attachment-uuid}
+```
+
+Example:
+```
+urn:uipath:cas:file:orchestrator:123e4567-e89b-12d3-a456-426614174000
+```
+
+### Target Output Key
+
+The `targetOutputKey` in evaluator configuration specifies which field contains the attachment URI:
+
+```json
+{
+  "targetOutputKey": "report"  // Looks for agent_output["report"]
+}
+```
+
+For nested paths, use dot notation:
+```json
+{
+  "targetOutputKey": "results.report"  // agent_output["results"]["report"]
+}
+```
+
+### Supported Evaluators
+
+All output evaluators support attachment evaluation:
+- **ExactMatch** - Full content match
+- **Contains** - Keyword/substring search
+- **JsonSimilarity** - JSON structure comparison (if attachment contains JSON)
+- **LLM-based evaluators** - Can analyze attachment content
+
+## Troubleshooting
+
+### Authentication Errors
+
+```bash
+# Verify credentials are set
+echo $UIPATH_URL
+echo $UIPATH_ACCESS_TOKEN
+
+# Or authenticate interactively
+uipath auth
+```
+
+### Attachment Not Found
+
+If you see "Attachment with key X not found":
+- Ensure you're connected to the correct tenant
+- Check that the folder context matches where the attachment was created
+- Verify the attachment UUID is correct
+
+### Download Failures
+
+If attachment download fails:
+- Check network connectivity to your UiPath tenant
+- Verify your access token has permissions to read attachments
+- Check if the attachment still exists (not deleted)
+
+## Learn More
+
+- [UiPath Python SDK Documentation](https://docs.uipath.com/)
+- [Evaluation Framework Guide](../../src/uipath/_resources/eval.md)
+- [Job Attachments API](https://docs.uipath.com/orchestrator/reference/api-attachments)
+- [Line-by-Line Evaluation Sample](../line_by_line_test/)
+
+## Advanced Usage
+
+### Custom Report Types
+
+Modify `main.py` to add more report types:
+
+```python
+elif "financial" in task.lower():
+    content = """Financial Report
+
+    Revenue: $X
+    Expenses: $Y
+    Profit: $Z
+    """
+```
+
+### Binary Attachments
+
+For binary files (images, PDFs), upload as bytes:
+
+```python
+attachment_id = client.attachments.upload(
+    name="document.pdf",
+    source_path="/path/to/file.pdf",  # Or use content=<bytes>
+)
+```
+
+### Multiple Attachments
+
+Return multiple attachment URIs:
+
+```python
+return {
+    "primary_report": f"urn:uipath:cas:file:orchestrator:{id1}",
+    "detailed_report": f"urn:uipath:cas:file:orchestrator:{id2}",
+}
+```
+
+Then configure evaluators for each:
+```json
+{
+  "targetOutputKey": "primary_report"  // Evaluates first attachment
+}
+```
diff --git a/packages/uipath/samples/attachment_evaluation_test/bindings.json b/packages/uipath/samples/attachment_evaluation_test/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/attachment_evaluation_test/entry-points.json b/packages/uipath/samples/attachment_evaluation_test/entry-points.json
new file mode 100644
index 000000000..ba9d6512b
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/entry-points.json
@@ -0,0 +1,60 @@
+{
+    "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+    "$id": "entry-points.json",
+    "entryPoints": [
+        {
+            "filePath": "main",
+            "uniqueId": "1bf59526-00ea-49fc-a9e3-0129eb537136",
+            "type": "function",
+            "input": {
+                "type": "object",
+                "properties": {
+                    "task": {
+                        "title": "Task",
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "task"
+                ],
+                "title": "Input"
+            },
+            "output": {
+                "type": "object",
+                "properties": {
+                    "report": {
+                        "title": "Report",
+                        "type": "string"
+                    },
+                    "task": {
+                        "title": "Task",
+                        "type": "string"
+                    },
+                    "status": {
+                        "title": "Status",
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "report",
+                    "task",
+                    "status"
+                ],
+                "title": "Output"
+            },
+            "graph": {
+                "nodes": [
+                    {
+                        "id": "main.py:84",
+                        "name": "main",
+                        "type": "function",
+                        "metadata": {
+                            "file": "main.py"
+                        }
+                    }
+                ],
+                "edges": []
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/attachment_evaluation_test/evaluations/eval-sets/default.json b/packages/uipath/samples/attachment_evaluation_test/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..cfb669b69
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/evaluations/eval-sets/default.json
@@ -0,0 +1,88 @@
+{
+  "version": "1.0",
+  "id": "attachment-evaluation-test",
+  "name": "Attachment Evaluation Tests",
+  "description": "Test cases for evaluating agent outputs stored as job attachments",
+  "evaluatorRefs": [
+    "ReportContentMatch",
+    "ReportContainsKeyword",
+    "LineByLineContains"
+  ],
+  "evaluations": [
+    {
+      "id": "test-sales-report-exact-match",
+      "name": "Test sales report exact match",
+      "description": "Verify the sales report content matches exactly",
+      "inputs": {
+        "task": "Generate sales report"
+      },
+      "evaluationCriterias": {
+        "ReportContentMatch": {
+          "expectedOutput": {
+            "report": "Sales Report Q4 2024\n\nTotal Revenue: $1,250,000\nNew Customers: 45\nCustomer Retention: 92%\nTop Product: Enterprise Suite\n"
+          }
+        },
+        "ReportContainsKeyword": {
+          "searchText": "Revenue"
+        }
+      }
+    },
+    {
+      "id": "test-inventory-report-contains",
+      "name": "Test inventory report contains keywords",
+      "description": "Verify the inventory report contains expected keywords",
+      "inputs": {
+        "task": "Generate inventory report"
+      },
+      "evaluationCriterias": {
+        "ReportContainsKeyword": {
+          "searchText": "Warehouse"
+        }
+      }
+    },
+    {
+      "id": "test-employee-report-line-by-line",
+      "name": "Test employee report line-by-line",
+      "description": "Verify employee report lines contain expected text",
+      "inputs": {
+        "task": "Generate employee report"
+      },
+      "evaluationCriterias": {
+        "LineByLineContains": {
+          "searchText": "Employee"
+        }
+      }
+    },
+    {
+      "id": "test-generic-report-exact-match",
+      "name": "Test generic report exact match",
+      "description": "Verify generic report content",
+      "inputs": {
+        "task": "Complete project review"
+      },
+      "evaluationCriterias": {
+        "ReportContentMatch": {
+          "expectedOutput": {
+            "report": "Task Report: Complete project review\n\nStatus: Completed\nDate: 2024-03-25\nSummary: Task has been successfully completed.\nNotes: All requirements met.\n"
+          }
+        },
+        "ReportContainsKeyword": {
+          "searchText": "Completed"
+        }
+      }
+    },
+    {
+      "id": "test-partial-match-with-contains",
+      "name": "Test partial match with contains",
+      "description": "Verify report contains specific information",
+      "inputs": {
+        "task": "Generate sales report"
+      },
+      "evaluationCriterias": {
+        "ReportContainsKeyword": {
+          "searchText": "Q4 2024"
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/contains-keyword.json b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/contains-keyword.json
new file mode 100644
index 000000000..a336a7c89
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/contains-keyword.json
@@ -0,0 +1,12 @@
+{
+  "version": "1.0",
+  "id": "ReportContainsKeyword",
+  "description": "Checks if attachment content contains expected keywords",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "ReportContainsKeyword",
+    "targetOutputKey": "report",
+    "ignoreCase": true,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/exact-match.json b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/exact-match.json
new file mode 100644
index 000000000..2079d05c4
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/exact-match.json
@@ -0,0 +1,12 @@
+{
+  "version": "1.0",
+  "id": "ReportContentMatch",
+  "description": "Evaluates full attachment content using exact match",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ReportContentMatch",
+    "targetOutputKey": "report",
+    "ignoreCase": true,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/line-by-line-contains.json b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/line-by-line-contains.json
new file mode 100644
index 000000000..92c793836
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/evaluations/evaluators/line-by-line-contains.json
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "id": "LineByLineContains",
+  "description": "Evaluates each line of attachment separately using contains",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "LineByLineContains",
+    "targetOutputKey": "report",
+    "lineByLineEvaluator": true,
+    "lineDelimiter": "\n",
+    "ignoreCase": true,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/main.py b/packages/uipath/samples/attachment_evaluation_test/main.py
new file mode 100644
index 000000000..5ed968d4d
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/main.py
@@ -0,0 +1,88 @@
+"""Sample agent that produces a job attachment as output.
+
+This agent demonstrates:
+1. Creating content based on input
+2. Uploading content as a job attachment
+3. Returning the attachment URI for evaluation
+"""
+
+from pydantic import BaseModel
+
+from uipath.platform import UiPath
+
+
+class Input(BaseModel):
+    """Input schema for report generation."""
+
+    task: str
+
+
+class Output(BaseModel):
+    """Output schema with attachment URI."""
+
+    report: str
+    task: str
+    status: str
+
+
+def main(input_data: Input) -> Output:
+    """Create a report and return it as a job attachment.
+
+    Args:
+        input_data: Input containing task description
+
+    Returns:
+        Output with attachment URI, task, and status
+    """
+    task = input_data.task
+
+    # Generate report content based on the task
+    if "sales" in task.lower():
+        content = """Sales Report Q4 2024
+
+Total Revenue: $1,250,000
+New Customers: 45
+Customer Retention: 92%
+Top Product: Enterprise Suite
+"""
+    elif "inventory" in task.lower():
+        content = """Inventory Report
+
+Warehouse A: 1,234 items
+Warehouse B: 987 items
+Low Stock Items: 12
+Reorder Required: 8
+"""
+    elif "employee" in task.lower():
+        content = """Employee Performance Report
+
+Total Employees: 150
+Average Performance Score: 4.2/5.0
+Training Completed: 95%
+Promotions This Quarter: 8
+"""
+    else:
+        # Default generic report
+        content = f"""Task Report: {task}
+
+Status: Completed
+Date: 2024-03-25
+Summary: Task has been successfully completed.
+Notes: All requirements met.
+"""
+
+    # Upload content as a job attachment
+    client = UiPath()
+    attachment_id = client.attachments.upload(
+        name=f"report_{task.replace(' ', '_')}.txt",
+        content=content,
+    )
+
+    # Return the attachment URI
+    attachment_uri = f"urn:uipath:cas:file:orchestrator:{attachment_id}"
+
+    return Output(
+        report=attachment_uri,
+        task=task,
+        status="completed",
+    )
diff --git a/packages/uipath/samples/attachment_evaluation_test/pyproject.toml b/packages/uipath/samples/attachment_evaluation_test/pyproject.toml
new file mode 100644
index 000000000..0520661f0
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "attachment-evaluation-test"
+version = "0.1.0"
+description = "Sample agent demonstrating job attachment evaluation"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+requires-python = ">=3.11"
+dependencies = [
+  "uipath"
+]
+
+[tool.uv.sources]
+uipath = { path = "../..", editable = true }
diff --git a/packages/uipath/samples/attachment_evaluation_test/uipath.json b/packages/uipath/samples/attachment_evaluation_test/uipath.json
new file mode 100644
index 000000000..e2a331e84
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/uipath.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "main.py:main"
+  },
+  "agents": {}
+}
diff --git a/packages/uipath/samples/attachment_evaluation_test/uv.lock b/packages/uipath/samples/attachment_evaluation_test/uv.lock
new file mode 100644
index 000000000..9e3fb82d6
--- /dev/null
+++ b/packages/uipath/samples/attachment_evaluation_test/uv.lock
@@ -0,0 +1,1605 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "applicationinsights"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f2/46a75ac6096d60da0e71a068015b610206e697de01fa2fb5bba8564b0798/applicationinsights-0.11.10.tar.gz", hash = "sha256:0b761f3ef0680acf4731906dfc1807faa6f2a57168ae74592db0084a6099f7b3", size = 44722, upload-time = "2021-04-22T23:22:45.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/0d/cb6b23164eb55eebaa5f9f302dfe557cfa751bd7b2779863f1abd0343b6b/applicationinsights-0.11.10-py2.py3-none-any.whl", hash = "sha256:e89a890db1c6906b6a7d0bcfd617dac83974773c64573147c8d6654f9cf2a6ea", size = 55068, upload-time = "2021-04-22T23:22:44.451Z" },
+]
+
+[[package]]
+name = "attachment-evaluation-test"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "uipath" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "uipath", editable = "../../" }]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bidict"
+version = "0.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093, upload-time = "2024-02-18T19:09:05.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "graphtty"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/b3/0756e1b1e46b61a4db4a463a76ca113e62113742f97ac6cf383dd05d6a97/graphtty-0.1.8.tar.gz", hash = "sha256:069cd84764cc64d414928451071fc9c97c05becbf564c2f0278691a6451a8240", size = 638011, upload-time = "2026-02-15T12:47:17.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/a9/66d01580a4a92b576c056e9967d552a28ed836540eaf73b436474c514bc2/graphtty-0.1.8-py3-none-any.whl", hash = "sha256:4e19e6d66b9ef79e2715377163f61a6542b5b9ee00d50406b80a40d0ba094f67", size = 25474, upload-time = "2026-02-15T12:47:16.377Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mermaid-builder"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/57/d83e7e62de05adbba2476b7596ed4a253907a4f4c19be74c40e7ce2944dc/mermaid_builder-0.0.3.tar.gz", hash = "sha256:3016ef25668bcb28de4a4746aabdfaa531c06a7e7f89fa1596e6a274c7c73705", size = 7183, upload-time = "2024-06-14T17:14:51.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/7480454b7ee7de5c2c8561e83b4564196ecf1c9847e893dfbb51032e5a3b/mermaid_builder-0.0.3-py3-none-any.whl", hash = "sha256:decd7d25268bda7a520ce0cab7873e50fac1e33b41e5a1dd7daec5c0ae3c7ffb", size = 6696, upload-time = "2024-06-14T17:14:38.48Z" },
+]
+
+[[package]]
+name = "mockito"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/4b/d342e6910379d04557fc1c32ea63d49d0c630d0dbeb81240482fbf13be87/mockito-2.0.3.tar.gz", hash = "sha256:8cb4981b56b0b96295c9581fff55e3d669ecdbcdc547762a4f10b46ae4032aea", size = 217711, upload-time = "2026-03-15T17:27:22.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/bf/138a95593c5fbaca78090e5c10259a682ec0c544974188a9defb726dd8b1/mockito-2.0.3-py3-none-any.whl", hash = "sha256:c6b104bda0b4808d4f6063b877e2c59dbaada940aad8eebd16463b5f5d423da2", size = 51944, upload-time = "2026-03-15T17:27:21.534Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" },
+    { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" },
+    { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathlib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298, upload-time = "2014-09-03T15:41:57.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363, upload-time = "2022-05-04T13:37:20.585Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[[package]]
+name = "pysignalr"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "msgpack" },
+    { name = "orjson" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/a6/ac80bd4972604c6930050e8b0eba41d6fde41cb3286087be0188a8865f55/pysignalr-1.3.0.tar.gz", hash = "sha256:ca2e4372f213d82148fa2f060f0fefd096f1f66fca1107ac05e76ec6abd4cf52", size = 16790, upload-time = "2025-04-29T21:23:38.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/54/74e35563927ab8538e1bd1404b35027861434aecf2bcc945ff30c188e56d/pysignalr-1.3.0-py3-none-any.whl", hash = "sha256:423c91b0d1dc8387f37118ac2d1dc87ed6b9e01993a04612eab8452193f40344", size = 19966, upload-time = "2025-04-29T21:23:37.513Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-engineio"
+version = "4.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "simple-websocket" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/12/bdef9dbeedbe2cdeba2a2056ad27b1fb081557d34b69a97f574843462cae/python_engineio-4.13.1.tar.gz", hash = "sha256:0a853fcef52f5b345425d8c2b921ac85023a04dfcf75d7b74696c61e940fd066", size = 92348, upload-time = "2026-02-06T23:38:06.12Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/54/0cce26da03a981f949bb8449c9778537f75f5917c172e1d2992ff25cb57d/python_engineio-4.13.1-py3-none-any.whl", hash = "sha256:f32ad10589859c11053ad7d9bb3c9695cdf862113bfb0d20bc4d890198287399", size = 59847, upload-time = "2026-02-06T23:38:04.861Z" },
+]
+
+[[package]]
+name = "python-socketio"
+version = "5.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bidict" },
+    { name = "python-engineio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/81/cf8284f45e32efa18d3848ed82cdd4dcc1b657b082458fbe01ad3e1f2f8d/python_socketio-5.16.1.tar.gz", hash = "sha256:f863f98eacce81ceea2e742f6388e10ca3cdd0764be21d30d5196470edf5ea89", size = 128508, upload-time = "2026-02-06T23:42:07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c7/deb8c5e604404dbf10a3808a858946ca3547692ff6316b698945bb72177e/python_socketio-5.16.1-py3-none-any.whl", hash = "sha256:a3eb1702e92aa2f2b5d3ba00261b61f062cce51f1cfb6900bf3ab4d1934d2d35", size = 82054, upload-time = "2026-02-06T23:42:05.772Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "simple-websocket"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/59/0782e51887ac6b07ffd1570e0364cf901ebc36345fea669969d2084baebb/simple_websocket-1.1.0-py3-none-any.whl", hash = "sha256:4af6069630a38ed6c561010f0e11a5bc0d4ca569b36306eb257cd9a192497c8c", size = 13842, upload-time = "2024-10-10T22:39:29.645Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath"
+version = "2.10.30"
+source = { editable = "../../" }
+dependencies = [
+    { name = "applicationinsights" },
+    { name = "click" },
+    { name = "coverage" },
+    { name = "graphtty" },
+    { name = "httpx" },
+    { name = "mermaid-builder" },
+    { name = "mockito" },
+    { name = "pathlib" },
+    { name = "pydantic-function-models" },
+    { name = "pyjwt" },
+    { name = "pysignalr" },
+    { name = "python-dotenv" },
+    { name = "python-socketio" },
+    { name = "rich" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+    { name = "uipath-platform" },
+    { name = "uipath-runtime" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "applicationinsights", specifier = ">=0.11.10" },
+    { name = "click", specifier = ">=8.3.1" },
+    { name = "coverage", specifier = ">=7.8.2" },
+    { name = "graphtty", specifier = "==0.1.8" },
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "mermaid-builder", specifier = "==0.0.3" },
+    { name = "mockito", specifier = ">=1.5.4" },
+    { name = "pathlib", specifier = ">=1.0.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "pyjwt", specifier = ">=2.10.1" },
+    { name = "pysignalr", specifier = "==1.3.0" },
+    { name = "python-dotenv", specifier = ">=1.0.1" },
+    { name = "python-socketio", specifier = ">=5.15.0,<6.0.0" },
+    { name = "rich", specifier = ">=14.2.0" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+    { name = "uipath-platform", editable = "../../../uipath-platform" },
+    { name = "uipath-runtime", specifier = ">=0.9.1,<0.10.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "filelock", specifier = ">=3.20.3" },
+    { name = "inflection", specifier = ">=0.5.1" },
+    { name = "mkdocs", specifier = ">=1.6.1" },
+    { name = "mkdocs-click", specifier = ">=0.9.0" },
+    { name = "mkdocs-llmstxt", specifier = ">=0.5.0" },
+    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.7.0" },
+    { name = "mkdocs-open-in-new-tab", specifier = ">=1.0.8" },
+    { name = "mkdocs-simple-hooks", specifier = ">=0.1.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.30.1" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.5.1" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+    { name = "termynal", specifier = ">=0.13.1" },
+    { name = "tomli-w", specifier = ">=1.2.0" },
+    { name = "types-toml", specifier = ">=0.10.8" },
+    { name = "virtualenv", specifier = ">=20.36.1" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.7"
+source = { editable = "../../../uipath-core" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.8"
+source = { editable = "../../../uipath-platform" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "sqlparse", specifier = ">=0.5.5" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-runtime"
+version = "0.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/eb/774d503e174e17af84eabb9d315683c5616fb0da956f93f99cf79912a6ff/uipath_runtime-0.9.3.tar.gz", hash = "sha256:5010ede13919d6883a6373cd137c06c18de2b6e2e9fa6b65e11f2d255db444e5", size = 139338, upload-time = "2026-03-04T20:49:11.153Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/83/52dc4d5bf534368d753656881306dffeed658e5e7eefcb91fe6c3bd0dfac/uipath_runtime-0.9.3-py3-none-any.whl", hash = "sha256:20aefc8d9b23978032bec67d2057b5457059aaf1ea788a71d218ba8b6816ff98", size = 41766, upload-time = "2026-03-04T20:49:10.005Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "wsproto"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/79/12135bdf8b9c9367b8701c2c19a14c913c120b882d50b014ca0d38083c2c/wsproto-1.3.2.tar.gz", hash = "sha256:b86885dcf294e15204919950f666e06ffc6c7c114ca900b060d6e16293528294", size = 50116, upload-time = "2025-11-20T18:18:01.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath/samples/calculator/README.md b/packages/uipath/samples/calculator/README.md
new file mode 100644
index 000000000..b1c1fa4fd
--- /dev/null
+++ b/packages/uipath/samples/calculator/README.md
@@ -0,0 +1,27 @@
+# Simple UiPath Coded Agents
+
+This is a simple, standalone Coded Agent which does not require external dependencies.
+
+After initialization, execute the agent using this sample command:
+```
+uipath run main '{"a": 0, "b": 1, "operator": "+"}'
+```
+
+# Run evaluations
+```
+uipath eval main .\evaluations\eval-sets\default.json --no-report --output-file output.json
+```
+
+# Add and register custom evaluator
+
+1. (Optional) Add a new evaluator -> can be created manually in the evaluations/custom-evaluators directory
+```
+uipath add evaluator my_custom_evaluator
+```
+2. Implement the logic
+
+3. Register the evaluator
+```
+uipath register evaluator my_custom_evaluator
+```
+4. Apply it to any dataset
diff --git a/packages/uipath/samples/calculator/bindings.json b/packages/uipath/samples/calculator/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/calculator/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/context-precision-multi-model.json b/packages/uipath/samples/calculator/evaluations/eval-sets/context-precision-multi-model.json
new file mode 100644
index 000000000..101b85494
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/context-precision-multi-model.json
@@ -0,0 +1,30 @@
+{
+  "fileName": "context-precision-multi-model.json",
+  "id": "context-precision-multi-model-eval-set",
+  "name": "Multi-Model Context Precision Evaluation",
+  "batchSize": 10,
+  "evaluatorRefs": [
+    "ContextPrecisionEvaluatorClaude",
+    "ContextPrecisionEvaluatorGemini"
+  ],
+  "evaluations": [
+    {
+      "id": "test-context-precision-add-multi-model",
+      "name": "Test Add Context Precision with Multiple LLM Judges",
+      "inputs": {
+        "a": 7,
+        "b": 3,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 10.0
+      },
+      "evalSetId": "context-precision-multi-model-eval-set",
+      "createdAt": "2025-01-25T00:00:00.000Z",
+      "updatedAt": "2025-01-25T00:00:00.000Z"
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/crash-scenarios.json b/packages/uipath/samples/calculator/evaluations/eval-sets/crash-scenarios.json
new file mode 100644
index 000000000..898747e96
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/crash-scenarios.json
@@ -0,0 +1,78 @@
+{
+  "version": "1.0",
+  "id": "CrashScenarios",
+  "name": "Crash Scenarios Evaluation",
+  "evaluatorRefs": [],
+  "evaluations": [
+    {
+      "id": "crash-string-input-a",
+      "name": "Crash when input 'a' is a string",
+      "inputs": {
+        "a": "not a number",
+        "b": 5,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-string-input-b",
+      "name": "Crash when input 'b' is a string",
+      "inputs": {
+        "a": 10,
+        "b": "invalid",
+        "operator": "*"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-both-inputs-strings",
+      "name": "Crash when both inputs are strings",
+      "inputs": {
+        "a": "hello",
+        "b": "world",
+        "operator": "-"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-null-input-a",
+      "name": "Crash when input 'a' is null",
+      "inputs": {
+        "a": null,
+        "b": 25,
+        "operator": "/"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-boolean-input",
+      "name": "Crash when input is a boolean",
+      "inputs": {
+        "a": true,
+        "b": 3,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-array-input",
+      "name": "Crash when input is an array",
+      "inputs": {
+        "a": [1, 2, 3],
+        "b": 5,
+        "operator": "*"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "crash-object-input",
+      "name": "Crash when input is an object",
+      "inputs": {
+        "a": {"value": 10},
+        "b": 3,
+        "operator": "-"
+      },
+      "evaluationCriterias": {}
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/default.json b/packages/uipath/samples/calculator/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..68fb9aca1
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/default.json
@@ -0,0 +1,168 @@
+{
+  "version": "1.0",
+  "id": "NewSchemaSampleEval",
+  "name": "New Schema Sample Evaluation",
+  "evaluatorRefs": [
+    "ContainsEvaluator",
+    "ExactMatchEvaluator",
+    "JsonSimilarityEvaluator",
+    "LLMJudgeOutputEvaluator",
+    "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+    "TrajectoryEvaluator",
+    "CorrectOperatorEvaluator",
+    "LLMJudgeHaiku45",
+    "LLMJudgeSonnet45"
+  ],
+  "evaluations": [
+    {
+      "id": "test-random-multiplication-using-mockito",
+      "name": "Test Random Multiplication Using Mockito",
+      "inputs": {
+        "a": 2,
+        "b": 4,
+        "operator": "random"
+      },
+      "evaluationCriterias": {
+        "ContainsEvaluator": {
+          "searchText": "8"
+        },
+        "CorrectOperatorEvaluator": {
+          "operator": "*"
+        },
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": "8.0"
+          }
+        },
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeOutputEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeStrictJSONSimilarityOutputEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should correctly parse the multiply operation, perform the calculation 2 * 4, and return the result 8.0"
+        },
+        "LLMJudgeHaiku45": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeSonnet45": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        }
+      },
+      "mockingStrategy": {
+        "type": "mockito",
+        "behaviors": [
+          {
+            "function": "get_random_operator",
+            "arguments": {
+              "args": [],
+              "kwargs": {}
+            },
+            "then": [
+              {
+                "type": "return",
+                "value": {
+                  "result": "*"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "id": "default",
+      "name": "Add",
+      "inputs": {
+        "a": 1,
+        "b": 4,
+        "operator": "+"
+      },
+      "evaluationCriterias": {
+        "ContainsEvaluator": null,
+        "ExactMatchEvaluator": null,
+        "JsonSimilarityEvaluator": null,
+        "LLMJudgeOutputEvaluator": null,
+        "LLMJudgeStrictJSONSimilarityOutputEvaluator": null,
+        "TrajectoryEvaluator": null,
+        "CorrectOperatorEvaluator": null,
+        "LLMJudgeHaiku45": null,
+        "LLMJudgeSonnet45": null
+      }
+    },
+    {
+      "id": "override",
+      "name": "Multiply",
+      "inputs": {
+        "a": 2,
+        "b": 4,
+        "operator": "*"
+      },
+      "evaluationCriterias": {
+        "ContainsEvaluator": {
+          "searchText": "8"
+        },
+        "CorrectOperatorEvaluator": {
+          "operator": "*"
+        },
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": "8.0"
+          }
+        },
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeOutputEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeStrictJSONSimilarityOutputEvaluator": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should correctly parse the multiply operation, perform the calculation 2 * 4, and return the result 8.0"
+        },
+        "LLMJudgeHaiku45": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        },
+        "LLMJudgeSonnet45": {
+          "expectedOutput": {
+            "result": 8.0
+          }
+        }
+      }
+    },
+    {
+      "id": "skip",
+      "name": "Skip denial code check",
+      "inputs": {
+        "a": 1,
+        "b": 1,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output-llm-judge.json b/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output-llm-judge.json
new file mode 100644
index 000000000..6e8449de5
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output-llm-judge.json
@@ -0,0 +1,45 @@
+{
+  "version": "1.0",
+  "id": "EvalLevelExpectedOutputLLMJudgeSet",
+  "name": "Evaluation-Level expectedOutput with LLM Judge",
+  "evaluatorRefs": [
+    "ExactMatchEvaluator",
+    "LLMJudgeOutputEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "eval-level-llm-judge-add",
+      "name": "LLM Judge uses eval-level expectedOutput (addition)",
+      "inputs": {
+        "a": 3,
+        "b": 7,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 10.0
+      },
+      "expectedAgentBehavior": "The agent should correctly add the two numbers and return the result.",
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": null,
+        "LLMJudgeOutputEvaluator": null
+      }
+    },
+    {
+      "id": "eval-level-llm-judge-multiply",
+      "name": "LLM Judge uses eval-level expectedOutput (multiplication)",
+      "inputs": {
+        "a": 6,
+        "b": 8,
+        "operator": "*"
+      },
+      "expectedOutput": {
+        "result": 48.0
+      },
+      "expectedAgentBehavior": "The agent should correctly multiply the two numbers and return the result.",
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": null,
+        "LLMJudgeOutputEvaluator": null
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output.json b/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output.json
new file mode 100644
index 000000000..3d4b2f159
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/eval-level-expected-output.json
@@ -0,0 +1,100 @@
+{
+  "version": "1.0",
+  "id": "EvalLevelExpectedOutputSet",
+  "name": "Evaluation-Level expectedOutput Tests",
+  "evaluatorRefs": [
+    "ExactMatchEvaluator",
+    "JsonSimilarityEvaluator",
+    "ContainsEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "eval-level-null-criteria-add",
+      "name": "Eval-level expectedOutput with null criteria (addition)",
+      "inputs": {
+        "a": 2,
+        "b": 3,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 5.0
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": null,
+        "JsonSimilarityEvaluator": null,
+        "ContainsEvaluator": {
+          "searchText": "5"
+        }
+      }
+    },
+    {
+      "id": "eval-level-null-criteria-multiply",
+      "name": "Eval-level expectedOutput with null criteria (multiplication)",
+      "inputs": {
+        "a": 4,
+        "b": 5,
+        "operator": "*"
+      },
+      "expectedOutput": {
+        "result": 20.0
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": null,
+        "JsonSimilarityEvaluator": null,
+        "ContainsEvaluator": {
+          "searchText": "20"
+        }
+      }
+    },
+    {
+      "id": "eval-level-per-evaluator-override",
+      "name": "Per-evaluator expectedOutput overrides eval-level",
+      "inputs": {
+        "a": 10,
+        "b": 5,
+        "operator": "-"
+      },
+      "expectedOutput": {
+        "result": 5.0
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": 5.0
+          }
+        },
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "result": 5.0
+          }
+        },
+        "ContainsEvaluator": {
+          "searchText": "5"
+        }
+      }
+    },
+    {
+      "id": "eval-level-mixed-null-and-explicit",
+      "name": "Mixed: some evaluators null, some explicit",
+      "inputs": {
+        "a": 7,
+        "b": 3,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 10.0
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": null,
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "result": 10.0
+          }
+        },
+        "ContainsEvaluator": {
+          "searchText": "10"
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/faithfulness-multi-model.json b/packages/uipath/samples/calculator/evaluations/eval-sets/faithfulness-multi-model.json
new file mode 100644
index 000000000..113db790d
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/faithfulness-multi-model.json
@@ -0,0 +1,30 @@
+{
+  "fileName": "faithfulness-multi-model.json",
+  "id": "faithfulness-multi-model-eval-set",
+  "name": "Multi-Model Faithfulness Evaluation",
+  "batchSize": 10,
+  "evaluatorRefs": [
+    "FaithfulnessEvaluatorClaude",
+    "FaithfulnessEvaluatorGemini"
+  ],
+  "evaluations": [
+    {
+      "id": "test-faithfulness-add-multi-model",
+      "name": "Test Add Faithfulness with Multiple LLM Judges",
+      "inputs": {
+        "a": 7,
+        "b": 3,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 10.0
+      },
+      "evalSetId": "faithfulness-multi-model-eval-set",
+      "createdAt": "2025-01-25T00:00:00.000Z",
+      "updatedAt": "2025-01-25T00:00:00.000Z"
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/legacy.json b/packages/uipath/samples/calculator/evaluations/eval-sets/legacy.json
new file mode 100644
index 000000000..b5100f9da
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/legacy.json
@@ -0,0 +1,73 @@
+{
+  "fileName": "default.json",
+  "id": "default-eval-set-id",
+  "name": "Basic Calculator Evaluation Set",
+  "batchSize": 10,
+  "evaluatorRefs": [
+    "equality",
+    "equality-with-target-key",
+    "llm-as-a-judge",
+    "json-similarity",
+    "trajectory",
+    "llm-as-a-judge-haiku-4.5",
+    "llm-as-a-judge-sonnet-4.5"
+  ],
+  "evaluations": [
+    {
+      "id": "test-addition",
+      "name": "Test Addition",
+      "inputs": {
+        "a": 1,
+        "b": 1,
+        "operator": "+"
+      },
+      "expectedOutput": {
+        "result": 2.0
+      },
+      "expectedAgentBehavior": "The operation should produce the right output.",
+      "evalSetId": "default-eval-set-id",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    },
+    {
+      "id": "test-random-addition-using-llm",
+      "name": "Test Random Addition Using LLM",
+      "inputs": {
+        "a": 1,
+        "b": 1,
+        "operator": "random"
+      },
+      "expectedOutput": {
+        "result": 2.0
+      },
+      "expectedAgentBehavior": "The operation should produce the right output.",
+      "simulateTools": true,
+      "simulationInstructions": "The random operator is '+'.",
+      "toolsToSimulate": [
+          {
+            "name": "get_random_operator"
+          }
+      ],
+      "evalSetId": "default-eval-set-id",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    },
+    {
+      "id": "test-with-llm-input-mocking",
+      "name": "Test with LLM input mocking",
+      "inputs": {},
+      "expectedOutput": {
+        "result": 35
+      },
+      "expectedAgentBehavior": "The operation should produce the right output.",
+      "simulateInput": true,
+      "inputGenerationInstructions": "Generate a multiplication calculation where the first number is 5 and the second number is 7",
+      "evalSetId": "default-eval-set-id",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-09-04T18:54:58.379Z",
+  "updatedAt": "2025-09-04T18:55:55.416Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/multi-model.json b/packages/uipath/samples/calculator/evaluations/eval-sets/multi-model.json
new file mode 100644
index 000000000..642a846d1
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/multi-model.json
@@ -0,0 +1,65 @@
+{
+  "version": "1.0",
+  "id": "MultiModelLLMJudgeEval",
+  "name": "Multi-Model LLM Judge Evaluation",
+  "evaluatorRefs": [
+    "LLMJudgeOutputEvaluator",
+    "LLMJudgeOutputEvaluatorClaude",
+    "LLMJudgeOutputEvaluatorGemini",
+    "LLMJudgeStrictJSONSimilarityOutputEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "test-add-multi-model",
+      "name": "Test Add with Multiple LLM Judges",
+      "inputs": {
+        "a": 2,
+        "b": 3,
+        "operator": "+"
+      },
+      "evaluationCriterias": {
+        "LLMJudgeOutputEvaluator": {
+          "expectedOutput": {
+            "result": 5.0
+          }
+        },
+        "LLMJudgeOutputEvaluatorClaude": {
+          "expectedOutput": {
+            "result": 5.0
+          }
+        },
+        "LLMJudgeOutputEvaluatorGemini": {
+          "expectedOutput": {
+            "result": 5.0
+          }
+        }
+      }
+    },
+    {
+      "id": "test-multiply-multi-model",
+      "name": "Test Multiply with Multiple LLM Judges",
+      "inputs": {
+        "a": 4,
+        "b": 5,
+        "operator": "*"
+      },
+      "evaluationCriterias": {
+        "LLMJudgeOutputEvaluator": {
+          "expectedOutput": {
+            "result": 20.0
+          }
+        },
+        "LLMJudgeOutputEvaluatorClaude": {
+          "expectedOutput": {
+            "result": 20.0
+          }
+        },
+        "LLMJudgeOutputEvaluatorGemini": {
+          "expectedOutput": {
+            "result": 20.0
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/eval-sets/trajectory-multi-model.json b/packages/uipath/samples/calculator/evaluations/eval-sets/trajectory-multi-model.json
new file mode 100644
index 000000000..62a6143b0
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/eval-sets/trajectory-multi-model.json
@@ -0,0 +1,52 @@
+{
+  "version": "1.0",
+  "id": "TrajectoryMultiModelEval",
+  "name": "Multi-Model Trajectory Evaluation",
+  "evaluatorRefs": [
+    "TrajectoryEvaluator",
+    "TrajectoryEvaluatorClaude",
+    "TrajectoryEvaluatorGemini"
+  ],
+  "evaluations": [
+    {
+      "id": "test-trajectory-add-multi-model",
+      "name": "Test Add Trajectory with Multiple LLM Judges",
+      "inputs": {
+        "a": 7,
+        "b": 3,
+        "operator": "+"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should correctly add the two numbers and return the result 10."
+        },
+        "TrajectoryEvaluatorClaude": {
+          "expectedAgentBehavior": "The agent should correctly add the two numbers and return the result 10."
+        },
+        "TrajectoryEvaluatorGemini": {
+          "expectedAgentBehavior": "The agent should correctly add the two numbers and return the result 10."
+        }
+      }
+    },
+    {
+      "id": "test-trajectory-divide-multi-model",
+      "name": "Test Divide Trajectory with Multiple LLM Judges",
+      "inputs": {
+        "a": 20,
+        "b": 4,
+        "operator": "/"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should correctly divide the first number by the second and return the result 5."
+        },
+        "TrajectoryEvaluatorClaude": {
+          "expectedAgentBehavior": "The agent should correctly divide the first number by the second and return the result 5."
+        },
+        "TrajectoryEvaluatorGemini": {
+          "expectedAgentBehavior": "The agent should correctly divide the first number by the second and return the result 5."
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/contains.json b/packages/uipath/samples/calculator/evaluations/evaluators/contains.json
new file mode 100644
index 000000000..e73655257
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/contains.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "ContainsEvaluator",
+  "description": "Checks if the response text includes the expected denial code.",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "ContainsEvaluator",
+    "targetOutputKey": "result",
+    "negated": false,
+    "ignoreCase": false,
+    "defaultEvaluationCriteria": {
+      "searchText": "5"
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-claude.json b/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-claude.json
new file mode 100644
index 000000000..88a30d30d
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-claude.json
@@ -0,0 +1,13 @@
+{
+  "id": "ContextPrecisionEvaluatorClaude",
+  "fileName": "context-precision-claude.json",
+  "name": "Context Precision Evaluator (Claude)",
+  "description": "Uses Claude to evaluate the relevance of context chunks to queries.",
+  "category": 1,
+  "type": 8,
+  "model": "anthropic.claude-3-5-sonnet-20240620-v1:0",
+  "prompt": "Evaluate the relevance of each context chunk to the provided query.",
+  "targetOutputKey": "*",
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-gemini.json b/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-gemini.json
new file mode 100644
index 000000000..08d93fbc1
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/context-precision-gemini.json
@@ -0,0 +1,13 @@
+{
+  "id": "ContextPrecisionEvaluatorGemini",
+  "fileName": "context-precision-gemini.json",
+  "name": "Context Precision Evaluator (Gemini)",
+  "description": "Uses Gemini to evaluate the relevance of context chunks to queries.",
+  "category": 1,
+  "type": 8,
+  "model": "gemini-2.5-flash",
+  "prompt": "Evaluate the relevance of each context chunk to the provided query.",
+  "targetOutputKey": "*",
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/correct-operator-evaluator.json b/packages/uipath/samples/calculator/evaluations/evaluators/correct-operator-evaluator.json
new file mode 100644
index 000000000..86dbfbb87
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/correct-operator-evaluator.json
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "id": "CorrectOperatorEvaluator",
+  "evaluatorTypeId": "file://types/correct-operator-evaluator-types.json",
+  "evaluatorSchema": "file://correct_operator.py:CorrectOperatorEvaluator",
+  "description": "A custom evaluator that checks if the correct operator is being used by the agent ",
+  "evaluatorConfig": {
+    "name": "CorrectOperatorEvaluator",
+    "defaultEvaluationCriteria": {
+      "operator": "+"
+    },
+    "negated": false
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/custom/correct_operator.py b/packages/uipath/samples/calculator/evaluations/evaluators/custom/correct_operator.py
new file mode 100644
index 000000000..0e79f3445
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/custom/correct_operator.py
@@ -0,0 +1,76 @@
+import json
+
+from opentelemetry.sdk.trace import ReadableSpan
+
+from uipath.eval.evaluators import BaseEvaluationCriteria, BaseEvaluatorConfig
+from uipath.eval.evaluators.base_evaluator import (
+    BaseEvaluator,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.models import (
+    AgentExecution,
+    EvaluationResult,
+    NumericEvaluationResult,
+)
+
+
+class CorrectOperatorEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the contains evaluator."""
+
+    operator: str
+
+
+class CorrectOperatorEvaluatorConfig(
+    BaseEvaluatorConfig[CorrectOperatorEvaluationCriteria]
+):
+    """Configuration for the contains evaluator."""
+
+    name: str = "CorrectOperatorEvaluator"
+    negated: bool = False
+    default_evaluation_criteria: CorrectOperatorEvaluationCriteria = (
+        CorrectOperatorEvaluationCriteria(operator="+")
+    )
+
+
+class CorrectOperatorEvaluator(
+    BaseEvaluator[
+        CorrectOperatorEvaluationCriteria,
+        CorrectOperatorEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """A custom evaluator that checks if the correct operator is being used by the agent"""
+
+    def extract_operator_from_spans(self, agent_trace: list[ReadableSpan]) -> str:
+        for span in agent_trace:
+            if span.name == "track_operator":
+                if span.attributes:
+                    input_value_as_str = span.attributes.get("input.value", "{}")
+                    assert isinstance(input_value_as_str, str)
+                    input_value = json.loads(input_value_as_str)
+                    return input_value.get("operator")
+        raise Exception("No 'track_operator' span found")
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        return "CorrectOperatorEvaluator"
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: CorrectOperatorEvaluationCriteria,
+    ) -> EvaluationResult:
+        actual_operator = self.extract_operator_from_spans(agent_execution.agent_trace)
+        print(actual_operator)
+        is_expected_operator = evaluation_criteria.operator == actual_operator
+        if self.evaluator_config.negated:
+            is_expected_operator = not is_expected_operator
+        return NumericEvaluationResult(
+            score=float(is_expected_operator),
+            details=self.validate_justification(
+                {
+                    "expected": evaluation_criteria.operator,
+                    "actual": actual_operator,
+                }
+            ),
+        )
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/custom/types/correct-operator-evaluator-types.json b/packages/uipath/samples/calculator/evaluations/evaluators/custom/types/correct-operator-evaluator-types.json
new file mode 100644
index 000000000..af810a7f8
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/custom/types/correct-operator-evaluator-types.json
@@ -0,0 +1,57 @@
+{
+  "evaluatorTypeId": "CorrectOperatorEvaluator",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "CorrectOperatorEvaluationCriteria": {
+        "description": "Evaluation criteria for the contains evaluator.",
+        "properties": {
+          "operator": {
+            "title": "Operator",
+            "type": "string"
+          }
+        },
+        "required": [
+          "operator"
+        ],
+        "title": "CorrectOperatorEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the contains evaluator.",
+    "properties": {
+      "name": {
+        "default": "CorrectOperatorEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "defaultEvaluationCriteria": {
+        "$ref": "#/$defs/CorrectOperatorEvaluationCriteria",
+        "default": {
+          "operator": "+"
+        }
+      },
+      "negated": {
+        "default": false,
+        "title": "Negated",
+        "type": "boolean"
+      }
+    },
+    "title": "CorrectOperatorEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for the contains evaluator.",
+    "properties": {
+      "operator": {
+        "title": "Operator",
+        "type": "string"
+      }
+    },
+    "required": [
+      "operator"
+    ],
+    "title": "CorrectOperatorEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {}
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/exact-match.json b/packages/uipath/samples/calculator/evaluations/evaluators/exact-match.json
new file mode 100644
index 000000000..6e5c5fca1
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/exact-match.json
@@ -0,0 +1,17 @@
+{
+  "version": "1.0",
+  "id": "ExactMatchEvaluator",
+  "description": "Checks if the response text exactly matches the expected value.",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ExactMatchEvaluator",
+    "targetOutputKey": "result",
+    "negated": false,
+    "ignoreCase": false,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": "5.0"
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-claude.json b/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-claude.json
new file mode 100644
index 000000000..6e7aae4c2
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-claude.json
@@ -0,0 +1,13 @@
+{
+  "id": "FaithfulnessEvaluatorClaude",
+  "fileName": "faithfulness-claude.json",
+  "name": "Faithfulness Evaluator (Claude)",
+  "description": "Uses Claude to evaluate whether agent output claims are grounded in context.",
+  "category": 1,
+  "type": 9,
+  "model": "anthropic.claude-3-5-sonnet-20240620-v1:0",
+  "prompt": "Evaluate whether the agent output claims are grounded in the provided context sources.",
+  "targetOutputKey": "*",
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-gemini.json b/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-gemini.json
new file mode 100644
index 000000000..b3eb4d4bb
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/faithfulness-gemini.json
@@ -0,0 +1,13 @@
+{
+  "id": "FaithfulnessEvaluatorGemini",
+  "fileName": "faithfulness-gemini.json",
+  "name": "Faithfulness Evaluator (Gemini)",
+  "description": "Uses Gemini to evaluate whether agent output claims are grounded in context.",
+  "category": 1,
+  "type": 9,
+  "model": "gemini-2.5-flash",
+  "prompt": "Evaluate whether the agent output claims are grounded in the provided context sources.",
+  "targetOutputKey": "*",
+  "createdAt": "2025-01-25T00:00:00.000Z",
+  "updatedAt": "2025-01-25T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/json-similarity.json b/packages/uipath/samples/calculator/evaluations/evaluators/json-similarity.json
new file mode 100644
index 000000000..767b9c940
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/json-similarity.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "JsonSimilarityEvaluator",
+  "description": "Checks if the response JSON is similar to the expected JSON structure.",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "JsonSimilarityEvaluator",
+    "targetOutputKey": "*",
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality-with-target-key.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality-with-target-key.json
new file mode 100644
index 000000000..5b169ee38
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality-with-target-key.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "equality-with-target-key.json",
+    "id": "equality-with-target-key",
+    "name": "Legacy Equality Evaluator With Target Key",
+    "description": "An evaluator that judges the agent based on expected output under \"result\" key.",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "result",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality.json
new file mode 100644
index 000000000..10e073c8e
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-equality.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "equality.json",
+    "id": "equality",
+    "name": "Equality Evaluator",
+    "description": "An evaluator that judges the agent based on expected output.",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "*",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-json-similarity.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-json-similarity.json
new file mode 100644
index 000000000..dd1fca355
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-json-similarity.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "json-similarity.json",
+    "id": "json-similarity",
+    "name": "JSON Similarity Evaluator",
+    "description": "An evaluator that compares JSON structures with tolerance for numeric and string differences.",
+    "category": 0,
+    "type": 6,
+    "targetOutputKey": "*",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-haiku-4.5.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-haiku-4.5.json
new file mode 100644
index 000000000..5205d6733
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-haiku-4.5.json
@@ -0,0 +1,14 @@
+{
+  "fileName": "llm-as-a-judge-haiku-4.5.json",
+  "id": "llm-as-a-judge-haiku-4.5",
+  "name": "LLMAsAJudge Haiku 4.5 Evaluator",
+  "description": "An evaluator that judges the agent based on it's run history and expected behavior using Claude Haiku 4.5",
+  "category": 3,
+  "type": 7,
+  "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+  "targetOutputKey": "*",
+  "model": "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "maxTokens": 8000,
+  "createdAt": "2026-02-04T00:00:00.000Z",
+  "updatedAt": "2026-02-04T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-sonnet-4.5.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-sonnet-4.5.json
new file mode 100644
index 000000000..72e4e8a0d
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge-sonnet-4.5.json
@@ -0,0 +1,14 @@
+{
+  "fileName": "llm-as-a-judge-sonnet-4.5.json",
+  "id": "llm-as-a-judge-sonnet-4.5",
+  "name": "LLMAsAJudge Sonnet 4.5 Evaluator",
+  "description": "An evaluator that judges the agent based on it's run history and expected behavior using Claude Sonnet 4.5",
+  "category": 3,
+  "type": 7,
+  "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+  "targetOutputKey": "*",
+  "model": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "maxTokens": 8000,
+  "createdAt": "2026-02-04T00:00:00.000Z",
+  "updatedAt": "2026-02-04T00:00:00.000Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge.json
new file mode 100644
index 000000000..1b90f193f
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-llm-as-a-judge.json
@@ -0,0 +1,13 @@
+{
+  "fileName": "llm-as-a-judge.json",
+  "id": "llm-as-a-judge",
+  "name": "LLMAsAJudge Evaluator",
+  "description": "An evaluator that judges the agent based on it's run history and expected behavior",
+  "category": 3,
+  "type": 7,
+  "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+  "targetOutputKey": "*",
+  "model":"gpt-4.1-2025-04-14",
+  "createdAt": "2025-08-21T15:12:58.695Z",
+  "updatedAt": "2025-08-21T15:12:58.695Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/legacy-trajectory.json b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-trajectory.json
new file mode 100644
index 000000000..8d6e600ea
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/legacy-trajectory.json
@@ -0,0 +1,13 @@
+{
+  "fileName": "trajectory.json",
+  "id": "trajectory",
+  "name": "Trajectory Evaluator",
+  "description": "An evaluator that analyzes the execution trajectory and decision sequence taken by the agent.",
+  "category": 3,
+  "type": 7,
+  "prompt": "Evaluate the agent's execution trajectory based on the expected behavior.\n\nExpected Agent Behavior: {{ExpectedAgentBehavior}}\nAgent Run History: {{AgentRunHistory}}\n\nProvide a score from 0-100 based on how well the agent followed the expected trajectory.",
+  "model": "gpt-4.1-2025-04-14",
+  "targetOutputKey": "*",
+  "createdAt": "2025-06-26T17:45:39.651Z",
+  "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-claude.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-claude.json
new file mode 100644
index 000000000..9a558cdca
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-claude.json
@@ -0,0 +1,18 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluatorClaude",
+  "description": "Uses Claude to judge semantic similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluatorClaude",
+    "targetOutputKey": "*",
+    "model": "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    "prompt": "Compare the following outputs and evaluate their semantic similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nProvide a score from 0-100 where 100 means semantically identical and 0 means completely different.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-gemini.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-gemini.json
new file mode 100644
index 000000000..3687e48b6
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-gemini.json
@@ -0,0 +1,18 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluatorGemini",
+  "description": "Uses Gemini to judge semantic similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluatorGemini",
+    "targetOutputKey": "*",
+    "model": "gemini-2.5-flash",
+    "prompt": "Compare the following outputs and evaluate their semantic similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nProvide a score from 0-100 where 100 means semantically identical and 0 means completely different.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-haiku-4.5.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-haiku-4.5.json
new file mode 100644
index 000000000..494474d60
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-haiku-4.5.json
@@ -0,0 +1,19 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeHaiku45",
+  "description": "Uses Claude Haiku 4.5 to judge semantic similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeHaiku45",
+    "targetOutputKey": "*",
+    "model": "anthropic.claude-haiku-4-5-20251001-v1:0",
+    "prompt": "Compare the following outputs and evaluate their semantic similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nProvide a score from 0-100 where 100 means semantically identical and 0 means completely different.",
+    "temperature": 0.0,
+    "maxTokens": 8000,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-semantic-similarity.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-semantic-similarity.json
new file mode 100644
index 000000000..900d85c67
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-semantic-similarity.json
@@ -0,0 +1,18 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluator",
+  "description": "Uses an LLM to judge semantic similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluator",
+    "targetOutputKey": "*",
+    "model": "gpt-4.1-2025-04-14",
+    "prompt": "Compare the following outputs and evaluate their semantic similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nProvide a score from 0-100 where 100 means semantically identical and 0 means completely different.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-sonnet-4.5.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-sonnet-4.5.json
new file mode 100644
index 000000000..77fbb6b2c
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-sonnet-4.5.json
@@ -0,0 +1,19 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeSonnet45",
+  "description": "Uses Claude Sonnet 4.5 to judge semantic similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeSonnet45",
+    "targetOutputKey": "*",
+    "model": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+    "prompt": "Compare the following outputs and evaluate their semantic similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nProvide a score from 0-100 where 100 means semantically identical and 0 means completely different.",
+    "temperature": 0.0,
+    "maxTokens": 8000,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-strict-json-similarity.json b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-strict-json-similarity.json
new file mode 100644
index 000000000..2dcd94989
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/llm-judge-strict-json-similarity.json
@@ -0,0 +1,18 @@
+{
+  "version": "1.0",
+  "id": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+  "description": "Uses an LLM to judge strict JSON similarity between expected and actual output.",
+  "evaluatorTypeId": "uipath-llm-judge-output-strict-json-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+    "targetOutputKey": "*",
+    "model": "gpt-4.1-2025-04-14",
+    "prompt": "Compare the following JSON outputs for strict structural similarity.\n\nActual Output: {{ActualOutput}}\nExpected Output: {{ExpectedOutput}}\n\nEvaluate if the JSON structure and values match precisely. Provide a score from 0-100 where 100 means exact match and 0 means completely different.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "result": 5.0
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-claude.json b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-claude.json
new file mode 100644
index 000000000..e7e18233e
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-claude.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "TrajectoryEvaluatorClaude",
+  "description": "Uses Claude to evaluate the agent's execution trajectory and decision sequence.",
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+  "evaluatorConfig": {
+    "name": "TrajectoryEvaluatorClaude",
+    "model": "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    "prompt": "Evaluate the agent's execution trajectory based on the expected behavior.\n\nExpected Agent Behavior: {{ExpectedAgentBehavior}}\nAgent Run History: {{AgentRunHistory}}\n\nProvide a score from 0-100 based on how well the agent followed the expected trajectory.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedAgentBehavior": "The agent should correctly perform the calculation and return the result."
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-gemini.json b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-gemini.json
new file mode 100644
index 000000000..016a1a172
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory-gemini.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "TrajectoryEvaluatorGemini",
+  "description": "Uses Gemini to evaluate the agent's execution trajectory and decision sequence.",
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+  "evaluatorConfig": {
+    "name": "TrajectoryEvaluatorGemini",
+    "model": "gemini-2.5-flash",
+    "prompt": "Evaluate the agent's execution trajectory based on the expected behavior.\n\nExpected Agent Behavior: {{ExpectedAgentBehavior}}\nAgent Run History: {{AgentRunHistory}}\n\nProvide a score from 0-100 based on how well the agent followed the expected trajectory.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedAgentBehavior": "The agent should correctly perform the calculation and return the result."
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/evaluations/evaluators/trajectory.json b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory.json
new file mode 100644
index 000000000..2924d8a41
--- /dev/null
+++ b/packages/uipath/samples/calculator/evaluations/evaluators/trajectory.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "TrajectoryEvaluator",
+  "description": "Evaluates the agent's execution trajectory and decision sequence.",
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+  "evaluatorConfig": {
+    "name": "TrajectoryEvaluator",
+    "model": "gpt-4.1-2025-04-14",
+    "prompt": "Evaluate the agent's execution trajectory based on the expected behavior.\n\nExpected Agent Behavior: {{ExpectedAgentBehavior}}\nAgent Run History: {{AgentRunHistory}}\n\nProvide a score from 0-100 based on how well the agent followed the expected trajectory.",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedAgentBehavior": "The agent should correctly perform the calculation and return the result."
+    }
+  }
+}
diff --git a/packages/uipath/samples/calculator/main.py b/packages/uipath/samples/calculator/main.py
new file mode 100644
index 000000000..94497b799
--- /dev/null
+++ b/packages/uipath/samples/calculator/main.py
@@ -0,0 +1,87 @@
+import logging
+import random
+from enum import Enum
+
+from pydantic.dataclasses import dataclass
+
+from uipath.eval.mocks import ExampleCall, mockable
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+
+class Operator(Enum):
+    ADD = "+"
+    SUBTRACT = "-"
+    MULTIPLY = "*"
+    DIVIDE = "/"
+    RANDOM = "random"
+
+
+@dataclass
+class CalculatorInput:
+    a: float
+    b: float
+    operator: Operator
+
+
+@dataclass
+class CalculatorOutput:
+    result: float
+
+
+@dataclass
+class Wrapper:
+    # Testing nested objects
+    result: Operator
+
+
+GET_RANDOM_OPERATOR_EXAMPLES = [
+    ExampleCall(id="example", input="{}", output='{"result": "*"}')
+]
+
+
+@traced()
+@mockable(example_calls=GET_RANDOM_OPERATOR_EXAMPLES)
+async def get_random_operator() -> (
+    Wrapper
+):  # pragma: no cover (since eval mocks this function, ignore it from coverage!)
+    """Get a random operator."""
+    return Wrapper(
+        result=random.choice(
+            [Operator.ADD, Operator.SUBTRACT, Operator.MULTIPLY, Operator.DIVIDE]
+        )
+    )
+
+
+@traced(name="apply_operator", span_type="tool")
+def apply_operator(operator: Operator, a: float, b: float) -> CalculatorOutput:
+    match operator:
+        case Operator.ADD:
+            result = a + b
+        case Operator.SUBTRACT:
+            result = a - b
+        case Operator.MULTIPLY:
+            result = a * b
+        case Operator.DIVIDE:
+            result = a / b if b != 0.0 else 0.0
+        case _:
+            raise ValueError("Unknown operator")
+    return CalculatorOutput(result=result)
+
+
+@traced(name="track_operator")
+def track_operator(operator: Operator) -> None:
+    """Track which operator is being used."""
+    pass
+
+
+@traced()
+async def main(input: CalculatorInput) -> CalculatorOutput:
+    if input.operator == Operator.RANDOM:
+        operator = (await get_random_operator()).result
+    else:
+        operator = input.operator
+    track_operator(operator)
+    result = apply_operator(operator, input.a, input.b)
+    return result
diff --git a/packages/uipath/samples/calculator/output.json b/packages/uipath/samples/calculator/output.json
new file mode 100644
index 000000000..eaf5976f4
--- /dev/null
+++ b/packages/uipath/samples/calculator/output.json
@@ -0,0 +1,142 @@
+{
+  "evaluationSetName": "New Schema Sample Evaluation",
+  "evaluationSetResults": [
+    {
+      "evaluationName": "Add",
+      "evaluationRunResults": [
+        {
+          "evaluatorName": "ContainsEvaluator",
+          "evaluatorId": "ContainsEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "CorrectOperatorEvaluator",
+          "evaluatorId": "CorrectOperatorEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "ExactMatchEvaluator",
+          "evaluatorId": "ExactMatchEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "JsonSimilarityEvaluator",
+          "evaluatorId": "JsonSimilarityEvaluator",
+          "result": {
+            "score": 1.0,
+            "details": "Matched leaves: 1.0, Total leaves: 1.0",
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "LLMJudgeOutputEvaluator",
+          "evaluatorId": "LLMJudgeOutputEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.8266587257385254
+          }
+        },
+        {
+          "evaluatorName": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+          "evaluatorId": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.7479231357574463
+          }
+        },
+        {
+          "evaluatorName": "TrajectoryEvaluator",
+          "evaluatorId": "TrajectoryEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.17264103889465332
+          }
+        }
+      ],
+      "agentExecutionOutput": null
+    },
+    {
+      "evaluationName": "Multiply",
+      "evaluationRunResults": [
+        {
+          "evaluatorName": "ContainsEvaluator",
+          "evaluatorId": "ContainsEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "CorrectOperatorEvaluator",
+          "evaluatorId": "CorrectOperatorEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0010058879852294922
+          }
+        },
+        {
+          "evaluatorName": "ExactMatchEvaluator",
+          "evaluatorId": "ExactMatchEvaluator",
+          "result": {
+            "score": 1.0,
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "JsonSimilarityEvaluator",
+          "evaluatorId": "JsonSimilarityEvaluator",
+          "result": {
+            "score": 1.0,
+            "details": "Matched leaves: 1.0, Total leaves: 1.0",
+            "evaluationTime": 0.0
+          }
+        },
+        {
+          "evaluatorName": "LLMJudgeOutputEvaluator",
+          "evaluatorId": "LLMJudgeOutputEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.12008285522460938
+          }
+        },
+        {
+          "evaluatorName": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+          "evaluatorId": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.11328649520874023
+          }
+        },
+        {
+          "evaluatorName": "TrajectoryEvaluator",
+          "evaluatorId": "TrajectoryEvaluator",
+          "result": {
+            "score": 0.0,
+            "details": "Exception thrown by evaluator: Error: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 145, in request_async\n    response.raise_for_status()\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\httpx\\_models.py\", line 829, in raise_for_status\n    raise HTTPStatusError(message, request=request, response=self)\nhttpx.HTTPStatusError: Client error '401 Unauthorized' for url 'https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\eval\\evaluators\\llm_as_judge_evaluator.py\", line 176, in _get_llm_response\n    response = await self.llm_service(**request_data)\n               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\tracing\\_traced.py\", line 318, in async_wrapper\n    result = await func(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\llm_gateway_service.py\", line 551, in chat_completions\n    response = await self.request_async(\n               ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 189, in async_wrapped\n    return await copy(fn, *args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 111, in __call__\n    do = await self.iter(retry_state=retry_state)\n         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 153, in iter\n    result = await action(retry_state)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\_utils.py\", line 99, in inner\n    return call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\__init__.py\", line 400, in <lambda>\n    self._add_action_func(lambda rs: rs.outcome.result())\n                                     ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 449, in result\n    return self.__get_result()\n           ^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\AppData\\Roaming\\uv\\python\\cpython-3.12.9-windows-x86_64-none\\Lib\\concurrent\\futures\\_base.py\", line 401, in __get_result\n    raise self._exception\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\tenacity\\asyncio\\__init__.py\", line 114, in __call__\n    result = await fn(*args, **kwargs)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"C:\\Users\\cristian.pufu\\Documents\\GitHub\\uipath-python\\samples\\calculator\\.venv\\Lib\\site-packages\\uipath\\_services\\_base_service.py\", line 148, in request_async\n    raise EnrichedException(e) from e\nuipath.models.exceptions.EnrichedException: \nRequest URL: https://alpha.uipath.com/Ada/byoa/agenthub_/llm/api/chat/completions?api-version=2024-08-01-preview\nHTTP Method: POST\nStatus Code: 401\nResponse Content: No content\n",
+            "evaluationTime": 0.11751747131347656
+          }
+        }
+      ],
+      "agentExecutionOutput": null
+    },
+    {
+      "evaluationName": "Skip denial code check",
+      "evaluationRunResults": [],
+      "agentExecutionOutput": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/calculator/pyproject.toml b/packages/uipath/samples/calculator/pyproject.toml
new file mode 100644
index 000000000..5c91c7235
--- /dev/null
+++ b/packages/uipath/samples/calculator/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "calculator-agent"
+version = "0.0.1"
+description = "calculator-agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/calculator/uipath.json b/packages/uipath/samples/calculator/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/calculator/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/classification_agent/bindings.json b/packages/uipath/samples/classification_agent/bindings.json
new file mode 100644
index 000000000..5e9beeb01
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/bindings.json
@@ -0,0 +1,4 @@
+{
+  "version": "2.0",
+  "resources": []
+}
diff --git a/packages/uipath/samples/classification_agent/evaluations/eval-sets/default.json b/packages/uipath/samples/classification_agent/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..2066e63f3
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/evaluations/eval-sets/default.json
@@ -0,0 +1,123 @@
+{
+  "version": "1.0",
+  "id": "TeleComClassificationEval",
+  "name": "TeleCom Email Classification Evaluation",
+  "evaluatorRefs": [
+    "MulticlassClassificationEvaluator",
+    "BalancedAccuracyEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "payment-invoice",
+      "name": "Payment - Invoice reminder",
+      "inputs": {
+        "email_subject": "Your invoice is ready",
+        "email_body": "Dear customer, your monthly invoice of $45.99 is now available. Payment is due by March 15."
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "payments"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "payments"
+        }
+      }
+    },
+    {
+      "id": "payment-overdue",
+      "name": "Payment - Overdue balance",
+      "inputs": {
+        "email_subject": "Action required: overdue balance",
+        "email_body": "Your account has an overdue balance of $120.00. Please submit your payment as soon as possible to avoid service interruption."
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "payments"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "payments"
+        }
+      }
+    },
+    {
+      "id": "payment-refund",
+      "name": "Payment - Refund request (DELIBERATELY WRONG: ground truth set to 'spam')",
+      "inputs": {
+        "email_subject": "Refund for last month's charge",
+        "email_body": "I was charged $29.99 last month for a service I cancelled. Please process a refund to my account."
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "spam"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "spam"
+        }
+      }
+    },
+    {
+      "id": "payment-confirmation",
+      "name": "Payment - Confirmation (DELIBERATELY WRONG: ground truth set to 'spam')",
+      "inputs": {
+        "email_subject": "Payment confirmation",
+        "email_body": "Thank you for your payment of $85.00. Your account balance is now $0.00."
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "spam"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "spam"
+        }
+      }
+    },
+    {
+      "id": "plan-upgrade",
+      "name": "Plan - Upgrade inquiry",
+      "inputs": {
+        "email_subject": "How do I upgrade my plan?",
+        "email_body": "Hi, I currently have the 10GB data plan and would like to upgrade to the unlimited plan. Can you help?"
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "plan_details"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "plan_details"
+        }
+      }
+    },
+    {
+      "id": "plan-subscription",
+      "name": "Plan - Subscription details",
+      "inputs": {
+        "email_subject": "Question about my subscription",
+        "email_body": "I would like to know the details of my current plan including data limits and any upgrade options available."
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "plan_details"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "plan_details"
+        }
+      }
+    },
+    {
+      "id": "spam-promo",
+      "name": "Spam - Unsolicited promotion",
+      "inputs": {
+        "email_subject": "You won a FREE iPhone!!!",
+        "email_body": "Congratulations! You have been selected as the lucky winner. Click here to claim your prize now!"
+      },
+      "evaluationCriterias": {
+        "MulticlassClassificationEvaluator": {
+          "expectedClass": "spam"
+        },
+        "BalancedAccuracyEvaluator": {
+          "expectedClass": "spam"
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/classification_agent/evaluations/evaluators/balanced-accuracy.json b/packages/uipath/samples/classification_agent/evaluations/evaluators/balanced-accuracy.json
new file mode 100644
index 000000000..6401b698d
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/evaluations/evaluators/balanced-accuracy.json
@@ -0,0 +1,20 @@
+{
+  "version": "1.0",
+  "id": "BalancedAccuracyEvaluator",
+  "evaluatorTypeId": "file://types/balanced-accuracy-types.json",
+  "evaluatorSchema": "file://balanced_accuracy_evaluator.py:BalancedAccuracyEvaluator",
+  "description": "Balanced accuracy: mean of per-class recall rates. Uses weighted per-datapoint scores with a custom reduce_scores (sum instead of average).",
+  "evaluatorConfig": {
+    "name": "BalancedAccuracyEvaluator",
+    "targetOutputKey": "category",
+    "classes": ["plan_details", "payments", "spam"],
+    "classCounts": {
+      "payments": 2,
+      "plan_details": 2,
+      "spam": 3
+    },
+    "defaultEvaluationCriteria": {
+      "expectedClass": "spam"
+    }
+  }
+}
diff --git a/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/balanced_accuracy_evaluator.py b/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/balanced_accuracy_evaluator.py
new file mode 100644
index 000000000..3ef7fd806
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/balanced_accuracy_evaluator.py
@@ -0,0 +1,133 @@
+"""Balanced accuracy evaluator — custom evaluator with non-trivial score aggregation.
+
+Balanced accuracy = mean of per-class recall rates.
+
+Per-datapoint scores encode class weights:
+  - correct prediction: score = 1 / (num_classes * class_count_for_expected)
+  - wrong prediction:   score = 0
+
+Then reduce_scores sums the scores, which yields:
+  sum = Σ_k (correct_k / (K * n_k)) = (1/K) Σ_k (correct_k / n_k) = balanced_accuracy
+"""
+
+from uipath.eval.evaluators.base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.evaluators.output_evaluator import (
+    BaseOutputEvaluator,
+    OutputEvaluatorConfig,
+)
+from uipath.eval.models import (
+    AgentExecution,
+    EvaluationResult,
+    NumericEvaluationResult,
+)
+from uipath.eval.models.models import (
+    EvaluationResultDto,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+
+
+class BalancedAccuracyEvaluationCriteria(BaseEvaluationCriteria):
+    """Per-datapoint criteria: which class this sample should belong to."""
+
+    expected_class: str
+
+
+class BalancedAccuracyEvaluatorConfig(
+    OutputEvaluatorConfig[BalancedAccuracyEvaluationCriteria]
+):
+    """Evaluator config with class list and per-class sample counts."""
+
+    name: str = "BalancedAccuracyEvaluator"
+    classes: list[str]
+    class_counts: dict[str, int]
+
+
+class BalancedAccuracyJustification(BaseEvaluatorJustification):
+    """Details about how this datapoint was scored."""
+
+    predicted_class: str
+    expected_class: str
+    weight: float
+    is_match: bool
+
+
+class BalancedAccuracyEvaluator(
+    BaseOutputEvaluator[
+        BalancedAccuracyEvaluationCriteria,
+        BalancedAccuracyEvaluatorConfig,
+        BalancedAccuracyJustification,
+    ]
+):
+    """Balanced accuracy: mean of per-class recall rates.
+
+    Uses weighted per-datapoint scores so that reduce_scores = sum()
+    gives the correct balanced accuracy.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return "custom-balanced-accuracy"
+
+    @staticmethod
+    def reduce_scores(results: list[EvaluationResultDto]) -> float:
+        """Sum of pre-weighted scores = balanced accuracy."""
+        return sum(r.score for r in results)
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: BalancedAccuracyEvaluationCriteria,
+    ) -> EvaluationResult:
+        predicted_class = str(self._get_actual_output(agent_execution)).lower()
+        expected_class = evaluation_criteria.expected_class.lower()
+        classes = [c.lower() for c in self.evaluator_config.classes]
+        class_counts = {
+            k.lower(): v for k, v in self.evaluator_config.class_counts.items()
+        }
+
+        if expected_class not in classes:
+            raise UiPathEvaluationError(
+                code="INVALID_EXPECTED_CLASS",
+                title="Expected class not in configured classes",
+                detail=f"Expected class '{expected_class}' is not in the configured classes: {classes}",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        if predicted_class not in classes:
+            raise UiPathEvaluationError(
+                code="INVALID_PREDICTED_CLASS",
+                title="Predicted class not in configured classes",
+                detail=f"Predicted class '{predicted_class}' is not in the configured classes: {classes}",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        num_classes = len(classes)
+        n_k = class_counts.get(expected_class)
+        if n_k is None or n_k <= 0:
+            raise UiPathEvaluationError(
+                code="INVALID_CLASS_COUNT",
+                title="Missing or invalid class count",
+                detail=f"class_counts must include a positive count for '{expected_class}'",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        weight = 1.0 / (num_classes * n_k)
+        is_match = predicted_class == expected_class
+        score = weight if is_match else 0.0
+
+        justification = self.validate_justification(
+            {
+                "expected": expected_class,
+                "actual": predicted_class,
+                "predicted_class": predicted_class,
+                "expected_class": expected_class,
+                "weight": weight,
+                "is_match": is_match,
+            }
+        )
+        return NumericEvaluationResult(score=score, details=justification)
diff --git a/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/types/balanced-accuracy-types.json b/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/types/balanced-accuracy-types.json
new file mode 100644
index 000000000..389317434
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/evaluations/evaluators/custom/types/balanced-accuracy-types.json
@@ -0,0 +1,71 @@
+{
+  "evaluatorTypeId": "custom-balanced-accuracy",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "BalancedAccuracyEvaluationCriteria": {
+        "description": "Per-datapoint criteria: which class this sample should belong to.",
+        "properties": {
+          "expectedClass": {
+            "title": "Expected Class",
+            "type": "string"
+          }
+        },
+        "required": ["expectedClass"],
+        "title": "BalancedAccuracyEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Evaluator config with class list and per-class sample counts.",
+    "properties": {
+      "name": {
+        "default": "BalancedAccuracyEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "targetOutputKey": {
+        "default": "*",
+        "title": "Target Output Key",
+        "type": "string"
+      },
+      "defaultEvaluationCriteria": {
+        "$ref": "#/$defs/BalancedAccuracyEvaluationCriteria",
+        "default": {
+          "expectedClass": "spam"
+        }
+      },
+      "classes": {
+        "items": { "type": "string" },
+        "title": "Classes",
+        "type": "array"
+      },
+      "classCounts": {
+        "additionalProperties": { "type": "integer" },
+        "title": "Class Counts",
+        "type": "object"
+      }
+    },
+    "required": ["classes", "classCounts"],
+    "title": "BalancedAccuracyEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Per-datapoint criteria: which class this sample should belong to.",
+    "properties": {
+      "expectedClass": {
+        "title": "Expected Class",
+        "type": "string"
+      }
+    },
+    "required": ["expectedClass"],
+    "title": "BalancedAccuracyEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "properties": {
+      "predictedClass": { "type": "string" },
+      "expectedClass": { "type": "string" },
+      "weight": { "type": "number" },
+      "isMatch": { "type": "boolean" }
+    }
+  }
+}
diff --git a/packages/uipath/samples/classification_agent/evaluations/evaluators/multiclass-classification.json b/packages/uipath/samples/classification_agent/evaluations/evaluators/multiclass-classification.json
new file mode 100644
index 000000000..8f573589b
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/evaluations/evaluators/multiclass-classification.json
@@ -0,0 +1,16 @@
+{
+  "version": "1.0",
+  "id": "MulticlassClassificationEvaluator",
+  "description": "Checks if the predicted email category matches the expected category using macro-averaged precision",
+  "evaluatorTypeId": "uipath-multiclass-classification",
+  "evaluatorConfig": {
+    "name": "MulticlassClassificationEvaluator",
+    "targetOutputKey": "category",
+    "classes": ["plan_details", "payments", "spam"],
+    "metricType": "precision",
+    "averaging": "macro",
+    "defaultEvaluationCriteria": {
+      "expectedClass": "spam"
+    }
+  }
+}
diff --git a/packages/uipath/samples/classification_agent/main.py b/packages/uipath/samples/classification_agent/main.py
new file mode 100644
index 000000000..d987e79b7
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/main.py
@@ -0,0 +1,53 @@
+"""TeleCom customer support email classification agent."""
+
+from dataclasses import dataclass
+
+from uipath.tracing import traced
+
+PAYMENT_KEYWORDS = {"payment", "bill", "invoice", "charge", "balance", "due", "overdue"}
+PLAN_KEYWORDS = {
+    "plan",
+    "upgrade",
+    "data",
+    "unlimited",
+    "downgrade",
+    "subscription",
+    "gb",
+}
+
+
+@dataclass
+class ClassificationInput:
+    email_subject: str
+    email_body: str
+
+
+@dataclass
+class ClassificationOutput:
+    category: str
+
+
+@traced(name="classify_email", span_type="tool")
+def classify_email(subject: str, body: str) -> str:
+    """Classify an email into a category based on keyword matching."""
+    text = f"{subject} {body}".lower()
+    tokens = set(text.split())
+
+    payment_hits = len(tokens & PAYMENT_KEYWORDS)
+    plan_hits = len(tokens & PLAN_KEYWORDS)
+
+    if payment_hits > plan_hits:
+        return "payments"
+    if plan_hits > payment_hits:
+        return "plan_details"
+    if payment_hits > 0:
+        return "payments"
+
+    return "spam"
+
+
+@traced()
+async def main(input: ClassificationInput) -> ClassificationOutput:
+    """Classify a customer support email for TeleCom Telecom."""
+    category = classify_email(input.email_subject, input.email_body)
+    return ClassificationOutput(category=category)
diff --git a/packages/uipath/samples/classification_agent/pyproject.toml b/packages/uipath/samples/classification_agent/pyproject.toml
new file mode 100644
index 000000000..b0cb005a9
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/pyproject.toml
@@ -0,0 +1,9 @@
+[project]
+name = "classification-agent"
+version = "0.0.1"
+description = "TeleCom customer support email classification agent"
+requires-python = ">=3.11"
+dependencies = ["uipath"]
+
+[dependency-groups]
+dev = ["uipath-dev"]
diff --git a/packages/uipath/samples/classification_agent/uipath.json b/packages/uipath/samples/classification_agent/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/classification_agent/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/csv-processor/.claude/commands/eval.md b/packages/uipath/samples/csv-processor/.claude/commands/eval.md
new file mode 100644
index 000000000..15fa04f7c
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/.claude/commands/eval.md
@@ -0,0 +1,287 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create and run agent evaluations
+---
+
+I'll help you create and run evaluations for your UiPath agent.
+
+## Step 1: Check project setup
+
+Let me check your project structure:
+
+!ls -la evaluations/ entry-points.json 2>/dev/null || echo "NEEDS_SETUP"
+
+# Check if schemas might be stale (main.py newer than entry-points.json)
+!if [ -f main.py ] && [ -f entry-points.json ] && [ main.py -nt entry-points.json ]; then echo "SCHEMAS_MAY_BE_STALE"; fi
+
+### If NEEDS_SETUP
+
+If `entry-points.json` doesn't exist, initialize the project first:
+
+!uv run uipath init
+
+Then re-run this skill.
+
+### If SCHEMAS_MAY_BE_STALE
+
+Your `main.py` is newer than `entry-points.json`. Refresh schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 2: What would you like to do?
+
+1. **Create new eval set** - Set up evaluations from scratch
+2. **Add test case** - Add a test to existing eval set
+3. **Run evaluations** - Execute tests and see results
+4. **Analyze failures** - Debug failing tests
+
+---
+
+## Creating an Eval Set
+
+First, create the directory structure:
+
+!mkdir -p evaluations/eval-sets evaluations/evaluators
+
+Read the agent's Input/Output schema from entry-points.json to understand the data types.
+
+### Evaluator Selection Guide
+
+| If your output is... | Use this evaluator | evaluatorTypeId |
+|---------------------|-------------------|-----------------|
+| Exact string/number | `ExactMatchEvaluator` | `uipath-exact-match` |
+| Contains key phrases | `ContainsEvaluator` | `uipath-contains` |
+| Semantically correct | `LLMJudgeOutputEvaluator` | `uipath-llm-judge-output-semantic-similarity` |
+| JSON with numbers | `JsonSimilarityEvaluator` | `uipath-json-similarity` |
+
+### Step 1: Create Evaluator Config Files
+
+**Each evaluator needs a JSON config file** in `evaluations/evaluators/`.
+
+**ExactMatchEvaluator** (`evaluations/evaluators/exact-match.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ExactMatchEvaluator",
+  "name": "ExactMatchEvaluator",
+  "description": "Checks for exact output match",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ExactMatchEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**LLMJudgeOutputEvaluator** (`evaluations/evaluators/llm-judge-output.json`):
+```json
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluator",
+  "name": "LLMJudgeOutputEvaluator",
+  "description": "Uses LLM to judge semantic similarity",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluator",
+    "model": "gpt-4o-mini-2024-07-18"
+  }
+}
+```
+
+**JsonSimilarityEvaluator** (`evaluations/evaluators/json-similarity.json`):
+```json
+{
+  "version": "1.0",
+  "id": "JsonSimilarityEvaluator",
+  "name": "JsonSimilarityEvaluator",
+  "description": "Compares JSON structures",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "JsonSimilarityEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**ContainsEvaluator** (`evaluations/evaluators/contains.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ContainsEvaluator",
+  "name": "ContainsEvaluator",
+  "description": "Checks if output contains text",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "ContainsEvaluator"
+  }
+}
+```
+
+### Step 2: Create Eval Set
+
+**Eval Set Template** (`evaluations/eval-sets/default.json`):
+```json
+{
+  "version": "1.0",
+  "id": "default-eval-set",
+  "name": "Default Evaluation Set",
+  "evaluatorRefs": ["ExactMatchEvaluator"],
+  "evaluations": [
+    {
+      "id": "test-1",
+      "name": "Test description",
+      "inputs": {
+        "field": "value"
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": "expected value"
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+**Important notes:**
+- `evaluatorRefs` must list ALL evaluators used in any test case
+- Each evaluator in `evaluatorRefs` needs a matching JSON config in `evaluations/evaluators/`
+- `evaluationCriterias` keys must match entries in `evaluatorRefs`
+- Use `expectedOutput` for most evaluators
+- LLM evaluators need `model` in their config. Available models are defined in the SDK's `ChatModels` class (`uipath.platform.chat.ChatModels`):
+  - `gpt-4o-mini-2024-07-18` (recommended for cost-efficiency)
+  - `gpt-4o-2024-08-06` (higher quality, higher cost)
+  - `o3-mini-2025-01-31` (latest reasoning model)
+  - Model availability varies by region and tenant configuration
+  - Check your UiPath Automation Cloud portal under AI Trust Layer for available models in your region
+
+---
+
+## Adding a Test Case
+
+When adding a test to an existing eval set:
+
+1. Read the existing eval set
+2. Check which evaluators are in `evaluatorRefs`
+3. Add the new test to `evaluations` array
+4. If using a new evaluator, add it to `evaluatorRefs`
+
+### Test Case Template
+
+```json
+{
+  "id": "test-{n}",
+  "name": "Description of what this tests",
+  "inputs": { },
+  "evaluationCriterias": {
+    "EvaluatorName": {
+      "expectedOutput": { }
+    }
+  }
+}
+```
+
+---
+
+## Running Evaluations
+
+First, read entry-points.json to get the entrypoint name (e.g., `main`):
+
+!uv run uipath eval main evaluations/eval-sets/default.json --output-file eval-results.json
+
+**Note:** Replace `main` with your actual entrypoint from entry-points.json.
+
+### Analyze Results
+
+After running, read `eval-results.json` and show:
+- Pass/fail summary table
+- For failures: expected vs actual output
+- Suggestions for fixing or changing evaluators
+
+### Results Format
+
+```json
+{
+  "evaluationSetResults": [{
+    "evaluationRunResults": [
+      {
+        "evaluationId": "test-1",
+        "evaluatorId": "ExactMatchEvaluator",
+        "result": { "score": 1.0 },
+        "errorMessage": null
+      }
+    ]
+  }]
+}
+```
+
+- Score 1.0 = PASS
+- Score < 1.0 = FAIL (show expected vs actual)
+- errorMessage present = ERROR (show message)
+
+---
+
+## Evaluator Reference
+
+### Deterministic Evaluators
+
+**ExactMatchEvaluator** - Exact output matching
+```json
+"ExactMatchEvaluator": {
+  "expectedOutput": { "result": "exact value" }
+}
+```
+
+**ContainsEvaluator** - Output contains substring
+```json
+"ContainsEvaluator": {
+  "searchText": "must contain this"
+}
+```
+
+**JsonSimilarityEvaluator** - JSON comparison with tolerance
+```json
+"JsonSimilarityEvaluator": {
+  "expectedOutput": { "value": 10.0 }
+}
+```
+
+### LLM-Based Evaluators
+
+**LLMJudgeOutputEvaluator** - Semantic correctness
+```json
+"LLMJudgeOutputEvaluator": {
+  "expectedOutput": { "summary": "Expected semantic meaning" }
+}
+```
+
+**LLMJudgeTrajectoryEvaluator** - Validate agent reasoning
+```json
+"LLMJudgeTrajectoryEvaluator": {
+  "expectedAgentBehavior": "The agent should first fetch data, then process it"
+}
+```
+
+---
+
+## Common Issues
+
+### "No evaluations found"
+- Check `evaluations/eval-sets/` directory exists
+- Verify JSON file is valid
+
+### Evaluator not found
+- Each evaluator needs a JSON config file in `evaluations/evaluators/`
+- Config file must have correct `evaluatorTypeId` (see templates above)
+- Config file must have `name` field at root level
+- LLM evaluators need `model` in `evaluatorConfig`
+
+### Evaluator skipped
+- Ensure evaluator is listed in root `evaluatorRefs` array
+- Check evaluator config file exists in `evaluations/evaluators/`
+
+### Schema mismatch
+- Run `uv run uipath init --no-agents-md-override` to refresh schemas
+- Check `entry-points.json` matches your Input/Output models
diff --git a/packages/uipath/samples/csv-processor/.claude/commands/new-agent.md b/packages/uipath/samples/csv-processor/.claude/commands/new-agent.md
new file mode 100644
index 000000000..b1d051866
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/.claude/commands/new-agent.md
@@ -0,0 +1,103 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create a new UiPath coded agent from a description
+---
+
+I'll help you create a new UiPath coded agent.
+
+## Step 1: Check existing project
+
+Let me check if this is an existing UiPath project:
+
+!ls uipath.json main.py 2>/dev/null || echo "NEW_PROJECT"
+
+## Step 2: Gather requirements
+
+**What should this agent do?**
+
+Please describe:
+
+-   What inputs it needs (e.g., "a file path and bucket name")
+-   What it should accomplish (e.g., "process CSV data")
+-   What outputs it should return (e.g., "total count and status")
+
+I'll generate the agent structure based on your description.
+
+## Step 3: Generate agent
+
+After you describe the agent, I will:
+
+1. Create `main.py` with Input/Output Pydantic models and `async def main()`
+2. Add entrypoint to `uipath.json` under `"functions": {"agent_name": "main.py:main"}`
+3. Run `uv run uipath init --no-agents-md-override` to generate schemas
+
+**Template structure** (from .agent/REQUIRED_STRUCTURE.md):
+
+```python
+from pydantic import BaseModel
+from uipath.platform import UiPath
+
+class Input(BaseModel):
+    """Input fields for the agent."""
+    # Fields based on your description
+    pass
+
+
+class Output(BaseModel):
+    """Output fields returned by the agent."""
+    # Fields based on your description
+    pass
+
+
+async def main(input: Input) -> Output:
+    """Main entry point for the agent.
+
+    Args:
+        input: The input data for the agent.
+
+    Returns:
+        The output data from the agent.
+    """
+
+    uipath = UiPath()
+
+    # TODO: Implement agent logic
+    return Output()
+```
+
+**Important notes:**
+
+-   Use `async def main` - many SDK methods are async
+-   Initialize `UiPath()` inside the function, not at module level
+-   After creating main.py, add entrypoint to `uipath.json` under `"functions"`
+
+## Step 4: Update entry-point schemas
+
+After creating main.py, regenerate the schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 5: Verify
+
+Quick test to verify the setup:
+
+!uv run uipath run main '{}' 2>&1 | head -30
+
+## Summary
+
+Once complete, you'll have:
+
+| File                | Purpose                             |
+| ------------------- | ----------------------------------- |
+| `main.py`           | Agent code with Input/Output models |
+| `uipath.json`       | Project configuration               |
+| `entry-points.json` | Entry point schemas                 |
+| `bindings.json`     | Resource bindings                   |
+| `.agent/`           | SDK and CLI reference docs          |
+
+**Next steps:**
+
+1. Implement your logic in `main()`
+2. Test: `uv run uipath run main '{"field": "value"}'`
+3. Create `eval_set.json` for evaluations
+4. Evaluate: `uv run uipath eval`
diff --git a/packages/uipath/samples/csv-processor/bindings.json b/packages/uipath/samples/csv-processor/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/csv-processor/evaluations/eval-sets/file-input-tests-local.json b/packages/uipath/samples/csv-processor/evaluations/eval-sets/file-input-tests-local.json
new file mode 100644
index 000000000..70ebd24ff
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/eval-sets/file-input-tests-local.json
@@ -0,0 +1,74 @@
+{
+  "version": "1.0",
+  "id": "FileInputTestsLocalEval",
+  "name": "File Input Scenario Tests (Local Mode)",
+  "evaluatorRefs": [
+    "CSVShapeEvaluator",
+    "CSVColumnsEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "test-sales-data-csv",
+      "name": "Test Sales Data CSV Processing",
+      "description": "Test processing of sales_data.csv with 5 rows and 5 columns",
+      "inputs": {
+        "attachment": {
+          "ID": "11111111-1111-1111-1111-111111111111",
+          "FullName": "../../samples/csv-processor/test-data/sales_data.csv",
+          "MimeType": "text/csv"
+        }
+      },
+      "evaluationCriterias": {
+        "CSVShapeEvaluator": {
+          "expected_rows": 5,
+          "expected_columns": 5
+        },
+        "CSVColumnsEvaluator": {
+          "expected_columns": ["date", "product", "quantity", "price", "total"]
+        }
+      }
+    },
+    {
+      "id": "test-large-dataset-csv",
+      "name": "Test Large Dataset CSV Processing",
+      "description": "Test processing of large_dataset.csv with 5 rows and 13 columns",
+      "inputs": {
+        "attachment": {
+          "ID": "22222222-2222-2222-2222-222222222222",
+          "FullName": "../../samples/csv-processor/test-data/large_dataset.csv",
+          "MimeType": "text/csv"
+        }
+      },
+      "evaluationCriterias": {
+        "CSVShapeEvaluator": {
+          "expected_rows": 5,
+          "expected_columns": 13
+        },
+        "CSVColumnsEvaluator": {
+          "expected_columns": ["id", "name", "email", "department", "salary", "status"]
+        }
+      }
+    },
+    {
+      "id": "test-minimal-csv",
+      "name": "Test Minimal CSV Processing",
+      "description": "Test processing of minimal.csv with 1 row and 2 columns",
+      "inputs": {
+        "attachment": {
+          "ID": "33333333-3333-3333-3333-333333333333",
+          "FullName": "../../samples/csv-processor/test-data/minimal.csv",
+          "MimeType": "text/csv"
+        }
+      },
+      "evaluationCriterias": {
+        "CSVShapeEvaluator": {
+          "expected_rows": 1,
+          "expected_columns": 2
+        },
+        "CSVColumnsEvaluator": {
+          "expected_columns": ["id", "value"]
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/attachment_created_evaluator.json b/packages/uipath/samples/csv-processor/evaluations/evaluators/attachment_created_evaluator.json
new file mode 100644
index 000000000..f4b352c20
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/attachment_created_evaluator.json
@@ -0,0 +1,12 @@
+{
+  "version": "1.0",
+  "id": "AttachmentCreatedEvaluator",
+  "description": "Checks if the agent successfully created an output attachment with processed CSV information",
+  "evaluatorSchema": "file://attachment_created_evaluator.py:AttachmentCreatedEvaluator",
+  "evaluatorConfig": {
+    "name": "AttachmentCreatedEvaluator",
+    "defaultEvaluationCriteria": {
+      "attachment_name": "processed_output.txt"
+    }
+  }
+}
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_columns_evaluator.json b/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_columns_evaluator.json
new file mode 100644
index 000000000..bddeea0ff
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_columns_evaluator.json
@@ -0,0 +1,12 @@
+{
+  "version": "1.0",
+  "id": "CSVColumnsEvaluator",
+  "description": "Checks if the expected CSV column names are correctly identified in the output",
+  "evaluatorSchema": "file://csv_columns_evaluator.py:CSVColumnsEvaluator",
+  "evaluatorConfig": {
+    "name": "CSVColumnsEvaluator",
+    "defaultEvaluationCriteria": {
+      "expected_columns": []
+    }
+  }
+}
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_shape_evaluator.json b/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_shape_evaluator.json
new file mode 100644
index 000000000..c829b9466
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/csv_shape_evaluator.json
@@ -0,0 +1,13 @@
+{
+  "version": "1.0",
+  "id": "CSVShapeEvaluator",
+  "description": "Checks if the CSV shape information (rows, columns) is correct in the output",
+  "evaluatorSchema": "file://csv_shape_evaluator.py:CSVShapeEvaluator",
+  "evaluatorConfig": {
+    "name": "CSVShapeEvaluator",
+    "defaultEvaluationCriteria": {
+      "expected_rows": 1,
+      "expected_columns": 1
+    }
+  }
+}
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/attachment_created_evaluator.py b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/attachment_created_evaluator.py
new file mode 100644
index 000000000..0b46e77b9
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/attachment_created_evaluator.py
@@ -0,0 +1,89 @@
+from uipath.eval.evaluators import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.models import AgentExecution, EvaluationResult, NumericEvaluationResult
+
+
+class AttachmentCreatedEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the attachment created evaluator."""
+
+    attachment_name: str = "processed_output.txt"
+
+
+class AttachmentCreatedEvaluatorConfig(
+    BaseEvaluatorConfig[AttachmentCreatedEvaluationCriteria]
+):
+    """Configuration for the attachment created evaluator."""
+
+    name: str = "AttachmentCreatedEvaluator"
+    default_evaluation_criteria: AttachmentCreatedEvaluationCriteria = (
+        AttachmentCreatedEvaluationCriteria()
+    )
+
+
+class AttachmentCreatedEvaluator(
+    BaseEvaluator[
+        AttachmentCreatedEvaluationCriteria,
+        AttachmentCreatedEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """A custom evaluator that checks if the agent successfully created an output attachment."""
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        return "AttachmentCreatedEvaluator"
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: AttachmentCreatedEvaluationCriteria,
+    ) -> EvaluationResult:
+        # Check if the agent created an attachment by looking for:
+        # 1. Span with name containing "create_attachment"
+        # 2. Or output containing attachment ID/information
+
+        attachment_created = False
+
+        # Look for attachment creation in traces
+        for span in agent_execution.agent_trace:
+            # Check span name for attachment operations
+            if "attachment" in span.name.lower() or "create" in span.name.lower():
+                attachment_created = True
+                break
+
+            # Check span attributes for attachment information
+            if span.attributes:
+                for attr_key, attr_value in span.attributes.items():
+                    if isinstance(attr_value, str):
+                        if (
+                            "attachment" in attr_key.lower()
+                            or evaluation_criteria.attachment_name in attr_value
+                        ):
+                            attachment_created = True
+                            break
+
+            if attachment_created:
+                break
+
+        # Also check if output contains attachment information
+        if not attachment_created and agent_execution.agent_output:
+            output_str = str(agent_execution.agent_output)
+            if (
+                "attachment" in output_str.lower()
+                or evaluation_criteria.attachment_name in output_str
+            ):
+                attachment_created = True
+
+        return NumericEvaluationResult(
+            score=float(attachment_created),
+            details=self.validate_justification(
+                {
+                    "expected": evaluation_criteria.attachment_name,
+                    "actual": "found" if attachment_created else "not found",
+                }
+            ),
+        )
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_columns_evaluator.py b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_columns_evaluator.py
new file mode 100644
index 000000000..29efe1ce7
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_columns_evaluator.py
@@ -0,0 +1,95 @@
+from typing import List
+
+from uipath.eval.evaluators import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.models import AgentExecution, EvaluationResult, NumericEvaluationResult
+
+
+class CSVColumnsEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the CSV columns evaluator."""
+
+    expected_columns: List[str]
+
+
+class CSVColumnsEvaluatorConfig(BaseEvaluatorConfig[CSVColumnsEvaluationCriteria]):
+    """Configuration for the CSV columns evaluator."""
+
+    name: str = "CSVColumnsEvaluator"
+    default_evaluation_criteria: CSVColumnsEvaluationCriteria = (
+        CSVColumnsEvaluationCriteria(expected_columns=[])
+    )
+
+
+class CSVColumnsEvaluator(
+    BaseEvaluator[
+        CSVColumnsEvaluationCriteria,
+        CSVColumnsEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """A custom evaluator that checks if the CSV column names are correctly identified."""
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        return "CSVColumnsEvaluator"
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: CSVColumnsEvaluationCriteria,
+    ) -> EvaluationResult:
+        # Check if all expected columns are mentioned in the output
+        # The agent writes: f"CSV shape {df.shape}\n\nCSV columns {df.columns}"
+
+        columns_found = set()
+        total_columns = len(evaluation_criteria.expected_columns)
+
+        if total_columns == 0:
+            return NumericEvaluationResult(
+                score=1.0,
+                details=self.validate_justification({"expected": "[]", "actual": "[]"}),
+            )
+
+        # Look for column names in agent traces (where print output is captured)
+        for span in agent_execution.agent_trace:
+            # Check span attributes
+            if span.attributes:
+                for attr_value in span.attributes.values():
+                    if isinstance(attr_value, str):
+                        for column in evaluation_criteria.expected_columns:
+                            if column in attr_value:
+                                columns_found.add(column)
+
+            # Check span events (where stdout might be captured)
+            if hasattr(span, "events") and span.events:
+                for event in span.events:
+                    if hasattr(event, "attributes") and event.attributes:
+                        for attr_value in event.attributes.values():
+                            if isinstance(attr_value, str):
+                                for column in evaluation_criteria.expected_columns:
+                                    if column in attr_value:
+                                        columns_found.add(column)
+
+        # Also check in the output
+        if len(columns_found) < total_columns and agent_execution.agent_output:
+            output_str = str(agent_execution.agent_output)
+            for column in evaluation_criteria.expected_columns:
+                if column in output_str:
+                    columns_found.add(column)
+
+        # Calculate score as ratio of found columns
+        score = len(columns_found) / total_columns
+
+        return NumericEvaluationResult(
+            score=score,
+            details=self.validate_justification(
+                {
+                    "expected": str(sorted(evaluation_criteria.expected_columns)),
+                    "actual": str(sorted(columns_found)),
+                }
+            ),
+        )
diff --git a/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_shape_evaluator.py b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_shape_evaluator.py
new file mode 100644
index 000000000..deb2b83f4
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/evaluations/evaluators/custom/csv_shape_evaluator.py
@@ -0,0 +1,87 @@
+from uipath.eval.evaluators import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from uipath.eval.models import AgentExecution, EvaluationResult, NumericEvaluationResult
+
+
+class CSVShapeEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the CSV shape evaluator."""
+
+    expected_rows: int
+    expected_columns: int
+
+
+class CSVShapeEvaluatorConfig(BaseEvaluatorConfig[CSVShapeEvaluationCriteria]):
+    """Configuration for the CSV shape evaluator."""
+
+    name: str = "CSVShapeEvaluator"
+    default_evaluation_criteria: CSVShapeEvaluationCriteria = (
+        CSVShapeEvaluationCriteria(expected_rows=1, expected_columns=1)
+    )
+
+
+class CSVShapeEvaluator(
+    BaseEvaluator[
+        CSVShapeEvaluationCriteria,
+        CSVShapeEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """A custom evaluator that checks if the CSV shape information is correct in the output attachment."""
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        return "CSVShapeEvaluator"
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: CSVShapeEvaluationCriteria,
+    ) -> EvaluationResult:
+        # The agent prints: "CSV shape (rows, columns)\nCSV columns [...]"
+        # We need to find this in the captured output
+
+        expected_shape = f"({evaluation_criteria.expected_rows}, {evaluation_criteria.expected_columns})"
+        shape_found = False
+
+        # Check agent traces (where print output is captured)
+        for span in agent_execution.agent_trace:
+            # Check span attributes
+            if span.attributes:
+                for attr_value in span.attributes.values():
+                    if isinstance(attr_value, str) and expected_shape in attr_value:
+                        shape_found = True
+                        break
+
+            # Check span events (where stdout might be captured)
+            if hasattr(span, "events") and span.events:
+                for event in span.events:
+                    if hasattr(event, "attributes") and event.attributes:
+                        for attr_value in event.attributes.values():
+                            if (
+                                isinstance(attr_value, str)
+                                and expected_shape in attr_value
+                            ):
+                                shape_found = True
+                                break
+
+            if shape_found:
+                break
+
+        # Check agent output
+        if not shape_found and agent_execution.agent_output:
+            output_str = str(agent_execution.agent_output)
+            shape_found = expected_shape in output_str
+
+        return NumericEvaluationResult(
+            score=float(shape_found),
+            details=self.validate_justification(
+                {
+                    "expected": expected_shape,
+                    "actual": "found" if shape_found else "not found",
+                }
+            ),
+        )
diff --git a/packages/uipath/samples/csv-processor/main.py b/packages/uipath/samples/csv-processor/main.py
new file mode 100644
index 000000000..db2a8c8ec
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/main.py
@@ -0,0 +1,57 @@
+import io
+import logging
+import os
+
+import pandas as pd
+from pydantic import BaseModel
+
+from uipath.platform import UiPath
+from uipath.platform.attachments import Attachment
+from uipath.platform.common import UiPathConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Input(BaseModel):
+    attachment: Attachment
+
+
+class Output(BaseModel):
+    processing_output: str
+
+
+async def main(input: Input) -> Output:
+    # Check if full_name points to a local file (for testing)
+    attachment_path = input.attachment.full_name
+
+    if os.path.exists(attachment_path):
+        # Local file mode for testing
+        logger.info(f"Reading local file: {attachment_path}")
+        with open(attachment_path, "rb") as f:
+            df = pd.read_csv(io.BytesIO(f.read()))
+            processing_output = (
+                f"CSV shape {df.shape}\n\nCSV columns {df.columns.tolist()}"
+            )
+            logger.info(f"Processed CSV: {processing_output}")
+            print(processing_output)
+            return Output(processing_output=processing_output)
+    else:
+        # Platform mode - use attachment API
+        uipath = UiPath()
+        async with uipath.attachments.open_async(attachment=input.attachment) as (
+            attachment,
+            response,
+        ):
+            async for raw_bytes in response.aiter_raw():
+                df = pd.read_csv(io.BytesIO(raw_bytes))
+
+                processing_output = (
+                    f"CSV shape {df.shape}\n\nCSV columns {df.columns.tolist()}"
+                )
+                await uipath.jobs.create_attachment_async(
+                    name="processed_output.txt",
+                    content=str(processing_output),
+                    folder_key=UiPathConfig.folder_key,
+                    job_key=UiPathConfig.job_key,
+                )
+                return Output(processing_output=processing_output)
diff --git a/packages/uipath/samples/csv-processor/pyproject.toml b/packages/uipath/samples/csv-processor/pyproject.toml
new file mode 100644
index 000000000..e69fc2697
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "csv-processor"
+version = "0.0.1"
+description = "csv-processor"
+dependencies = [
+  "uipath",
+  "pandas>=2.3.3",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/csv-processor/test-data/large_dataset.csv b/packages/uipath/samples/csv-processor/test-data/large_dataset.csv
new file mode 100644
index 000000000..2596e085b
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/test-data/large_dataset.csv
@@ -0,0 +1,6 @@
+id,name,email,age,department,salary,hire_date,address,city,state,zip,phone,status
+1,John Doe,john@example.com,30,Engineering,75000,2020-01-15,123 Main St,New York,NY,10001,555-0101,Active
+2,Jane Smith,jane@example.com,28,Marketing,65000,2021-03-20,456 Oak Ave,Los Angeles,CA,90001,555-0102,Active
+3,Bob Johnson,bob@example.com,35,Sales,70000,2019-06-10,789 Pine Rd,Chicago,IL,60601,555-0103,Active
+4,Alice Brown,alice@example.com,32,Engineering,80000,2018-11-05,321 Elm St,Houston,TX,77001,555-0104,On Leave
+5,Charlie Wilson,charlie@example.com,29,HR,60000,2022-02-28,654 Maple Dr,Phoenix,AZ,85001,555-0105,Active
diff --git a/packages/uipath/samples/csv-processor/test-data/minimal.csv b/packages/uipath/samples/csv-processor/test-data/minimal.csv
new file mode 100644
index 000000000..a8d8d2c21
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/test-data/minimal.csv
@@ -0,0 +1,2 @@
+id,value
+1,test
diff --git a/packages/uipath/samples/csv-processor/test-data/sales_data.csv b/packages/uipath/samples/csv-processor/test-data/sales_data.csv
new file mode 100644
index 000000000..155cdd47e
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/test-data/sales_data.csv
@@ -0,0 +1,6 @@
+date,product,quantity,price,total
+2024-01-01,Laptop,5,999.99,4999.95
+2024-01-02,Mouse,15,25.50,382.50
+2024-01-03,Keyboard,10,75.00,750.00
+2024-01-04,Monitor,3,299.99,899.97
+2024-01-05,Headphones,8,150.00,1200.00
diff --git a/packages/uipath/samples/csv-processor/uipath.json b/packages/uipath/samples/csv-processor/uipath.json
new file mode 100644
index 000000000..2f1e23ce5
--- /dev/null
+++ b/packages/uipath/samples/csv-processor/uipath.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {"main": "main.py:main"}
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/csv_employee_generator/bindings.json b/packages/uipath/samples/csv_employee_generator/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/csv_employee_generator/entry-points.json b/packages/uipath/samples/csv_employee_generator/entry-points.json
new file mode 100644
index 000000000..c4a691d10
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/entry-points.json
@@ -0,0 +1,55 @@
+{
+    "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+    "$id": "entry-points.json",
+    "entryPoints": [
+        {
+            "filePath": "main",
+            "uniqueId": "d3fdfadf-469d-408a-89bb-9f3202467632",
+            "type": "function",
+            "input": {
+                "type": "object",
+                "properties": {
+                    "department": {
+                        "title": "Department",
+                        "type": "string"
+                    },
+                    "count": {
+                        "default": 3,
+                        "title": "Count",
+                        "type": "integer"
+                    }
+                },
+                "required": [
+                    "department"
+                ],
+                "title": "Input"
+            },
+            "output": {
+                "type": "object",
+                "properties": {
+                    "csv_data": {
+                        "title": "Csv Data",
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "csv_data"
+                ],
+                "title": "Output"
+            },
+            "graph": {
+                "nodes": [
+                    {
+                        "id": "main.py:72",
+                        "name": "main",
+                        "type": "function",
+                        "metadata": {
+                            "file": "main.py"
+                        }
+                    }
+                ],
+                "edges": []
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/csv_employee_generator/evaluations/eval-sets/employee_csv_eval_set.json b/packages/uipath/samples/csv_employee_generator/evaluations/eval-sets/employee_csv_eval_set.json
new file mode 100644
index 000000000..1ca4d905e
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/evaluations/eval-sets/employee_csv_eval_set.json
@@ -0,0 +1,130 @@
+{
+  "id": "employee-csv-eval",
+  "name": "Employee CSV Generator Evaluation",
+  "description": "Tests the CSV employee generator agent with various scenarios",
+  "fileName": "employee_csv_eval_set.json",
+  "createdAt": "2025-01-01T00:00:00Z",
+  "updatedAt": "2025-01-01T00:00:00Z",
+  "evaluatorRefs": [
+    "csv-name-match",
+    "csv-name-age-match",
+    "csv-line-by-line-name"
+  ],
+  "evaluations": [
+    {
+      "id": "eng-3-name-only",
+      "name": "Engineering - 3 employees - Name only",
+      "inputs": {
+        "department": "Engineering",
+        "count": 3
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nAlice Johnson,28,Software Engineer\nBob Smith,32,Senior Engineer\nCarol Davis,26,DevOps Engineer"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    },
+    {
+      "id": "eng-3-name-age",
+      "name": "Engineering - 3 employees - Name and Age",
+      "inputs": {
+        "department": "Engineering",
+        "count": 3
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nAlice Johnson,28,Software Engineer\nBob Smith,32,Senior Engineer\nCarol Davis,26,DevOps Engineer"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    },
+    {
+      "id": "sales-2-name-age",
+      "name": "Sales - 2 employees - Name and Age",
+      "inputs": {
+        "department": "Sales",
+        "count": 2
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nFrank Brown,30,Sales Rep\nGrace Lee,27,Account Manager"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    },
+    {
+      "id": "hr-2-line-by-line",
+      "name": "HR - 2 employees - Line by line Name check",
+      "inputs": {
+        "department": "HR",
+        "count": 2
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nKelly White,34,HR Manager\nLiam Garcia,28,Recruiter"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    },
+    {
+      "id": "eng-wrong-name-fail",
+      "name": "Engineering - Wrong name (should fail)",
+      "inputs": {
+        "department": "Engineering",
+        "count": 3
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nWrong Name,28,Software Engineer\nBob Smith,32,Senior Engineer\nCarol Davis,26,DevOps Engineer"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    },
+    {
+      "id": "eng-partial-match",
+      "name": "Engineering - Line by line with partial match",
+      "inputs": {
+        "department": "Engineering",
+        "count": 3
+      },
+      "expectedOutput": {
+        "csv_data": "Name,Age,Role\nAlice Johnson,28,Software Engineer\nWrong Name,32,Senior Engineer\nCarol Davis,26,DevOps Engineer"
+      },
+      "evaluationCriterias": {
+        "csv-name-match": null,
+        "csv-name-age-match": null,
+        "csv-line-by-line-name": null
+      },
+      "evalSetId": "employee-csv-eval",
+      "createdAt": "2025-01-01T00:00:00Z",
+      "updatedAt": "2025-01-01T00:00:00Z"
+    }
+  ],
+  "modelSettings": []
+}
diff --git a/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_line_by_line_name.json b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_line_by_line_name.json
new file mode 100644
index 000000000..6ed580995
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_line_by_line_name.json
@@ -0,0 +1,14 @@
+{
+  "fileName": "csv_line_by_line_name.json",
+  "id": "csv-line-by-line-name",
+  "name": "CSV Line-by-Line Name Match",
+  "description": "Checks if Name column matches for each row in the CSV output",
+  "category": 0,
+  "type": 10,
+  "targetSubOutputKey": "Name",
+  "targetOutputKey": "csv_data",
+  "lineByLineEvaluation": true,
+  "lineDelimiter": "\n",
+  "createdAt": "2025-01-01T00:00:00Z",
+  "updatedAt": "2025-01-01T00:00:00Z"
+}
diff --git a/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_age_match.json b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_age_match.json
new file mode 100644
index 000000000..c27403e19
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_age_match.json
@@ -0,0 +1,12 @@
+{
+  "fileName": "csv_name_age_match.json",
+  "id": "csv-name-age-match",
+  "name": "CSV Name and Age Match",
+  "description": "Checks if Name and Age columns match in the CSV output",
+  "category": 0,
+  "type": 10,
+  "targetSubOutputKey": "Name,Age",
+  "targetOutputKey": "csv_data",
+  "createdAt": "2025-01-01T00:00:00Z",
+  "updatedAt": "2025-01-01T00:00:00Z"
+}
diff --git a/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_match.json b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_match.json
new file mode 100644
index 000000000..336032b4b
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/evaluations/evaluators/csv_name_match.json
@@ -0,0 +1,12 @@
+{
+  "fileName": "csv_name_match.json",
+  "id": "csv-name-match",
+  "name": "CSV Name Column Match",
+  "description": "Checks if the Name column matches in the CSV output",
+  "category": 0,
+  "type": 10,
+  "targetSubOutputKey": "Name",
+  "targetOutputKey": "csv_data",
+  "createdAt": "2025-01-01T00:00:00Z",
+  "updatedAt": "2025-01-01T00:00:00Z"
+}
diff --git a/packages/uipath/samples/csv_employee_generator/main.py b/packages/uipath/samples/csv_employee_generator/main.py
new file mode 100644
index 000000000..b5d5218f3
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/main.py
@@ -0,0 +1,72 @@
+"""CSV Employee Generator Agent.
+
+This agent generates employee data in CSV format based on the department and count.
+"""
+
+from pydantic import BaseModel
+
+
+class Input(BaseModel):
+    """Input schema for employee generation."""
+
+    department: str
+    count: int = 3
+
+
+class Output(BaseModel):
+    """Output schema with CSV data."""
+
+    csv_data: str
+
+
+def main(input: Input) -> Output:
+    """Generate employee CSV data based on department and count.
+
+    Args:
+        input: Request with department and count
+
+    Returns:
+        Output with CSV formatted employee data
+    """
+    # Employee database by department
+    employees_by_dept = {
+        "Engineering": [
+            ("Alice Johnson", 28, "Software Engineer"),
+            ("Bob Smith", 32, "Senior Engineer"),
+            ("Carol Davis", 26, "DevOps Engineer"),
+            ("David Wilson", 35, "Tech Lead"),
+            ("Eve Martinez", 29, "QA Engineer"),
+        ],
+        "Sales": [
+            ("Frank Brown", 30, "Sales Rep"),
+            ("Grace Lee", 27, "Account Manager"),
+            ("Henry Taylor", 33, "Sales Director"),
+            ("Ivy Chen", 25, "Sales Associate"),
+            ("Jack Kumar", 31, "Regional Manager"),
+        ],
+        "HR": [
+            ("Kelly White", 34, "HR Manager"),
+            ("Liam Garcia", 28, "Recruiter"),
+            ("Maya Patel", 29, "HR Specialist"),
+            ("Noah Johnson", 32, "Training Coordinator"),
+            ("Olivia Rodriguez", 26, "HR Assistant"),
+        ],
+    }
+
+    # Get employees for the requested department
+    department = input.department
+    count = min(input.count, 5)  # Max 5 employees per department
+
+    if department not in employees_by_dept:
+        # Return empty result for unknown department
+        csv_lines = ["Name,Age,Role"]
+        return Output(csv_data="\n".join(csv_lines))
+
+    employees = employees_by_dept[department][:count]
+
+    # Generate CSV
+    csv_lines = ["Name,Age,Role"]
+    for name, age, role in employees:
+        csv_lines.append(f"{name},{age},{role}")
+
+    return Output(csv_data="\n".join(csv_lines))
diff --git a/packages/uipath/samples/csv_employee_generator/pyproject.toml b/packages/uipath/samples/csv_employee_generator/pyproject.toml
new file mode 100644
index 000000000..6fa8b4b61
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "csv-employee-generator"
+version = "0.0.1"
+description = "csv-employee-generator"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath"
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../..", editable = true }
diff --git a/packages/uipath/samples/csv_employee_generator/uipath.json b/packages/uipath/samples/csv_employee_generator/uipath.json
new file mode 100644
index 000000000..7854b316e
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/uipath.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "main.py:main"
+  },
+  "agents": {}
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/csv_employee_generator/uv.lock b/packages/uipath/samples/csv_employee_generator/uv.lock
new file mode 100644
index 000000000..4ac5d0af4
--- /dev/null
+++ b/packages/uipath/samples/csv_employee_generator/uv.lock
@@ -0,0 +1,1605 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "applicationinsights"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f2/46a75ac6096d60da0e71a068015b610206e697de01fa2fb5bba8564b0798/applicationinsights-0.11.10.tar.gz", hash = "sha256:0b761f3ef0680acf4731906dfc1807faa6f2a57168ae74592db0084a6099f7b3", size = 44722, upload-time = "2021-04-22T23:22:45.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/0d/cb6b23164eb55eebaa5f9f302dfe557cfa751bd7b2779863f1abd0343b6b/applicationinsights-0.11.10-py2.py3-none-any.whl", hash = "sha256:e89a890db1c6906b6a7d0bcfd617dac83974773c64573147c8d6654f9cf2a6ea", size = 55068, upload-time = "2021-04-22T23:22:44.451Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bidict"
+version = "0.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093, upload-time = "2024-02-18T19:09:05.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[[package]]
+name = "csv-employee-generator"
+version = "0.0.1"
+source = { virtual = "." }
+dependencies = [
+    { name = "uipath" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "uipath", editable = "../../" }]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "graphtty"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/b3/0756e1b1e46b61a4db4a463a76ca113e62113742f97ac6cf383dd05d6a97/graphtty-0.1.8.tar.gz", hash = "sha256:069cd84764cc64d414928451071fc9c97c05becbf564c2f0278691a6451a8240", size = 638011, upload-time = "2026-02-15T12:47:17.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/a9/66d01580a4a92b576c056e9967d552a28ed836540eaf73b436474c514bc2/graphtty-0.1.8-py3-none-any.whl", hash = "sha256:4e19e6d66b9ef79e2715377163f61a6542b5b9ee00d50406b80a40d0ba094f67", size = 25474, upload-time = "2026-02-15T12:47:16.377Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mermaid-builder"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/57/d83e7e62de05adbba2476b7596ed4a253907a4f4c19be74c40e7ce2944dc/mermaid_builder-0.0.3.tar.gz", hash = "sha256:3016ef25668bcb28de4a4746aabdfaa531c06a7e7f89fa1596e6a274c7c73705", size = 7183, upload-time = "2024-06-14T17:14:51.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/7480454b7ee7de5c2c8561e83b4564196ecf1c9847e893dfbb51032e5a3b/mermaid_builder-0.0.3-py3-none-any.whl", hash = "sha256:decd7d25268bda7a520ce0cab7873e50fac1e33b41e5a1dd7daec5c0ae3c7ffb", size = 6696, upload-time = "2024-06-14T17:14:38.48Z" },
+]
+
+[[package]]
+name = "mockito"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/4b/d342e6910379d04557fc1c32ea63d49d0c630d0dbeb81240482fbf13be87/mockito-2.0.3.tar.gz", hash = "sha256:8cb4981b56b0b96295c9581fff55e3d669ecdbcdc547762a4f10b46ae4032aea", size = 217711, upload-time = "2026-03-15T17:27:22.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/bf/138a95593c5fbaca78090e5c10259a682ec0c544974188a9defb726dd8b1/mockito-2.0.3-py3-none-any.whl", hash = "sha256:c6b104bda0b4808d4f6063b877e2c59dbaada940aad8eebd16463b5f5d423da2", size = 51944, upload-time = "2026-03-15T17:27:21.534Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" },
+    { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" },
+    { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathlib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298, upload-time = "2014-09-03T15:41:57.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363, upload-time = "2022-05-04T13:37:20.585Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[[package]]
+name = "pysignalr"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "msgpack" },
+    { name = "orjson" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/a6/ac80bd4972604c6930050e8b0eba41d6fde41cb3286087be0188a8865f55/pysignalr-1.3.0.tar.gz", hash = "sha256:ca2e4372f213d82148fa2f060f0fefd096f1f66fca1107ac05e76ec6abd4cf52", size = 16790, upload-time = "2025-04-29T21:23:38.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/54/74e35563927ab8538e1bd1404b35027861434aecf2bcc945ff30c188e56d/pysignalr-1.3.0-py3-none-any.whl", hash = "sha256:423c91b0d1dc8387f37118ac2d1dc87ed6b9e01993a04612eab8452193f40344", size = 19966, upload-time = "2025-04-29T21:23:37.513Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-engineio"
+version = "4.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "simple-websocket" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/12/bdef9dbeedbe2cdeba2a2056ad27b1fb081557d34b69a97f574843462cae/python_engineio-4.13.1.tar.gz", hash = "sha256:0a853fcef52f5b345425d8c2b921ac85023a04dfcf75d7b74696c61e940fd066", size = 92348, upload-time = "2026-02-06T23:38:06.12Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/54/0cce26da03a981f949bb8449c9778537f75f5917c172e1d2992ff25cb57d/python_engineio-4.13.1-py3-none-any.whl", hash = "sha256:f32ad10589859c11053ad7d9bb3c9695cdf862113bfb0d20bc4d890198287399", size = 59847, upload-time = "2026-02-06T23:38:04.861Z" },
+]
+
+[[package]]
+name = "python-socketio"
+version = "5.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bidict" },
+    { name = "python-engineio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/81/cf8284f45e32efa18d3848ed82cdd4dcc1b657b082458fbe01ad3e1f2f8d/python_socketio-5.16.1.tar.gz", hash = "sha256:f863f98eacce81ceea2e742f6388e10ca3cdd0764be21d30d5196470edf5ea89", size = 128508, upload-time = "2026-02-06T23:42:07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c7/deb8c5e604404dbf10a3808a858946ca3547692ff6316b698945bb72177e/python_socketio-5.16.1-py3-none-any.whl", hash = "sha256:a3eb1702e92aa2f2b5d3ba00261b61f062cce51f1cfb6900bf3ab4d1934d2d35", size = 82054, upload-time = "2026-02-06T23:42:05.772Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "simple-websocket"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/59/0782e51887ac6b07ffd1570e0364cf901ebc36345fea669969d2084baebb/simple_websocket-1.1.0-py3-none-any.whl", hash = "sha256:4af6069630a38ed6c561010f0e11a5bc0d4ca569b36306eb257cd9a192497c8c", size = 13842, upload-time = "2024-10-10T22:39:29.645Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath"
+version = "2.10.35"
+source = { editable = "../../" }
+dependencies = [
+    { name = "applicationinsights" },
+    { name = "click" },
+    { name = "coverage" },
+    { name = "graphtty" },
+    { name = "httpx" },
+    { name = "mermaid-builder" },
+    { name = "mockito" },
+    { name = "pathlib" },
+    { name = "pydantic-function-models" },
+    { name = "pyjwt" },
+    { name = "pysignalr" },
+    { name = "python-dotenv" },
+    { name = "python-socketio" },
+    { name = "rich" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+    { name = "uipath-platform" },
+    { name = "uipath-runtime" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "applicationinsights", specifier = ">=0.11.10" },
+    { name = "click", specifier = ">=8.3.1" },
+    { name = "coverage", specifier = ">=7.8.2" },
+    { name = "graphtty", specifier = "==0.1.8" },
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "mermaid-builder", specifier = "==0.0.3" },
+    { name = "mockito", specifier = ">=1.5.4" },
+    { name = "pathlib", specifier = ">=1.0.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "pyjwt", specifier = ">=2.10.1" },
+    { name = "pysignalr", specifier = "==1.3.0" },
+    { name = "python-dotenv", specifier = ">=1.0.1" },
+    { name = "python-socketio", specifier = ">=5.15.0,<6.0.0" },
+    { name = "rich", specifier = ">=14.2.0" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+    { name = "uipath-platform", editable = "../../../uipath-platform" },
+    { name = "uipath-runtime", specifier = ">=0.10.0,<0.11.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "filelock", specifier = ">=3.20.3" },
+    { name = "inflection", specifier = ">=0.5.1" },
+    { name = "mkdocs", specifier = ">=1.6.1" },
+    { name = "mkdocs-click", specifier = ">=0.9.0" },
+    { name = "mkdocs-llmstxt", specifier = ">=0.5.0" },
+    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.7.0" },
+    { name = "mkdocs-open-in-new-tab", specifier = ">=1.0.8" },
+    { name = "mkdocs-simple-hooks", specifier = ">=0.1.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.30.1" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.5.1" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+    { name = "termynal", specifier = ">=0.13.1" },
+    { name = "tomli-w", specifier = ">=1.2.0" },
+    { name = "types-toml", specifier = ">=0.10.8" },
+    { name = "virtualenv", specifier = ">=20.36.1" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.8"
+source = { editable = "../../../uipath-core" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.13"
+source = { editable = "../../../uipath-platform" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "sqlparse", specifier = ">=0.5.5" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-runtime"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/75/64/69462ee01a5607ce36b1fa152c52ac72fb28abe0aa049394406fc0b31525/uipath_runtime-0.10.0.tar.gz", hash = "sha256:d27d58e2252f506c8c0e00f814b37c3863150e8ffcde8e4c6ab14bd98febd3df", size = 139626, upload-time = "2026-03-24T19:42:43.738Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/ed/9c0e97a078b96e4d3742ea3515cb30886b08579cd08077cd42a159adf70d/uipath_runtime-0.10.0-py3-none-any.whl", hash = "sha256:4f52df0b56f54e70fcf34fbf74e223d02b97b5a6fd6d8f64bc06782bb5484b07", size = 42097, upload-time = "2026-03-24T19:42:42.359Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "wsproto"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/79/12135bdf8b9c9367b8701c2c19a14c913c120b882d50b014ca0d38083c2c/wsproto-1.3.2.tar.gz", hash = "sha256:b86885dcf294e15204919950f666e06ffc6c7c114ca900b060d6e16293528294", size = 50116, upload-time = "2025-11-20T18:18:01.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath/samples/document-understanding-agent/README.md b/packages/uipath/samples/document-understanding-agent/README.md
new file mode 100644
index 000000000..9fd335b3e
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/README.md
@@ -0,0 +1,72 @@
+# Document Understanding Sample
+
+This sample demonstrates how to use UiPath Document Understanding capabilities with the UiPath Python SDK to classify, extract and validate data from documents.
+
+## Overview
+
+Document Understanding enables automated processing of documents through:
+
+- **Classification**: Identify document types
+- **Extraction**: Extract data from classified documents
+- **Validation**: Create human-in-the-loop validation actions for review
+
+This sample includes three Document Understanding approaches:
+
+- **IXP (Intelligent Xtraction and Processing)** (`src/ixp.py`) - [IXP documentation](https://docs.uipath.com/ixp/automation-cloud/latest/overview/introduction)
+- **Modern Projects** (`src/du_modern.py`) - [Modern DU documentation](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding)
+- **Pretrained Models** (`src/pretrained.py`) - [Pretrained models documentation](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/out-of-the-box-pre-trained-ml-packages)
+
+## Prerequisites
+
+- UiPath Automation Suite or Automation Cloud tenant
+- Document Understanding projects deployed with appropriate tags ( [DU Modern publish documentation](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/publish) / [IXP model deployment documentation](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/publish) )
+- Action catalog configured for validation actions ( [Actions documentation](https://docs.uipath.com/action-center/automation-cloud/latest/user-guide/about-actions) )
+- Storage bucket for validation data ( [Storage buckets documentation](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-storage-buckets) )
+
+## Setup
+
+1. **Install dependencies**:
+
+   ```bash
+   uv sync
+   ```
+
+2. **Configure UiPath credentials and initialize project**:
+
+   ```bash
+   uv run uipath auth
+   uv run uipath init
+   ```
+
+3. **Update sample parameters**:
+
+   Edit the sample files to match your environment:
+   - Project names and tags
+   - Document type names
+   - Action catalog and folder names
+   - Storage bucket configuration
+
+## Usage
+
+Run the complete sample workflow:
+
+```bash
+uv run uipath run main
+```
+
+Or run individual samples:
+
+```python
+from src import ixp, du_modern, pretrained
+
+# IXP extraction and validation
+ixp.extract_validate()
+
+# Modern project
+du_modern.extract_validate()
+du_modern.classify_extract_validate()
+
+# Pretrained model
+pretrained.extract_validate()
+pretrained.classify_extract_validate()
+```
diff --git a/packages/uipath/samples/document-understanding-agent/bindings.json b/packages/uipath/samples/document-understanding-agent/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/document-understanding-agent/main.py b/packages/uipath/samples/document-understanding-agent/main.py
new file mode 100644
index 000000000..7ea0bbde2
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/main.py
@@ -0,0 +1,10 @@
+from src import ixp, du_modern, pretrained
+
+def main():
+    ixp.extract_validate()
+
+    du_modern.extract_validate()
+    du_modern.classify_extract_validate()
+
+    pretrained.extract_validate()
+    pretrained.classify_extract_validate()
diff --git a/packages/uipath/samples/document-understanding-agent/pyproject.toml b/packages/uipath/samples/document-understanding-agent/pyproject.toml
new file mode 100644
index 000000000..b11472ebf
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "document-understanding-agent"
+version = "0.1.0"
+authors = [{ name = "John Doe" }]
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "uipath"
+]
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/document-understanding-agent/src/du_modern.py b/packages/uipath/samples/document-understanding-agent/src/du_modern.py
new file mode 100644
index 000000000..4ecdaaa35
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/src/du_modern.py
@@ -0,0 +1,81 @@
+from uipath.platform import UiPath
+from uipath.platform.documents import ProjectType, ActionPriority
+
+TAG = "Production"
+PROJECT_NAME = "TestModernProject"
+DOCUMENT_TYPE_NAME = "TestDocumentType"
+FILE_PATH = "test.pdf"
+ACTION_TITLE = "Test Validation Action"
+ACTION_PRIORITY = ActionPriority.MEDIUM
+ACTION_CATALOG = "default_du_actions"
+ACTION_FOLDER = "Shared"
+STORAGE_BUCKET_NAME = "du_storage_bucket"
+STORAGE_BUCKET_DIRECTORY_PATH = "TestDirectory"
+
+def extract_validate():
+    uipath = UiPath()
+
+    extraction_response = uipath.documents.extract(
+        tag=TAG,
+        project_name=PROJECT_NAME,
+        project_type=ProjectType.MODERN,
+        document_type_name=DOCUMENT_TYPE_NAME,
+        file_path=FILE_PATH,
+    )
+
+    validation_action = uipath.documents.create_validate_extraction_action(
+        action_title=ACTION_TITLE,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        extraction_response=extraction_response,
+    )
+
+    uipath.documents.get_validate_extraction_result(
+        validation_action=validation_action
+    )
+
+def classify_extract_validate():
+    uipath = UiPath()
+
+    classification_results = uipath.documents.classify(
+        tag=TAG,
+        project_name=PROJECT_NAME,
+        project_type=ProjectType.MODERN,
+        file_path=FILE_PATH,
+    )
+
+    validation_action = uipath.documents.create_validate_classification_action(
+        action_title=ACTION_TITLE,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        classification_results=classification_results,
+    )
+
+    validated_classification_results = uipath.documents.get_validate_classification_result(
+        validation_action=validation_action
+    )
+
+    best_confidence_result = max(validated_classification_results, key=lambda result: result.confidence)
+
+    extraction_response = uipath.documents.extract(classification_result=best_confidence_result)
+
+    validation_action = uipath.documents.create_validate_extraction_action(
+        action_title=ACTION_CATALOG,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        extraction_response=extraction_response,
+    )
+
+    uipath.documents.get_validate_extraction_result(
+        validation_action=validation_action
+    )
+
diff --git a/packages/uipath/samples/document-understanding-agent/src/ixp.py b/packages/uipath/samples/document-understanding-agent/src/ixp.py
new file mode 100644
index 000000000..72ca8c7d2
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/src/ixp.py
@@ -0,0 +1,37 @@
+from uipath.platform import UiPath
+from uipath.platform.documents import ProjectType, ActionPriority
+
+PROJECT_NAME = "TestIxpProject"
+TAG = "live"
+FILE_PATH = "test.pdf"
+ACTION_TITLE = "Test IXP Validation Action"
+ACTION_CATALOG = "default_du_actions"
+ACTION_FOLDER = "Shared"
+ACTION_PRIORITY = ActionPriority.MEDIUM
+STORAGE_BUCKET_NAME = "du_storage_bucket"
+STORAGE_BUCKET_DIRECTORY_PATH = "TestDirectory"
+
+
+def extract_validate():
+    uipath = UiPath()
+
+    extraction_response = uipath.documents.extract(
+        tag=TAG,
+        project_name=PROJECT_NAME,
+        project_type=ProjectType.IXP,
+        file_path=FILE_PATH,
+    )
+
+    validation_action = uipath.documents.create_validate_extraction_action(
+        action_title=ACTION_TITLE,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        extraction_response=extraction_response,
+    )
+
+    uipath.documents.get_validate_extraction_result(
+        validation_action=validation_action
+    )
diff --git a/packages/uipath/samples/document-understanding-agent/src/pretrained.py b/packages/uipath/samples/document-understanding-agent/src/pretrained.py
new file mode 100644
index 000000000..26a3c6e80
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/src/pretrained.py
@@ -0,0 +1,61 @@
+from uipath.platform import UiPath
+from uipath.platform.documents import ProjectType, ActionPriority
+
+DOCUMENT_TYPE_NAME = "invoices"
+FILE_PATH = "test.pdf"
+ACTION_TITLE = "Test Validation Action"
+ACTION_PRIORITY = ActionPriority.MEDIUM
+ACTION_CATALOG = "default_du_actions"
+ACTION_FOLDER = "Shared"
+STORAGE_BUCKET_NAME = "du_storage_bucket"
+STORAGE_BUCKET_DIRECTORY_PATH = "TestDirectory"
+
+def extract_validate():
+    uipath = UiPath()
+
+    extraction_response = uipath.documents.extract(
+        project_type=ProjectType.PRETRAINED,
+        document_type_name=DOCUMENT_TYPE_NAME,
+        file_path=FILE_PATH,
+    )
+
+    extraction_action = uipath.documents.create_validate_extraction_action(
+        action_title=ACTION_TITLE,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        extraction_response=extraction_response,
+    )
+
+    uipath.documents.get_validate_extraction_result(
+        validation_action=extraction_action
+    )
+
+def classify_extract_validate():
+    uipath = UiPath()
+
+    classification_results = uipath.documents.classify(
+        project_type=ProjectType.PRETRAINED, file_path=FILE_PATH
+    )
+
+    best_confidence_result = max(classification_results, key=lambda result: result.confidence)
+
+    extraction_response = uipath.documents.extract(
+        classification_result=best_confidence_result
+    )
+
+    extraction_action = uipath.documents.create_validate_extraction_action(
+        action_title=ACTION_TITLE,
+        action_priority=ACTION_PRIORITY,
+        action_catalog=ACTION_CATALOG,
+        action_folder=ACTION_FOLDER,
+        storage_bucket_name=STORAGE_BUCKET_NAME,
+        storage_bucket_directory_path=STORAGE_BUCKET_DIRECTORY_PATH,
+        extraction_response=extraction_response,
+    )
+
+    uipath.documents.get_validate_extraction_result(
+        validation_action=extraction_action
+    )
\ No newline at end of file
diff --git a/packages/uipath/samples/document-understanding-agent/test.pdf b/packages/uipath/samples/document-understanding-agent/test.pdf
new file mode 100644
index 000000000..f80d24b3c
Binary files /dev/null and b/packages/uipath/samples/document-understanding-agent/test.pdf differ
diff --git a/packages/uipath/samples/document-understanding-agent/uipath.json b/packages/uipath/samples/document-understanding-agent/uipath.json
new file mode 100644
index 000000000..2f1e23ce5
--- /dev/null
+++ b/packages/uipath/samples/document-understanding-agent/uipath.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {"main": "main.py:main"}
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/event-trigger/.python-version b/packages/uipath/samples/event-trigger/.python-version
new file mode 100644
index 000000000..24ee5b1be
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/packages/uipath/samples/event-trigger/README.md b/packages/uipath/samples/event-trigger/README.md
new file mode 100644
index 000000000..46fd6a3ae
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/README.md
@@ -0,0 +1,128 @@
+# UiPath Coded Agents with Event Triggers
+
+This guide explains how to create Python-based UiPath Coded Agents that respond to event triggers, enabling seamless event-driven agents.
+
+## Overview
+
+UiPath Coded Agents allow you to write automation logic directly in Python while leveraging UiPath's event trigger system. This project demonstrates how to create agents that handle external events from systems like Gmail, Slack, and other connectors.
+
+## How to Set Up UiPath Coded Agents with Event Triggers
+
+### Step 1: Install UiPath Python SDK
+
+1. Open it with your prefered editor
+2. In terminal run:
+```bash
+uv init
+uv add uipath
+uv run uipath new event-agent
+uv run uipath init
+```
+
+### Step 2: Create Your Coded Agent
+
+Create a Python file with your agent logic using the UiPath SDK:
+
+```python
+from dataclasses import dataclass
+from uipath.platform import EventArguments
+from uipath import UiPath
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+# use EventArguments when called by UiPath EventTriggers
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)
+```
+
+Run `uipath init` again to update the input arguments.
+
+### Step 3: Understanding the Event Flow
+
+When an event trigger fires, UiPath will:
+1. Pass event data through `EventArguments`
+2. Your agent retrieves the full payload using `sdk.connections.retrieve_event_payload(input)`
+3. Process the payload based on your business logic
+4. Return structured output
+
+### Step 4: Publish Your Coded Agent and setup Event Trigger
+
+#### 4.1: Build and Publish
+1. Use `uipath pack` and `uipath publish` to create and publish the package
+2. Create an Orchestrator Automation from the published process
+
+#### 4.2: Access Event Triggers
+1. Log into UiPath Orchestrator
+2. Navigate to **Automations** → **Processes**
+3. Click on your coded workflow process
+
+#### 4.3: Create Event Trigger
+1. Go to the **Triggers** tab
+2. Click **Add Trigger** → **Event Trigger**
+
+#### 4.4: Configure Event Trigger Settings
+1. **Name**: Descriptive name (e.g., "Gmail Event Handler")
+2. **Event Source**: Select connector type:
+   - `uipath-google-gmailcustom` for Gmail
+   - `uipath-slack` for Slack
+   - `uipath-microsoft-outlookcustom` for Outlook
+   - Custom connectors
+3. **Event Type**: Choose specific event:
+   - `EMAIL_RECEIVED` for emails
+   - `MESSAGE_RECEIVED` for chat messages
+   - Custom event types
+4. **Filters**: Optional event filtering criteria
+
+#### 4.5: Map Event to Input Arguments
+The event data will automatically be passed to your `EventArguments` parameter.
+
+#### 4.6: Enable the Trigger
+1. Review configuration
+2. Click **Create** to save
+3. Ensure trigger status is **Enabled**
+
+### Step 5: Test Your Setup
+
+#### 5.1: Trigger Test Events
+- Send test email (Gmail triggers)
+- Post message in Slack (Slack triggers)
+- Perform action matching your event source
+
+#### 5.2: Monitor Execution
+1. Check **Monitoring** → **Jobs** in Orchestrator
+2. View job details and execution logs
+3. Verify your coded agent processed the event correctly
+
+#### 5.3: Debug with Logs
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # payload will be a json (dict) specific to your event
+    payload = sdk.connections.retrieve_event_payload(input)
+    logger.info(f"Successfully retrieved payload: {type(payload)}")
+    logger.debug(f"Payload details: {payload}")
+
+    # Your processing logic here
+    result = process_event(payload)
+
+    logger.info(f"Event processed successfully: {result}")
+    return EchoOut(result)
+```
diff --git a/packages/uipath/samples/event-trigger/bindings.json b/packages/uipath/samples/event-trigger/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/event-trigger/main.py b/packages/uipath/samples/event-trigger/main.py
new file mode 100644
index 000000000..6bc08f1e7
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/main.py
@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from uipath.platform.connections import EventArguments
+from uipath.platform import UiPath
+from uipath.tracing import traced
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+@traced()
+def handle_slack_event(payload: dict[str, any]) -> EchoOut:
+    """Handle Slack message events"""
+    message = payload['event']['text'] if 'event' in payload and 'text' in payload['event'] else "No message"
+    user = payload['event']['user'] if 'event' in payload and 'user' in payload['event'] else "Unknown user"
+
+    logger.info(f"Slack message from {user}: {message}")
+
+
+# use InputTriggerEventArgs when called by UiPath EventTriggers
+@traced()
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    handle_slack_event(payload)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)
diff --git a/packages/uipath/samples/event-trigger/pyproject.toml b/packages/uipath/samples/event-trigger/pyproject.toml
new file mode 100644
index 000000000..13ad843f5
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "event-trigger"
+version = "0.0.1"
+description = "Event Trigger Demo"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+  "uipath"
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/event-trigger/uipath.json b/packages/uipath/samples/event-trigger/uipath.json
new file mode 100644
index 000000000..0c04b8ac6
--- /dev/null
+++ b/packages/uipath/samples/event-trigger/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions":{
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/greeter/README.md b/packages/uipath/samples/greeter/README.md
new file mode 100644
index 000000000..8a7a98d3f
--- /dev/null
+++ b/packages/uipath/samples/greeter/README.md
@@ -0,0 +1,83 @@
+# Greeter Sample - Simulated Input Testing
+
+This sample demonstrates LLM-based input generation (simulation) during evaluations and proper span instrumentation.
+
+## Overview
+
+The greeter function generates personalized greetings based on:
+- **name**: The person's name
+- **greeting_style**: The style of greeting (formal, casual, enthusiastic)
+
+## Running the Function
+
+```bash
+# From the greeter directory
+uv run uipath run main '{"name": "Alice", "greeting_style": "formal"}'
+```
+
+**Expected output:**
+```json
+{
+  "message": "Good day, Alice. It is a pleasure to meet you.",
+  "recipient": "Alice",
+  "style": "formal"
+}
+```
+
+## Running Evaluations
+
+### Option 1: Basic Evaluation (No Authentication Required)
+
+Test the function with predefined inputs - no LLM calls needed:
+
+```bash
+uv run uipath eval main ./evaluations/eval-sets/basic.json --output-file output-basic.json
+```
+
+This will run 3 test cases with fixed inputs and verify the outputs match expected results.
+
+### Option 2: Simulated Input Evaluation (Requires Authentication)
+
+The `simulated-input.json` eval set demonstrates LLM-based input generation:
+
+```bash
+# First, authenticate with UiPath
+uipath auth
+
+# Or set environment variables
+export UIPATH_URL=https://your-tenant.uipath.com
+export UIPATH_ACCESS_TOKEN=your-token
+
+# Then run the simulation eval
+uv run uipath eval main ./evaluations/eval-sets/simulated-input.json --output-file output.json
+```
+
+### How Simulated Input Works
+
+Each evaluation in `simulated-input.json` has:
+- `"inputs": {}` - Empty inputs
+- `"inputMockingStrategy"` - Configuration for LLM-based input generation with a prompt
+
+The evaluation framework will:
+1. Extract the function's input schema from the dataclass (`GreeterInput`)
+2. Call an LLM with the generation prompt and schema
+3. Parse the LLM's response to generate valid inputs
+4. Execute the function with the generated inputs
+5. Evaluate the output against expected results
+
+### Observability - "Simulate Input" Span
+
+When running evals with input simulation, you'll see a **"Simulate Input"** span in the traces with these attributes:
+
+**Custom attributes:**
+- `span_type`: `"simulatedInput"`
+- `type`: `"simulatedInput"`
+- `uipath.custom_instrumentation`: `true`
+
+**Standard @traced attributes:**
+- `input.mime_type`: `"application/json"`
+- `input.value`: JSON with `mocking_strategy`, `input_schema`, `expected_behavior`, `expected_output`
+- `output.mime_type`: `"application/json"`
+- `output.value`: The generated input (LLM response)
+
+This span matches the pattern used in the uipath-agents-python repository.
diff --git a/packages/uipath/samples/greeter/bindings.json b/packages/uipath/samples/greeter/bindings.json
new file mode 100644
index 000000000..6122d0e77
--- /dev/null
+++ b/packages/uipath/samples/greeter/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
diff --git a/packages/uipath/samples/greeter/evaluations/eval-sets/basic.json b/packages/uipath/samples/greeter/evaluations/eval-sets/basic.json
new file mode 100644
index 000000000..4a35e509e
--- /dev/null
+++ b/packages/uipath/samples/greeter/evaluations/eval-sets/basic.json
@@ -0,0 +1,61 @@
+{
+  "version": "1.0",
+  "id": "BasicGreeterEvalSet",
+  "name": "Basic Greeter Evaluation Set (No Simulation)",
+  "evaluatorRefs": [
+    "JsonSimilarityEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "test-formal-greeting",
+      "name": "Test Formal Greeting",
+      "inputs": {
+        "name": "Alice",
+        "greeting_style": "formal"
+      },
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Good day, Alice. It is a pleasure to meet you.",
+            "recipient": "Alice",
+            "style": "formal"
+          }
+        }
+      }
+    },
+    {
+      "id": "test-casual-greeting",
+      "name": "Test Casual Greeting",
+      "inputs": {
+        "name": "Bob",
+        "greeting_style": "casual"
+      },
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Hey Bob, what's up?",
+            "recipient": "Bob",
+            "style": "casual"
+          }
+        }
+      }
+    },
+    {
+      "id": "test-enthusiastic-greeting",
+      "name": "Test Enthusiastic Greeting",
+      "inputs": {
+        "name": "Charlie",
+        "greeting_style": "enthusiastic"
+      },
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Wow! Hi Charlie!! So great to see you!!!",
+            "recipient": "Charlie",
+            "style": "enthusiastic"
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/greeter/evaluations/eval-sets/simulated-input.json b/packages/uipath/samples/greeter/evaluations/eval-sets/simulated-input.json
new file mode 100644
index 000000000..04cf8de0d
--- /dev/null
+++ b/packages/uipath/samples/greeter/evaluations/eval-sets/simulated-input.json
@@ -0,0 +1,61 @@
+{
+  "version": "1.0",
+  "id": "SimulatedInputEvalSet",
+  "name": "Greeter Simulated Input Evaluation Set",
+  "evaluatorRefs": [
+    "JsonSimilarityEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "test-formal-greeting-simulated",
+      "name": "Test Formal Greeting with Simulated Input",
+      "inputs": {},
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Good day, Alice. It is a pleasure to meet you.",
+            "recipient": "Alice",
+            "style": "formal"
+          }
+        }
+      },
+      "inputMockingStrategy": {
+        "prompt": "Generate a formal greeting request for a person named Alice. The name field must be exactly 'Alice' and the greeting_style field must be exactly 'formal'."
+      }
+    },
+    {
+      "id": "test-casual-greeting-simulated",
+      "name": "Test Casual Greeting with Simulated Input",
+      "inputs": {},
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Hey Bob, what's up?",
+            "recipient": "Bob",
+            "style": "casual"
+          }
+        }
+      },
+      "inputMockingStrategy": {
+        "prompt": "Generate a casual greeting request for a person named Bob. The name field must be exactly 'Bob' and the greeting_style field must be exactly 'casual'."
+      }
+    },
+    {
+      "id": "test-enthusiastic-greeting-simulated",
+      "name": "Test Enthusiastic Greeting with Simulated Input",
+      "inputs": {},
+      "evaluationCriterias": {
+        "JsonSimilarityEvaluator": {
+          "expectedOutput": {
+            "message": "Wow! Hi Charlie!! So great to see you!!!",
+            "recipient": "Charlie",
+            "style": "enthusiastic"
+          }
+        }
+      },
+      "inputMockingStrategy": {
+        "prompt": "Generate an enthusiastic greeting request. The name field must be exactly 'Charlie' and the greeting_style field must be exactly 'enthusiastic'."
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/greeter/evaluations/evaluators/json-similarity.json b/packages/uipath/samples/greeter/evaluations/evaluators/json-similarity.json
new file mode 100644
index 000000000..ab91af344
--- /dev/null
+++ b/packages/uipath/samples/greeter/evaluations/evaluators/json-similarity.json
@@ -0,0 +1,17 @@
+{
+  "version": "1.0",
+  "id": "JsonSimilarityEvaluator",
+  "description": "Checks if the response JSON is similar to the expected JSON structure",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "JsonSimilarityEvaluator",
+    "targetOutputKey": "*",
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "message": "Good day, Alice. It is a pleasure to meet you.",
+        "recipient": "Alice",
+        "style": "formal"
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/greeter/main.py b/packages/uipath/samples/greeter/main.py
new file mode 100644
index 000000000..b69f6ee77
--- /dev/null
+++ b/packages/uipath/samples/greeter/main.py
@@ -0,0 +1,42 @@
+"""Simple greeter function for testing input simulation."""
+
+from pydantic.dataclasses import dataclass
+
+
+@dataclass
+class GreeterInput:
+    """Input for the greeter function."""
+
+    name: str
+    greeting_style: str = "formal"
+
+
+@dataclass
+class GreeterOutput:
+    """Output from the greeter function."""
+
+    message: str
+    recipient: str
+    style: str
+
+
+def main(input: GreeterInput) -> GreeterOutput:
+    """Generate a greeting based on the name and style.
+
+    Args:
+        input: The greeter input containing name and greeting_style
+
+    Returns:
+        A GreeterOutput containing the greeting message
+    """
+    greetings = {
+        "formal": f"Good day, {input.name}. It is a pleasure to meet you.",
+        "casual": f"Hey {input.name}, what's up?",
+        "enthusiastic": f"Wow! Hi {input.name}!! So great to see you!!!",
+    }
+
+    greeting = greetings.get(input.greeting_style, greetings["formal"])
+
+    return GreeterOutput(
+        message=greeting, recipient=input.name, style=input.greeting_style
+    )
diff --git a/packages/uipath/samples/greeter/output-basic.json b/packages/uipath/samples/greeter/output-basic.json
new file mode 100644
index 000000000..2d31e4e5e
--- /dev/null
+++ b/packages/uipath/samples/greeter/output-basic.json
@@ -0,0 +1 @@
+{"evaluationSetName": "Basic Greeter Evaluation Set (No Simulation)", "evaluationSetResults": [{"evaluationName": "Test Formal Greeting", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': 'Good day, Alice. It is a pleasure to meet you.', 'recipient': 'Alice', 'style': 'formal'}", "actual": "{'message': 'Good day, Alice. It is a pleasure to meet you.', 'recipient': 'Alice', 'style': 'formal'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 0.0002827644348144531}, "isLineResult": false}], "agentExecutionOutput": null}, {"evaluationName": "Test Casual Greeting", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': \"Hey Bob, what's up?\", 'recipient': 'Bob', 'style': 'casual'}", "actual": "{'message': \"Hey Bob, what's up?\", 'recipient': 'Bob', 'style': 'casual'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 5.459785461425781e-05}, "isLineResult": false}], "agentExecutionOutput": null}, {"evaluationName": "Test Enthusiastic Greeting", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': 'Wow! Hi Charlie!! So great to see you!!!', 'recipient': 'Charlie', 'style': 'enthusiastic'}", "actual": "{'message': 'Wow! Hi Charlie!! So great to see you!!!', 'recipient': 'Charlie', 'style': 'enthusiastic'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 0.00021982192993164062}, "isLineResult": false}], "agentExecutionOutput": null}]}
\ No newline at end of file
diff --git a/packages/uipath/samples/greeter/output.json b/packages/uipath/samples/greeter/output.json
new file mode 100644
index 000000000..2bdffb287
--- /dev/null
+++ b/packages/uipath/samples/greeter/output.json
@@ -0,0 +1 @@
+{"evaluationSetName": "Greeter Simulated Input Evaluation Set", "evaluationSetResults": [{"evaluationName": "Test Formal Greeting with Simulated Input", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': 'Good day, Alice. It is a pleasure to meet you.', 'recipient': 'Alice', 'style': 'formal'}", "actual": "{'message': 'Good day, Alice. It is a pleasure to meet you.', 'recipient': 'Alice', 'style': 'formal'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 0.0007398128509521484}, "isLineResult": false}], "agentExecutionOutput": null}, {"evaluationName": "Test Casual Greeting with Simulated Input", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': \"Hey Bob, what's up?\", 'recipient': 'Bob', 'style': 'casual'}", "actual": "{'message': \"Hey Bob, what's up?\", 'recipient': 'Bob', 'style': 'casual'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 0.0002269744873046875}, "isLineResult": false}], "agentExecutionOutput": null}, {"evaluationName": "Test Enthusiastic Greeting with Simulated Input", "evaluationRunResults": [{"evaluatorName": "JsonSimilarityEvaluator", "evaluatorId": "JsonSimilarityEvaluator", "result": {"score": 1.0, "details": {"expected": "{'message': 'Wow! Hi Charlie!! So great to see you!!!', 'recipient': 'Charlie', 'style': 'enthusiastic'}", "actual": "{'message': 'Wow! Hi Charlie!! So great to see you!!!', 'recipient': 'Charlie', 'style': 'enthusiastic'}", "matched_leaves": 3.0, "total_leaves": 3.0}, "evaluationTime": 0.0009617805480957031}, "isLineResult": false}], "agentExecutionOutput": null}]}
\ No newline at end of file
diff --git a/packages/uipath/samples/greeter/pyproject.toml b/packages/uipath/samples/greeter/pyproject.toml
new file mode 100644
index 000000000..a34c74fef
--- /dev/null
+++ b/packages/uipath/samples/greeter/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "greeter"
+version = "0.0.1"
+description = "greeter"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/greeter/test_greeter.sh b/packages/uipath/samples/greeter/test_greeter.sh
new file mode 100755
index 000000000..5672cc654
--- /dev/null
+++ b/packages/uipath/samples/greeter/test_greeter.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Test script for greeter sample with mocked authentication
+# This demonstrates the input simulation feature
+
+echo "Testing greeter sample with simulated inputs..."
+echo ""
+echo "Note: This requires valid UiPath authentication for LLM calls."
+echo "Set UIPATH_URL and UIPATH_ACCESS_TOKEN environment variables."
+echo ""
+
+# Check if auth is configured
+if [ -z "$UIPATH_URL" ] || [ -z "$UIPATH_ACCESS_TOKEN" ]; then
+    echo "⚠️  Authentication not configured."
+    echo ""
+    echo "To run this demo with real LLM input generation:"
+    echo "  export UIPATH_URL=https://your-tenant.uipath.com"
+    echo "  export UIPATH_ACCESS_TOKEN=your-token"
+    echo ""
+    echo "Or run: uipath auth"
+    echo ""
+    exit 1
+fi
+
+# Run the evaluation
+uv run uipath eval main ./evaluations/eval-sets/simulated-input.json --output-file output.json
+
+echo ""
+echo "Results saved to output.json"
diff --git a/packages/uipath/samples/greeter/uipath.json b/packages/uipath/samples/greeter/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/greeter/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/greeter/uv.lock b/packages/uipath/samples/greeter/uv.lock
new file mode 100644
index 000000000..c23ee9137
--- /dev/null
+++ b/packages/uipath/samples/greeter/uv.lock
@@ -0,0 +1,2337 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "aiosqlite"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/8a/64761f4005f17809769d23e518d915db74e6310474e733e3593cfc854ef1/aiosqlite-0.22.1.tar.gz", hash = "sha256:043e0bd78d32888c0a9ca90fc788b38796843360c855a7262a532813133a0650", size = 14821, upload-time = "2025-12-23T19:25:43.997Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "applicationinsights"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f2/46a75ac6096d60da0e71a068015b610206e697de01fa2fb5bba8564b0798/applicationinsights-0.11.10.tar.gz", hash = "sha256:0b761f3ef0680acf4731906dfc1807faa6f2a57168ae74592db0084a6099f7b3", size = 44722, upload-time = "2021-04-22T23:22:45.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/0d/cb6b23164eb55eebaa5f9f302dfe557cfa751bd7b2779863f1abd0343b6b/applicationinsights-0.11.10-py2.py3-none-any.whl", hash = "sha256:e89a890db1c6906b6a7d0bcfd617dac83974773c64573147c8d6654f9cf2a6ea", size = 55068, upload-time = "2021-04-22T23:22:44.451Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bidict"
+version = "0.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093, upload-time = "2024-02-18T19:09:05.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a4/ba/04b1bd4218cbc58dc90ce967106d51582371b898690f3ae0402876cc4f34/cryptography-46.0.6.tar.gz", hash = "sha256:27550628a518c5c6c903d84f637fbecf287f6cb9ced3804838a1295dc1fd0759", size = 750542, upload-time = "2026-03-25T23:34:53.396Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/23/9285e15e3bc57325b0a72e592921983a701efc1ee8f91c06c5f0235d86d9/cryptography-46.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:64235194bad039a10bb6d2d930ab3323baaec67e2ce36215fd0952fad0930ca8", size = 7176401, upload-time = "2026-03-25T23:33:22.096Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/e61f8f13950ab6195b31913b42d39f0f9afc7d93f76710f299b5ec286ae6/cryptography-46.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:26031f1e5ca62fcb9d1fcb34b2b60b390d1aacaa15dc8b895a9ed00968b97b30", size = 4275275, upload-time = "2026-03-25T23:33:23.844Z" },
+    { url = "https://files.pythonhosted.org/packages/19/69/732a736d12c2631e140be2348b4ad3d226302df63ef64d30dfdb8db7ad1c/cryptography-46.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9a693028b9cbe51b5a1136232ee8f2bc242e4e19d456ded3fa7c86e43c713b4a", size = 4425320, upload-time = "2026-03-25T23:33:25.703Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/12/123be7292674abf76b21ac1fc0e1af50661f0e5b8f0ec8285faac18eb99e/cryptography-46.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:67177e8a9f421aa2d3a170c3e56eca4e0128883cf52a071a7cbf53297f18b175", size = 4278082, upload-time = "2026-03-25T23:33:27.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ba/d5e27f8d68c24951b0a484924a84c7cdaed7502bac9f18601cd357f8b1d2/cryptography-46.0.6-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:d9528b535a6c4f8ff37847144b8986a9a143585f0540fbcb1a98115b543aa463", size = 4926514, upload-time = "2026-03-25T23:33:29.206Z" },
+    { url = "https://files.pythonhosted.org/packages/34/71/1ea5a7352ae516d5512d17babe7e1b87d9db5150b21f794b1377eac1edc0/cryptography-46.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:22259338084d6ae497a19bae5d4c66b7ca1387d3264d1c2c0e72d9e9b6a77b97", size = 4457766, upload-time = "2026-03-25T23:33:30.834Z" },
+    { url = "https://files.pythonhosted.org/packages/01/59/562be1e653accee4fdad92c7a2e88fced26b3fdfce144047519bbebc299e/cryptography-46.0.6-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:760997a4b950ff00d418398ad73fbc91aa2894b5c1db7ccb45b4f68b42a63b3c", size = 3986535, upload-time = "2026-03-25T23:33:33.02Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/8b/b1ebfeb788bf4624d36e45ed2662b8bd43a05ff62157093c1539c1288a18/cryptography-46.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:3dfa6567f2e9e4c5dceb8ccb5a708158a2a871052fa75c8b78cb0977063f1507", size = 4277618, upload-time = "2026-03-25T23:33:34.567Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/52/a005f8eabdb28df57c20f84c44d397a755782d6ff6d455f05baa2785bd91/cryptography-46.0.6-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:cdcd3edcbc5d55757e5f5f3d330dd00007ae463a7e7aa5bf132d1f22a4b62b19", size = 4890802, upload-time = "2026-03-25T23:33:37.034Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4d/8e7d7245c79c617d08724e2efa397737715ca0ec830ecb3c91e547302555/cryptography-46.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:d4e4aadb7fc1f88687f47ca20bb7227981b03afaae69287029da08096853b738", size = 4457425, upload-time = "2026-03-25T23:33:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/5c/f6c3596a1430cec6f949085f0e1a970638d76f81c3ea56d93d564d04c340/cryptography-46.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2b417edbe8877cda9022dde3a008e2deb50be9c407eef034aeeb3a8b11d9db3c", size = 4405530, upload-time = "2026-03-25T23:33:40.842Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/c9/9f9cea13ee2dbde070424e0c4f621c091a91ffcc504ffea5e74f0e1daeff/cryptography-46.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:380343e0653b1c9d7e1f55b52aaa2dbb2fdf2730088d48c43ca1c7c0abb7cc2f", size = 4667896, upload-time = "2026-03-25T23:33:42.781Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/b5/1895bc0821226f129bc74d00eccfc6a5969e2028f8617c09790bf89c185e/cryptography-46.0.6-cp311-abi3-win32.whl", hash = "sha256:bcb87663e1f7b075e48c3be3ecb5f0b46c8fc50b50a97cf264e7f60242dca3f2", size = 3026348, upload-time = "2026-03-25T23:33:45.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f8/c9bcbf0d3e6ad288b9d9aa0b1dee04b063d19e8c4f871855a03ab3a297ab/cryptography-46.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:6739d56300662c468fddb0e5e291f9b4d084bead381667b9e654c7dd81705124", size = 3483896, upload-time = "2026-03-25T23:33:46.649Z" },
+    { url = "https://files.pythonhosted.org/packages/01/41/3a578f7fd5c70611c0aacba52cd13cb364a5dee895a5c1d467208a9380b0/cryptography-46.0.6-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:2ef9e69886cbb137c2aef9772c2e7138dc581fad4fcbcf13cc181eb5a3ab6275", size = 7117147, upload-time = "2026-03-25T23:33:48.249Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/87/887f35a6fca9dde90cad08e0de0c89263a8e59b2d2ff904fd9fcd8025b6f/cryptography-46.0.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7f417f034f91dcec1cb6c5c35b07cdbb2ef262557f701b4ecd803ee8cefed4f4", size = 4266221, upload-time = "2026-03-25T23:33:49.874Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/a8/0a90c4f0b0871e0e3d1ed126aed101328a8a57fd9fd17f00fb67e82a51ca/cryptography-46.0.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d24c13369e856b94892a89ddf70b332e0b70ad4a5c43cf3e9cb71d6d7ffa1f7b", size = 4408952, upload-time = "2026-03-25T23:33:52.128Z" },
+    { url = "https://files.pythonhosted.org/packages/16/0b/b239701eb946523e4e9f329336e4ff32b1247e109cbab32d1a7b61da8ed7/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:aad75154a7ac9039936d50cf431719a2f8d4ed3d3c277ac03f3339ded1a5e707", size = 4270141, upload-time = "2026-03-25T23:33:54.11Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/a8/976acdd4f0f30df7b25605f4b9d3d89295351665c2091d18224f7ad5cdbf/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:3c21d92ed15e9cfc6eb64c1f5a0326db22ca9c2566ca46d845119b45b4400361", size = 4904178, upload-time = "2026-03-25T23:33:55.725Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/1b/bf0e01a88efd0e59679b69f42d4afd5bced8700bb5e80617b2d63a3741af/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:4668298aef7cddeaf5c6ecc244c2302a2b8e40f384255505c22875eebb47888b", size = 4441812, upload-time = "2026-03-25T23:33:57.364Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/8b/11df86de2ea389c65aa1806f331cae145f2ed18011f30234cc10ca253de8/cryptography-46.0.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:8ce35b77aaf02f3b59c90b2c8a05c73bac12cea5b4e8f3fbece1f5fddea5f0ca", size = 3963923, upload-time = "2026-03-25T23:33:59.361Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e0/207fb177c3a9ef6a8108f234208c3e9e76a6aa8cf20d51932916bd43bda0/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:c89eb37fae9216985d8734c1afd172ba4927f5a05cfd9bf0e4863c6d5465b013", size = 4269695, upload-time = "2026-03-25T23:34:00.909Z" },
+    { url = "https://files.pythonhosted.org/packages/21/5e/19f3260ed1e95bced52ace7501fabcd266df67077eeb382b79c81729d2d3/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:ed418c37d095aeddf5336898a132fba01091f0ac5844e3e8018506f014b6d2c4", size = 4869785, upload-time = "2026-03-25T23:34:02.796Z" },
+    { url = "https://files.pythonhosted.org/packages/10/38/cd7864d79aa1d92ef6f1a584281433419b955ad5a5ba8d1eb6c872165bcb/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:69cf0056d6947edc6e6760e5f17afe4bea06b56a9ac8a06de9d2bd6b532d4f3a", size = 4441404, upload-time = "2026-03-25T23:34:04.35Z" },
+    { url = "https://files.pythonhosted.org/packages/09/0a/4fe7a8d25fed74419f91835cf5829ade6408fd1963c9eae9c4bce390ecbb/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e7304c4f4e9490e11efe56af6713983460ee0780f16c63f219984dab3af9d2d", size = 4397549, upload-time = "2026-03-25T23:34:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/a0/7d738944eac6513cd60a8da98b65951f4a3b279b93479a7e8926d9cd730b/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b928a3ca837c77a10e81a814a693f2295200adb3352395fad024559b7be7a736", size = 4651874, upload-time = "2026-03-25T23:34:07.916Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/f1/c2326781ca05208845efca38bf714f76939ae446cd492d7613808badedf1/cryptography-46.0.6-cp314-cp314t-win32.whl", hash = "sha256:97c8115b27e19e592a05c45d0dd89c57f81f841cc9880e353e0d3bf25b2139ed", size = 3001511, upload-time = "2026-03-25T23:34:09.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/57/fe4a23eb549ac9d903bd4698ffda13383808ef0876cc912bcb2838799ece/cryptography-46.0.6-cp314-cp314t-win_amd64.whl", hash = "sha256:c797e2517cb7880f8297e2c0f43bb910e91381339336f75d2c1c2cbf811b70b4", size = 3471692, upload-time = "2026-03-25T23:34:11.613Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/cc/f330e982852403da79008552de9906804568ae9230da8432f7496ce02b71/cryptography-46.0.6-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:12cae594e9473bca1a7aceb90536060643128bb274fcea0fc459ab90f7d1ae7a", size = 7162776, upload-time = "2026-03-25T23:34:13.308Z" },
+    { url = "https://files.pythonhosted.org/packages/49/b3/dc27efd8dcc4bff583b3f01d4a3943cd8b5821777a58b3a6a5f054d61b79/cryptography-46.0.6-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:639301950939d844a9e1c4464d7e07f902fe9a7f6b215bb0d4f28584729935d8", size = 4270529, upload-time = "2026-03-25T23:34:15.019Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/05/e8d0e6eb4f0d83365b3cb0e00eb3c484f7348db0266652ccd84632a3d58d/cryptography-46.0.6-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ed3775295fb91f70b4027aeba878d79b3e55c0b3e97eaa4de71f8f23a9f2eb77", size = 4414827, upload-time = "2026-03-25T23:34:16.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/97/daba0f5d2dc6d855e2dcb70733c812558a7977a55dd4a6722756628c44d1/cryptography-46.0.6-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:8927ccfbe967c7df312ade694f987e7e9e22b2425976ddbf28271d7e58845290", size = 4271265, upload-time = "2026-03-25T23:34:18.586Z" },
+    { url = "https://files.pythonhosted.org/packages/89/06/fe1fce39a37ac452e58d04b43b0855261dac320a2ebf8f5260dd55b201a9/cryptography-46.0.6-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b12c6b1e1651e42ab5de8b1e00dc3b6354fdfd778e7fa60541ddacc27cd21410", size = 4916800, upload-time = "2026-03-25T23:34:20.561Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8a/b14f3101fe9c3592603339eb5d94046c3ce5f7fc76d6512a2d40efd9724e/cryptography-46.0.6-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:063b67749f338ca9c5a0b7fe438a52c25f9526b851e24e6c9310e7195aad3b4d", size = 4448771, upload-time = "2026-03-25T23:34:22.406Z" },
+    { url = "https://files.pythonhosted.org/packages/01/b3/0796998056a66d1973fd52ee89dc1bb3b6581960a91ad4ac705f182d398f/cryptography-46.0.6-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:02fad249cb0e090b574e30b276a3da6a149e04ee2f049725b1f69e7b8351ec70", size = 3978333, upload-time = "2026-03-25T23:34:24.281Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3d/db200af5a4ffd08918cd55c08399dc6c9c50b0bc72c00a3246e099d3a849/cryptography-46.0.6-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e6142674f2a9291463e5e150090b95a8519b2fb6e6aaec8917dd8d094ce750d", size = 4271069, upload-time = "2026-03-25T23:34:25.895Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/18/61acfd5b414309d74ee838be321c636fe71815436f53c9f0334bf19064fa/cryptography-46.0.6-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:456b3215172aeefb9284550b162801d62f5f264a081049a3e94307fe20792cfa", size = 4878358, upload-time = "2026-03-25T23:34:27.67Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/65/5bf43286d566f8171917cae23ac6add941654ccf085d739195a4eacf1674/cryptography-46.0.6-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:341359d6c9e68834e204ceaf25936dffeafea3829ab80e9503860dcc4f4dac58", size = 4448061, upload-time = "2026-03-25T23:34:29.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/25/7e49c0fa7205cf3597e525d156a6bce5b5c9de1fd7e8cb01120e459f205a/cryptography-46.0.6-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9a9c42a2723999a710445bc0d974e345c32adfd8d2fac6d8a251fa829ad31cfb", size = 4399103, upload-time = "2026-03-25T23:34:32.036Z" },
+    { url = "https://files.pythonhosted.org/packages/44/46/466269e833f1c4718d6cd496ffe20c56c9c8d013486ff66b4f69c302a68d/cryptography-46.0.6-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6617f67b1606dfd9fe4dbfa354a9508d4a6d37afe30306fe6c101b7ce3274b72", size = 4659255, upload-time = "2026-03-25T23:34:33.679Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/09/ddc5f630cc32287d2c953fc5d32705e63ec73e37308e5120955316f53827/cryptography-46.0.6-cp38-abi3-win32.whl", hash = "sha256:7f6690b6c55e9c5332c0b59b9c8a3fb232ebf059094c17f9019a51e9827df91c", size = 3010660, upload-time = "2026-03-25T23:34:35.418Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/82/ca4893968aeb2709aacfb57a30dec6fa2ab25b10fa9f064b8882ce33f599/cryptography-46.0.6-cp38-abi3-win_amd64.whl", hash = "sha256:79e865c642cfc5c0b3eb12af83c35c5aeff4fa5c672dc28c43721c2c9fdd2f0f", size = 3471160, upload-time = "2026-03-25T23:34:37.191Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/84/7ccff00ced5bac74b775ce0beb7d1be4e8637536b522b5df9b73ada42da2/cryptography-46.0.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:2ea0f37e9a9cf0df2952893ad145fd9627d326a59daec9b0802480fa3bcd2ead", size = 3475444, upload-time = "2026-03-25T23:34:38.944Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/1f/4c926f50df7749f000f20eede0c896769509895e2648db5da0ed55db711d/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a3e84d5ec9ba01f8fd03802b2147ba77f0c8f2617b2aff254cedd551844209c8", size = 4218227, upload-time = "2026-03-25T23:34:40.871Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/65/707be3ffbd5f786028665c3223e86e11c4cda86023adbc56bd72b1b6bab5/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:12f0fa16cc247b13c43d56d7b35287ff1569b5b1f4c5e87e92cc4fcc00cd10c0", size = 4381399, upload-time = "2026-03-25T23:34:42.609Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6d/73557ed0ef7d73d04d9aba745d2c8e95218213687ee5e76b7d236a5030fc/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:50575a76e2951fe7dbd1f56d181f8c5ceeeb075e9ff88e7ad997d2f42af06e7b", size = 4217595, upload-time = "2026-03-25T23:34:44.205Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c5/e1594c4eec66a567c3ac4400008108a415808be2ce13dcb9a9045c92f1a0/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:90e5f0a7b3be5f40c3a0a0eafb32c681d8d2c181fc2a1bdabe9b3f611d9f6b1a", size = 4380912, upload-time = "2026-03-25T23:34:46.328Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/89/843b53614b47f97fe1abc13f9a86efa5ec9e275292c457af1d4a60dc80e0/cryptography-46.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6728c49e3b2c180ef26f8e9f0a883a2c585638db64cf265b49c9ba10652d430e", size = 3409955, upload-time = "2026-03-25T23:34:48.465Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.135.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/73/5903c4b13beae98618d64eb9870c3fac4f605523dd0312ca5c80dadbd5b9/fastapi-0.135.2.tar.gz", hash = "sha256:88a832095359755527b7f63bb4c6bc9edb8329a026189eed83d6c1afcf419d56", size = 395833, upload-time = "2026-03-23T14:12:41.697Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/ea/18f6d0457f9efb2fc6fa594857f92810cadb03024975726db6546b3d6fcf/fastapi-0.135.2-py3-none-any.whl", hash = "sha256:0af0447d541867e8db2a6a25c23a8c4bd80e2394ac5529bd87501bbb9e240ca5", size = 117407, upload-time = "2026-03-23T14:12:43.284Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "graphtty"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/b3/0756e1b1e46b61a4db4a463a76ca113e62113742f97ac6cf383dd05d6a97/graphtty-0.1.8.tar.gz", hash = "sha256:069cd84764cc64d414928451071fc9c97c05becbf564c2f0278691a6451a8240", size = 638011, upload-time = "2026-02-15T12:47:17.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/a9/66d01580a4a92b576c056e9967d552a28ed836540eaf73b436474c514bc2/graphtty-0.1.8-py3-none-any.whl", hash = "sha256:4e19e6d66b9ef79e2715377163f61a6542b5b9ee00d50406b80a40d0ba094f67", size = 25474, upload-time = "2026-02-15T12:47:16.377Z" },
+]
+
+[[package]]
+name = "greeter"
+version = "0.0.1"
+source = { virtual = "." }
+dependencies = [
+    { name = "uipath" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "uipath-dev" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "uipath" }]
+
+[package.metadata.requires-dev]
+dev = [{ name = "uipath-dev" }]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/08/17e07e8d89ab8f343c134616d72eebfe03798835058e2ab579dcc8353c06/httptools-0.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:474d3b7ab469fefcca3697a10d11a32ee2b9573250206ba1e50d5980910da657", size = 206521, upload-time = "2025-10-10T03:54:31.002Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/06/c9c1b41ff52f16aee526fd10fbda99fa4787938aa776858ddc4a1ea825ec/httptools-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3c3b7366bb6c7b96bd72d0dbe7f7d5eead261361f013be5f6d9590465ea1c70", size = 110375, upload-time = "2025-10-10T03:54:31.941Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/cc/10935db22fda0ee34c76f047590ca0a8bd9de531406a3ccb10a90e12ea21/httptools-0.7.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:379b479408b8747f47f3b253326183d7c009a3936518cdb70db58cffd369d9df", size = 456621, upload-time = "2025-10-10T03:54:33.176Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/84/875382b10d271b0c11aa5d414b44f92f8dd53e9b658aec338a79164fa548/httptools-0.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad6b591a682dcc6cf1397c3900527f9affef1e55a06c4547264796bbd17cf5e", size = 454954, upload-time = "2025-10-10T03:54:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e1/44f89b280f7e46c0b1b2ccee5737d46b3bb13136383958f20b580a821ca0/httptools-0.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eb844698d11433d2139bbeeb56499102143beb582bd6c194e3ba69c22f25c274", size = 440175, upload-time = "2025-10-10T03:54:35.942Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/7e/b9287763159e700e335028bc1824359dc736fa9b829dacedace91a39b37e/httptools-0.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f65744d7a8bdb4bda5e1fa23e4ba16832860606fcc09d674d56e425e991539ec", size = 440310, upload-time = "2025-10-10T03:54:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/07/5b614f592868e07f5c94b1f301b5e14a21df4e8076215a3bccb830a687d8/httptools-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:135fbe974b3718eada677229312e97f3b31f8a9c8ffa3ae6f565bf808d5b6bcb", size = 86875, upload-time = "2025-10-10T03:54:38.421Z" },
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "linkify-it-py"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uc-micro-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/c9/06ea13676ef354f0af6169587ae292d3e2406e212876a413bf9eece4eb23/linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b", size = 29158, upload-time = "2026-03-01T07:48:47.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/de/88b3be5c31b22333b3ca2f6ff1de4e863d8fe45aaea7485f591970ec1d3e/linkify_it_py-2.1.0-py3-none-any.whl", hash = "sha256:0d252c1594ecba2ecedc444053db5d3a9b7ec1b0dd929c8f1d74dce89f86c05e", size = 19878, upload-time = "2026-03-01T07:48:46.098Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[package.optional-dependencies]
+linkify = [
+    { name = "linkify-it-py" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "jsonschema" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "python-multipart" },
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/6d/62e76bbb8144d6ed86e202b5edd8a4cb631e7c8130f3f4893c3f90262b10/mcp-1.26.0.tar.gz", hash = "sha256:db6e2ef491eecc1a0d93711a76f28dec2e05999f93afd48795da1c1137142c66", size = 608005, upload-time = "2026-01-24T19:40:32.468Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/d9/eaa1f80170d2b7c5ba23f3b59f766f3a0bb41155fbc32a69adfa1adaaef9/mcp-1.26.0-py3-none-any.whl", hash = "sha256:904a21c33c25aa98ddbeb47273033c435e595bbacfdb177f4bd87f6dceebe1ca", size = 233615, upload-time = "2026-01-24T19:40:30.652Z" },
+]
+
+[package.optional-dependencies]
+cli = [
+    { name = "python-dotenv" },
+    { name = "typer" },
+]
+
+[[package]]
+name = "mdit-py-plugins"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mermaid-builder"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/57/d83e7e62de05adbba2476b7596ed4a253907a4f4c19be74c40e7ce2944dc/mermaid_builder-0.0.3.tar.gz", hash = "sha256:3016ef25668bcb28de4a4746aabdfaa531c06a7e7f89fa1596e6a274c7c73705", size = 7183, upload-time = "2024-06-14T17:14:51.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/7480454b7ee7de5c2c8561e83b4564196ecf1c9847e893dfbb51032e5a3b/mermaid_builder-0.0.3-py3-none-any.whl", hash = "sha256:decd7d25268bda7a520ce0cab7873e50fac1e33b41e5a1dd7daec5c0ae3c7ffb", size = 6696, upload-time = "2024-06-14T17:14:38.48Z" },
+]
+
+[[package]]
+name = "mockito"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/4b/d342e6910379d04557fc1c32ea63d49d0c630d0dbeb81240482fbf13be87/mockito-2.0.3.tar.gz", hash = "sha256:8cb4981b56b0b96295c9581fff55e3d669ecdbcdc547762a4f10b46ae4032aea", size = 217711, upload-time = "2026-03-15T17:27:22.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/bf/138a95593c5fbaca78090e5c10259a682ec0c544974188a9defb726dd8b1/mockito-2.0.3-py3-none-any.whl", hash = "sha256:c6b104bda0b4808d4f6063b877e2c59dbaada940aad8eebd16463b5f5d423da2", size = 51944, upload-time = "2026-03-15T17:27:21.534Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" },
+    { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" },
+    { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathlib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298, upload-time = "2014-09-03T15:41:57.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363, upload-time = "2022-05-04T13:37:20.585Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[package]]
+name = "pyperclip"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" },
+]
+
+[[package]]
+name = "pysignalr"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "msgpack" },
+    { name = "orjson" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/a6/ac80bd4972604c6930050e8b0eba41d6fde41cb3286087be0188a8865f55/pysignalr-1.3.0.tar.gz", hash = "sha256:ca2e4372f213d82148fa2f060f0fefd096f1f66fca1107ac05e76ec6abd4cf52", size = 16790, upload-time = "2025-04-29T21:23:38.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/54/74e35563927ab8538e1bd1404b35027861434aecf2bcc945ff30c188e56d/pysignalr-1.3.0-py3-none-any.whl", hash = "sha256:423c91b0d1dc8387f37118ac2d1dc87ed6b9e01993a04612eab8452193f40344", size = 19966, upload-time = "2025-04-29T21:23:37.513Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-engineio"
+version = "4.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "simple-websocket" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/12/bdef9dbeedbe2cdeba2a2056ad27b1fb081557d34b69a97f574843462cae/python_engineio-4.13.1.tar.gz", hash = "sha256:0a853fcef52f5b345425d8c2b921ac85023a04dfcf75d7b74696c61e940fd066", size = 92348, upload-time = "2026-02-06T23:38:06.12Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/54/0cce26da03a981f949bb8449c9778537f75f5917c172e1d2992ff25cb57d/python_engineio-4.13.1-py3-none-any.whl", hash = "sha256:f32ad10589859c11053ad7d9bb3c9695cdf862113bfb0d20bc4d890198287399", size = 59847, upload-time = "2026-02-06T23:38:04.861Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },
+]
+
+[[package]]
+name = "python-socketio"
+version = "5.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bidict" },
+    { name = "python-engineio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/81/cf8284f45e32efa18d3848ed82cdd4dcc1b657b082458fbe01ad3e1f2f8d/python_socketio-5.16.1.tar.gz", hash = "sha256:f863f98eacce81ceea2e742f6388e10ca3cdd0764be21d30d5196470edf5ea89", size = 128508, upload-time = "2026-02-06T23:42:07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c7/deb8c5e604404dbf10a3808a858946ca3547692ff6316b698945bb72177e/python_socketio-5.16.1-py3-none-any.whl", hash = "sha256:a3eb1702e92aa2f2b5d3ba00261b61f062cce51f1cfb6900bf3ab4d1934d2d35", size = 82054, upload-time = "2026-02-06T23:42:05.772Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" },
+    { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },
+    { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },
+    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
+]
+
+[[package]]
+name = "pywinpty"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/54/37c7370ba91f579235049dc26cd2c5e657d2a943e01820844ffc81f32176/pywinpty-3.0.3.tar.gz", hash = "sha256:523441dc34d231fb361b4b00f8c99d3f16de02f5005fd544a0183112bcc22412", size = 31309, upload-time = "2026-02-04T21:51:09.524Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/c3/3e75075c7f71735f22b66fab0481f2c98e3a4d58cba55cb50ba29114bcf6/pywinpty-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:dff25a9a6435f527d7c65608a7e62783fc12076e7d44487a4911ee91be5a8ac8", size = 2114430, upload-time = "2026-02-04T21:54:19.485Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/1e/8a54166a8c5e4f5cb516514bdf4090be4d51a71e8d9f6d98c0aa00fe45d4/pywinpty-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:fbc1e230e5b193eef4431cba3f39996a288f9958f9c9f092c8a961d930ee8f68", size = 236191, upload-time = "2026-02-04T21:50:36.239Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/d4/aeb5e1784d2c5bff6e189138a9ca91a090117459cea0c30378e1f2db3d54/pywinpty-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c9081df0e49ffa86d15db4a6ba61530630e48707f987df42c9d3313537e81fc0", size = 2113098, upload-time = "2026-02-04T21:54:37.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/53/7278223c493ccfe4883239cf06c823c56460a8010e0fc778eef67858dc14/pywinpty-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:15e79d870e18b678fb8a5a6105fd38496b55697c66e6fc0378236026bc4d59e9", size = 234901, upload-time = "2026-02-04T21:53:31.35Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/cb/58d6ed3fd429c96a90ef01ac9a617af10a6d41469219c25e7dc162abbb71/pywinpty-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9c91dbb026050c77bdcef964e63a4f10f01a639113c4d3658332614544c467ab", size = 2112686, upload-time = "2026-02-04T21:52:03.035Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/50/724ed5c38c504d4e58a88a072776a1e880d970789deaeb2b9f7bd9a5141a/pywinpty-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:fe1f7911805127c94cf51f89ab14096c6f91ffdcacf993d2da6082b2142a2523", size = 234591, upload-time = "2026-02-04T21:52:29.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ad/90a110538696b12b39fd8758a06d70ded899308198ad2305ac68e361126e/pywinpty-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:3f07a6cf1c1d470d284e614733c3d0f726d2c85e78508ea10a403140c3c0c18a", size = 2112360, upload-time = "2026-02-04T21:55:33.397Z" },
+    { url = "https://files.pythonhosted.org/packages/44/0f/7ffa221757a220402bc79fda44044c3f2cc57338d878ab7d622add6f4581/pywinpty-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:15c7c0b6f8e9d87aabbaff76468dabf6e6121332c40fc1d83548d02a9d6a3759", size = 233107, upload-time = "2026-02-04T21:51:45.455Z" },
+    { url = "https://files.pythonhosted.org/packages/28/88/2ff917caff61e55f38bcdb27de06ee30597881b2cae44fbba7627be015c4/pywinpty-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:d4b6b7b0fe0cdcd02e956bd57cfe9f4e5a06514eecf3b5ae174da4f951b58be9", size = 2113282, upload-time = "2026-02-04T21:52:08.188Z" },
+    { url = "https://files.pythonhosted.org/packages/63/32/40a775343ace542cc43ece3f1d1fce454021521ecac41c4c4573081c2336/pywinpty-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:34789d685fc0d547ce0c8a65e5a70e56f77d732fa6e03c8f74fefb8cbb252019", size = 234207, upload-time = "2026-02-04T21:51:58.687Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/54/5d5e52f4cb75028104ca6faf36c10f9692389b1986d34471663b4ebebd6d/pywinpty-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0c37e224a47a971d1a6e08649a1714dac4f63c11920780977829ed5c8cadead1", size = 2112910, upload-time = "2026-02-04T21:52:30.976Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/44/dcd184824e21d4620b06c7db9fbb15c3ad0a0f1fa2e6de79969fb82647ec/pywinpty-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c4e9c3dff7d86ba81937438d5819f19f385a39d8f592d4e8af67148ceb4f6ab5", size = 233425, upload-time = "2026-02-04T21:51:56.754Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" },
+    { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" },
+    { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" },
+    { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+    { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" },
+    { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" },
+    { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" },
+    { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" },
+    { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "simple-websocket"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/59/0782e51887ac6b07ffd1570e0364cf901ebc36345fea669969d2084baebb/simple_websocket-1.1.0-py3-none-any.whl", hash = "sha256:4af6069630a38ed6c561010f0e11a5bc0d4ca569b36306eb257cd9a192497c8c", size = 13842, upload-time = "2024-10-10T22:39:29.645Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/14/2f/9223c24f568bb7a0c03d751e609844dce0968f13b39a3f73fbb3a96cd27a/sse_starlette-3.3.3.tar.gz", hash = "sha256:72a95d7575fd5129bd0ae15275ac6432bb35ac542fdebb82889c24bb9f3f4049", size = 32420, upload-time = "2026-03-17T20:05:55.529Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/e2/b8cff57a67dddf9a464d7e943218e031617fb3ddc133aeeb0602ff5f6c85/sse_starlette-3.3.3-py3-none-any.whl", hash = "sha256:c5abb5082a1cc1c6294d89c5290c46b5f67808cfdb612b7ec27e8ba061c22e8d", size = 14329, upload-time = "2026-03-17T20:05:54.35Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "textual"
+version = "7.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py", extra = ["linkify"] },
+    { name = "mdit-py-plugins" },
+    { name = "platformdirs" },
+    { name = "pygments" },
+    { name = "rich" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9f/38/7d169a765993efde5095c70a668bf4f5831bb7ac099e932f2783e9b71abf/textual-7.5.0.tar.gz", hash = "sha256:c730cba1e3d704e8f1ca915b6a3af01451e3bca380114baacf6abf87e9dac8b6", size = 1592319, upload-time = "2026-01-30T13:46:39.881Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/78/96ddb99933e11d91bc6e05edae23d2687e44213066bcbaca338898c73c47/textual-7.5.0-py3-none-any.whl", hash = "sha256:849dfee9d705eab3b2d07b33152b7bd74fb1f5056e002873cc448bce500c6374", size = 718164, upload-time = "2026-01-30T13:46:37.635Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uc-micro-py"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/67/9a363818028526e2d4579334460df777115bdec1bb77c08f9db88f6389f2/uc_micro_py-2.0.0.tar.gz", hash = "sha256:c53691e495c8db60e16ffc4861a35469b0ba0821fe409a8a7a0a71864d33a811", size = 6611, upload-time = "2026-03-01T06:31:27.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383, upload-time = "2026-03-01T06:31:26.257Z" },
+]
+
+[[package]]
+name = "uipath"
+version = "2.10.32"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "applicationinsights" },
+    { name = "click" },
+    { name = "coverage" },
+    { name = "graphtty" },
+    { name = "httpx" },
+    { name = "mermaid-builder" },
+    { name = "mockito" },
+    { name = "pathlib" },
+    { name = "pydantic-function-models" },
+    { name = "pyjwt" },
+    { name = "pysignalr" },
+    { name = "python-dotenv" },
+    { name = "python-socketio" },
+    { name = "rich" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+    { name = "uipath-platform" },
+    { name = "uipath-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/80/3e/57dd2097602a0de1bc11209ebe635b4a1c895eace8f4c388bcdab3220bde/uipath-2.10.32.tar.gz", hash = "sha256:475a194ae441c756ff6100cf2df78f305f85f3a30d247d1e6fc9f980443a6722", size = 2885019, upload-time = "2026-03-26T16:09:56.991Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/07/3b6ec65480f8b2fc168d9d00fe7afc63b2a87b7df684790368831e0fda9f/uipath-2.10.32-py3-none-any.whl", hash = "sha256:2aad5c94c5c6d39cde7b32ccadeedd9a5e591169dec89d038ad1b6d6618b1fcb", size = 366322, upload-time = "2026-03-26T16:09:55.004Z" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2f/6a/91fe6b46a8c28233868072340d47ca29f4c5feadd40a4b3c501658560dd8/uipath_core-0.5.8.tar.gz", hash = "sha256:8f37ab200a0afe11d56d3dd3b5086b4591185e55c8a0a0b0e66f85ae58580f02", size = 116088, upload-time = "2026-03-26T15:40:50.498Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/87/fec9cf831ccf9753b9fab09ab759ae9ba8b65eb5a03a9efbf36b654d8d1d/uipath_core-0.5.8-py3-none-any.whl", hash = "sha256:7f3d2ee982fc6c5752a0c702f1c79f6c8160d746e5f50dabc3add16c21732bac", size = 43032, upload-time = "2026-03-26T15:40:48.754Z" },
+]
+
+[[package]]
+name = "uipath-dev"
+version = "0.0.75"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiosqlite" },
+    { name = "fastapi" },
+    { name = "mcp", extra = ["cli"] },
+    { name = "pyperclip" },
+    { name = "pywinpty", marker = "sys_platform == 'win32'" },
+    { name = "textual" },
+    { name = "uipath" },
+    { name = "uipath-runtime" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/0b/2f62759b6580551e328ceea6e194873d2440535a6654367ca767edde4479/uipath_dev-0.0.75.tar.gz", hash = "sha256:a04fc104da9299dd26e8dfca2a2a224e49e1c5791d9ae99eb8f3db6c334c5a9f", size = 8761204, upload-time = "2026-03-25T21:20:09.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/bd/36f49f8cf4f049c783d565e2e5ba16baa51c3024d8fe3bad17c64d0920b0/uipath_dev-0.0.75-py3-none-any.whl", hash = "sha256:f1d1154d041e3fd3c94a07fd46ef9f3daf5e8a6950f37d4396fa8f35d0242fd6", size = 961576, upload-time = "2026-03-25T21:20:07.933Z" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/14/39/06561ed0c9400beaa4a273b99eb9f62d686aa8f4c404074729a3bb404ca9/uipath_platform-0.1.11.tar.gz", hash = "sha256:3f567a5ce4340c47390fff09f697a15904f225d9600d79373bc49b1660a2ce13", size = 285384, upload-time = "2026-03-26T16:07:54.659Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/55/fecf1552376303c28f45d95fc813cfb6d8722f3a289f98e3a03b6142e566/uipath_platform-0.1.11-py3-none-any.whl", hash = "sha256:3ab0c58500f9e6bb8ae75d62eeb36d91768a776177223e6a836d75705c0c8369", size = 176345, upload-time = "2026-03-26T16:07:53.432Z" },
+]
+
+[[package]]
+name = "uipath-runtime"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/75/64/69462ee01a5607ce36b1fa152c52ac72fb28abe0aa049394406fc0b31525/uipath_runtime-0.10.0.tar.gz", hash = "sha256:d27d58e2252f506c8c0e00f814b37c3863150e8ffcde8e4c6ab14bd98febd3df", size = 139626, upload-time = "2026-03-24T19:42:43.738Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/ed/9c0e97a078b96e4d3742ea3515cb30886b08579cd08077cd42a159adf70d/uipath_runtime-0.10.0-py3-none-any.whl", hash = "sha256:4f52df0b56f54e70fcf34fbf74e223d02b97b5a6fd6d8f64bc06782bb5484b07", size = 42097, upload-time = "2026-03-24T19:42:42.359Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.42.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/ad/4a96c425be6fb67e0621e62d86c402b4a17ab2be7f7c055d9bd2f638b9e2/uvicorn-0.42.0.tar.gz", hash = "sha256:9b1f190ce15a2dd22e7758651d9b6d12df09a13d51ba5bf4fc33c383a48e1775", size = 85393, upload-time = "2026-03-16T06:19:50.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" },
+    { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" },
+    { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" },
+    { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" },
+    { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" },
+    { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "wsproto"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/79/12135bdf8b9c9367b8701c2c19a14c913c120b882d50b014ca0d38083c2c/wsproto-1.3.2.tar.gz", hash = "sha256:b86885dcf294e15204919950f666e06ffc6c7c114ca900b060d6e16293528294", size = 50116, upload-time = "2025-11-20T18:18:01.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath/samples/hello-world/README.md b/packages/uipath/samples/hello-world/README.md
new file mode 100644
index 000000000..76ec01c62
--- /dev/null
+++ b/packages/uipath/samples/hello-world/README.md
@@ -0,0 +1,3 @@
+# Hello World
+
+This is a simple, hello-world script
diff --git a/packages/uipath/samples/hello-world/bindings.json b/packages/uipath/samples/hello-world/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/hello-world/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/hello-world/entry-points.json b/packages/uipath/samples/hello-world/entry-points.json
new file mode 100644
index 000000000..5c12eb4a0
--- /dev/null
+++ b/packages/uipath/samples/hello-world/entry-points.json
@@ -0,0 +1,15 @@
+{
+    "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+    "$id": "entry-points.json",
+    "entryPoints": [
+        {
+            "filePath": "main",
+            "uniqueId": "4656656a-c159-43a6-9263-e3a3f0ba9943",
+            "type": "agent",
+            "input": {},
+            "output": {
+                "type": "object"
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/hello-world/main.py b/packages/uipath/samples/hello-world/main.py
new file mode 100644
index 000000000..c5662340b
--- /dev/null
+++ b/packages/uipath/samples/hello-world/main.py
@@ -0,0 +1,2 @@
+async def main():
+    print("Hello, World!")
diff --git a/packages/uipath/samples/hello-world/pyproject.toml b/packages/uipath/samples/hello-world/pyproject.toml
new file mode 100644
index 000000000..2d5bb0f26
--- /dev/null
+++ b/packages/uipath/samples/hello-world/pyproject.toml
@@ -0,0 +1,13 @@
+[project]
+name = "hello-world"
+version = "0.0.1"
+description = "hello-world"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/hello-world/uipath.json b/packages/uipath/samples/hello-world/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/hello-world/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/line_by_line_test/README.md b/packages/uipath/samples/line_by_line_test/README.md
new file mode 100644
index 000000000..502d46032
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/README.md
@@ -0,0 +1,201 @@
+# Line-by-Line Evaluation Sample
+
+This sample demonstrates the line-by-line evaluation feature for output evaluators.
+
+## Overview
+
+Line-by-line evaluation allows evaluators to:
+- Split multi-line outputs by a configurable delimiter (e.g., `\n`)
+- Evaluate each line independently
+- Provide partial credit based on the percentage of correct lines
+- Return detailed per-line feedback
+
+## Features Demonstrated
+
+- **Partial Credit Scoring**: Get 0.67 for 2/3 correct lines instead of 0.0
+- **Per-Line Feedback**: See exactly which lines passed or failed
+- **Configurable Delimiter**: Use `\n`, `|`, or any custom delimiter
+- **Comparison**: Side-by-side comparison with regular evaluation
+
+## Installation
+
+This sample uses the UiPath package from TestPyPI:
+
+```bash
+# Install dependencies
+uv sync
+
+```
+
+## Usage
+
+### Run the agent
+
+```bash
+uv run uipath run main '{"items": ["apple", "banana", "cherry"]}'
+```
+
+### Run evaluations
+
+```bash
+uv run uipath eval main evaluations/eval-sets/default.json --workers 1
+```
+
+## Evaluation Results
+
+The sample includes three test cases with five evaluators:
+
+### ExactMatch Evaluators
+- **LineByLineExactMatch** - New evaluator with line-by-line support
+- **RegularExactMatch** - New evaluator without line-by-line (for comparison)
+- **LegacyLineByLineExactMatch** - Legacy evaluator with line-by-line support
+
+### Contains Evaluators
+- **LineByLineContains** - New evaluator with line-by-line support (checks if each line contains the search text)
+- **RegularContains** - New evaluator without line-by-line (checks if the entire output contains the search text)
+
+Test cases:
+1. **All lines match exactly** - All evaluators score 1.0
+2. **One line doesn't match** - Line-by-line ExactMatch: 0.67, Regular ExactMatch: 0.0 (shows partial credit!)
+3. **Single item** - All evaluators score 1.0
+
+Expected output (showing ExactMatch evaluators):
+```
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃  Evaluation                   ┃  LineByLineExactMatch  ┃  RegularExactMatch  ┃  LegacyLineByLineExactMatch  ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│  Test all lines match         │                   1.0  │                1.0  │                          1.0  │
+│  Test when one line doesn't   │                   0.7  │                0.0  │                          0.7  │  ← Key difference!
+│  Test with single item        │                   1.0  │                1.0  │                          1.0  │
+├───────────────────────────────┼────────────────────────┼─────────────────────┼───────────────────────────────┤
+│  Average                      │                   0.9  │                0.7  │                          0.9  │
+└───────────────────────────────┴────────────────────────┴─────────────────────┴───────────────────────────────┘
+```
+
+Contains evaluators will all score 1.0 since all test outputs contain "Item:".
+
+## Configuration
+
+### Evaluator Configuration
+
+#### New Evaluators (Version-based)
+
+The line-by-line evaluator is configured in `evaluations/evaluators/line-by-line-exact-match.json`:
+
+```json
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "LineByLineExactMatch",
+    "targetOutputKey": "result",
+    "lineByLineEvaluator": true,
+    "lineDelimiter": "\n"
+  }
+}
+```
+
+#### Legacy Evaluators (Category/Type-based)
+
+Legacy evaluators also support line-by-line evaluation in `evaluations/evaluators/legacy-line-by-line-exact-match.json`:
+
+```json
+{
+  "category": "Deterministic",
+  "type": "Equals",
+  "name": "LegacyLineByLineExactMatch",
+  "targetOutputKey": "result",
+  "lineByLineEvaluation": true,
+  "lineDelimiter": "\n"
+}
+```
+
+#### Contains Evaluators
+
+The Contains evaluator checks if the output contains a specific search text. In line-by-line mode, it checks each line independently:
+
+**Line-by-line Contains** (`evaluations/evaluators/line-by-line-contains.json`):
+```json
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "LineByLineContains",
+    "target_output_key": "result",
+    "line_by_line_evaluator": true,
+    "line_delimiter": "\n",
+    "case_sensitive": false,
+    "negated": false
+  }
+}
+```
+
+**Regular Contains** (`evaluations/evaluators/regular-contains.json`):
+```json
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "RegularContains",
+    "target_output_key": "result",
+    "line_by_line_evaluator": false,
+    "case_sensitive": false,
+    "negated": false
+  }
+}
+```
+
+In evaluation criteria, specify the search text:
+```json
+{
+  "LineByLineContains": {
+    "searchText": "Item:"
+  }
+}
+```
+
+**Behavior difference**:
+- **Line-by-line**: Checks if each line contains "Item:", gives partial credit (e.g., 2/3 if one line is missing it)
+- **Regular**: Checks if the entire output contains "Item:" at least once, returns 1.0 or 0.0
+
+Key options for all evaluator types:
+- `lineByLineEvaluator`/`lineByLineEvaluation`: Enable line-by-line evaluation (default: `false`)
+- `lineDelimiter`: Delimiter to split lines (default: `"\n"`)
+- `case_sensitive`: Case-sensitive comparison (default: `false` for Contains, `true` for ExactMatch)
+- `negated`: Invert the result (default: `false`, only for Contains)
+
+### Custom Delimiters
+
+You can use any delimiter:
+
+```json
+{
+  "evaluatorConfig": {
+    "lineByLineEvaluator": true,
+    "lineDelimiter": "|"  // Pipe-separated values
+  }
+}
+```
+
+## File Structure
+
+```
+line_by_line_test/
+├── main.py                                      # Simple agent that outputs one item per line
+├── uipath.json                                  # Agent configuration
+├── pyproject.toml                               # Dependencies (uses TestPyPI)
+└── evaluations/
+    ├── evaluators/
+    │   ├── line-by-line-exact-match.json           # New line-by-line ExactMatch evaluator
+    │   ├── regular-exact-match.json                 # New regular ExactMatch evaluator
+    │   ├── legacy-line-by-line-exact-match.json    # Legacy line-by-line ExactMatch evaluator
+    │   ├── line-by-line-contains.json              # New line-by-line Contains evaluator
+    │   └── regular-contains.json                    # New regular Contains evaluator
+    └── eval-sets/
+        └── default.json                             # Test cases with all 5 evaluators
+```
+
+## Learn More
+
+- [UiPath Python SDK Documentation](https://docs.uipath.com/)
+- [Evaluation Framework Guide](../../src/uipath/_resources/eval.md)
diff --git a/packages/uipath/samples/line_by_line_test/bindings.json b/packages/uipath/samples/line_by_line_test/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/line_by_line_test/entry-points.json b/packages/uipath/samples/line_by_line_test/entry-points.json
new file mode 100644
index 000000000..90719917b
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/entry-points.json
@@ -0,0 +1,38 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+  "$id": "entry-points.json",
+  "entryPoints": [
+    {
+      "filePath": "main",
+      "uniqueId": "main",
+      "type": "function",
+      "input": {
+        "type": "object",
+        "properties": {
+          "items": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        },
+        "description": "Input schema.",
+        "required": [
+          "items"
+        ]
+      },
+      "output": {
+        "type": "object",
+        "properties": {
+          "result": {
+            "type": "string"
+          }
+        },
+        "description": "Output schema.",
+        "required": [
+          "result"
+        ]
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/default.json b/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..fa8f9691c
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/default.json
@@ -0,0 +1,117 @@
+{
+  "version": "1.0",
+  "id": "line-by-line-test",
+  "name": "Line-by-Line Evaluation Test",
+  "evaluatorRefs": [
+    "LineByLineExactMatch",
+    "RegularExactMatch",
+    "LegacyLineByLineExactMatch",
+    "LineByLineContains",
+    "RegularContains"
+  ],
+  "evaluations": [
+    {
+      "id": "test-all-lines-match",
+      "name": "Test all lines match exactly",
+      "inputs": {
+        "items": [
+          "apple",
+          "banana",
+          "cherry"
+        ]
+      },
+      "evaluationCriterias": {
+        "LineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: banana\nItem: cherry"
+          }
+        },
+        "RegularExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: banana\nItem: cherry"
+          }
+        },
+        "LegacyLineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: banana\nItem: cherry"
+          },
+          "expectedAgentBehavior": ""
+        },
+        "LineByLineContains": {
+          "searchText": "apple"
+        },
+        "RegularContains": {
+          "searchText": "apple"
+        }
+      }
+    },
+    {
+      "id": "test-partial-line-mismatch",
+      "name": "Test when one line doesn't match",
+      "inputs": {
+        "items": [
+          "apple",
+          "banana",
+          "cherry"
+        ]
+      },
+      "evaluationCriterias": {
+        "LineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: WRONG\nItem: cherry"
+          }
+        },
+        "RegularExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: WRONG\nItem: cherry"
+          }
+        },
+        "LegacyLineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple\nItem: WRONG\nItem: cherry"
+          },
+          "expectedAgentBehavior": ""
+        },
+        "LineByLineContains": {
+          "searchText": "Item:"
+        },
+        "RegularContains": {
+          "searchText": "Item:"
+        }
+      }
+    },
+    {
+      "id": "test-single-item",
+      "name": "Test with single item",
+      "inputs": {
+        "items": [
+          "orange"
+        ]
+      },
+      "evaluationCriterias": {
+        "LineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: orange"
+          }
+        },
+        "RegularExactMatch": {
+          "expectedOutput": {
+            "result": "Item: orange"
+          }
+        },
+        "LegacyLineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: orange"
+          },
+          "expectedAgentBehavior": ""
+        },
+        "LineByLineContains": {
+          "searchText": "Item:"
+        },
+        "RegularContains": {
+          "searchText": "Item:"
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/simple_test.json b/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/simple_test.json
new file mode 100644
index 000000000..18b18aef9
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/eval-sets/simple_test.json
@@ -0,0 +1,22 @@
+{
+  "version": "1.0",
+  "id": "simple-test",
+  "name": "Simple Test",
+  "evaluatorRefs": ["LineByLineExactMatch"],
+  "evaluations": [
+    {
+      "id": "test-1",
+      "name": "Single test",
+      "inputs": {
+        "items": ["apple"]
+      },
+      "evaluationCriterias": {
+        "LineByLineExactMatch": {
+          "expectedOutput": {
+            "result": "Item: apple"
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/evaluators/legacy-line-by-line-exact-match.json b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/legacy-line-by-line-exact-match.json
new file mode 100644
index 000000000..15669ca8d
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/legacy-line-by-line-exact-match.json
@@ -0,0 +1,12 @@
+{
+  "id": "LegacyLineByLineExactMatch",
+  "category": 0,
+  "type": 1,
+  "name": "LegacyLineByLineExactMatch",
+  "description": "Legacy evaluator that evaluates each line separately using exact match",
+  "createdAt": "2025-01-01T00:00:00Z",
+  "updatedAt": "2025-01-01T00:00:00Z",
+  "targetOutputKey": "result",
+  "lineByLineEvaluation": true,
+  "lineDelimiter": "\n"
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-contains.json b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-contains.json
new file mode 100644
index 000000000..2dae0353a
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-contains.json
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-contains",
+  "id": "LineByLineContains",
+  "name": "LineByLineContains",
+  "evaluatorConfig": {
+    "name": "LineByLineContains",
+    "target_output_key": "result",
+    "line_by_line_evaluator": true,
+    "line_delimiter": "\n",
+    "case_sensitive": false,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-exact-match.json b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-exact-match.json
new file mode 100644
index 000000000..c658ba849
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/line-by-line-exact-match.json
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "id": "LineByLineExactMatch",
+  "description": "Evaluates each line of output separately using exact match",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "LineByLineExactMatch",
+    "targetOutputKey": "result",
+    "lineByLineEvaluator": true,
+    "lineDelimiter": "\n",
+    "ignoreCase": false,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-contains.json b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-contains.json
new file mode 100644
index 000000000..19e8d74dc
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-contains.json
@@ -0,0 +1,13 @@
+{
+  "version": "1.0",
+  "evaluatorTypeId": "uipath-contains",
+  "id": "RegularContains",
+  "name": "RegularContains",
+  "evaluatorConfig": {
+    "name": "RegularContains",
+    "target_output_key": "result",
+    "line_by_line_evaluator": false,
+    "case_sensitive": false,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-exact-match.json b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-exact-match.json
new file mode 100644
index 000000000..1cf0f00ab
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/evaluations/evaluators/regular-exact-match.json
@@ -0,0 +1,13 @@
+{
+  "version": "1.0",
+  "id": "RegularExactMatch",
+  "description": "Regular exact match evaluator (for comparison)",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "RegularExactMatch",
+    "targetOutputKey": "result",
+    "lineByLineEvaluator": false,
+    "ignoreCase": false,
+    "negated": false
+  }
+}
diff --git a/packages/uipath/samples/line_by_line_test/main.py b/packages/uipath/samples/line_by_line_test/main.py
new file mode 100644
index 000000000..3aeb81efc
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/main.py
@@ -0,0 +1,34 @@
+"""Simple agent to test line-by-line evaluation.
+
+This agent takes a list of items and outputs one result per line.
+"""
+
+from pydantic import BaseModel
+
+
+class Input(BaseModel):
+    """Input schema."""
+
+    items: list[str]
+
+
+class Output(BaseModel):
+    """Output schema."""
+
+    result: str
+
+
+def main(input_data: Input) -> Output:
+    """Process items and return one result per line.
+
+    Args:
+        input_data: Input containing list of items
+
+    Returns:
+        Output with one processed item per line
+    """
+    results = []
+    for item in input_data.items:
+        results.append(f"Item: {item}")
+
+    return Output(result="\n".join(results))
diff --git a/packages/uipath/samples/line_by_line_test/pyproject.toml b/packages/uipath/samples/line_by_line_test/pyproject.toml
new file mode 100644
index 000000000..f4912f262
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "line-by-line-test"
+version = "0.1.0"
+description = "Sample agent demonstrating line-by-line evaluation"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+requires-python = ">=3.11"
+dependencies = [
+  "uipath"
+]
+
+[tool.uv.sources]
+uipath = { path = "../..", editable = true }
diff --git a/packages/uipath/samples/line_by_line_test/uipath.json b/packages/uipath/samples/line_by_line_test/uipath.json
new file mode 100644
index 000000000..7854b316e
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/uipath.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "main.py:main"
+  },
+  "agents": {}
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/line_by_line_test/uv.lock b/packages/uipath/samples/line_by_line_test/uv.lock
new file mode 100644
index 000000000..b990b3f58
--- /dev/null
+++ b/packages/uipath/samples/line_by_line_test/uv.lock
@@ -0,0 +1,1605 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "applicationinsights"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f2/46a75ac6096d60da0e71a068015b610206e697de01fa2fb5bba8564b0798/applicationinsights-0.11.10.tar.gz", hash = "sha256:0b761f3ef0680acf4731906dfc1807faa6f2a57168ae74592db0084a6099f7b3", size = 44722, upload-time = "2021-04-22T23:22:45.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/0d/cb6b23164eb55eebaa5f9f302dfe557cfa751bd7b2779863f1abd0343b6b/applicationinsights-0.11.10-py2.py3-none-any.whl", hash = "sha256:e89a890db1c6906b6a7d0bcfd617dac83974773c64573147c8d6654f9cf2a6ea", size = 55068, upload-time = "2021-04-22T23:22:44.451Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bidict"
+version = "0.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093, upload-time = "2024-02-18T19:09:05.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "graphtty"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/b3/0756e1b1e46b61a4db4a463a76ca113e62113742f97ac6cf383dd05d6a97/graphtty-0.1.8.tar.gz", hash = "sha256:069cd84764cc64d414928451071fc9c97c05becbf564c2f0278691a6451a8240", size = 638011, upload-time = "2026-02-15T12:47:17.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/a9/66d01580a4a92b576c056e9967d552a28ed836540eaf73b436474c514bc2/graphtty-0.1.8-py3-none-any.whl", hash = "sha256:4e19e6d66b9ef79e2715377163f61a6542b5b9ee00d50406b80a40d0ba094f67", size = 25474, upload-time = "2026-02-15T12:47:16.377Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "line-by-line-test"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "uipath" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "uipath", editable = "../../" }]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mermaid-builder"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/57/d83e7e62de05adbba2476b7596ed4a253907a4f4c19be74c40e7ce2944dc/mermaid_builder-0.0.3.tar.gz", hash = "sha256:3016ef25668bcb28de4a4746aabdfaa531c06a7e7f89fa1596e6a274c7c73705", size = 7183, upload-time = "2024-06-14T17:14:51.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/7480454b7ee7de5c2c8561e83b4564196ecf1c9847e893dfbb51032e5a3b/mermaid_builder-0.0.3-py3-none-any.whl", hash = "sha256:decd7d25268bda7a520ce0cab7873e50fac1e33b41e5a1dd7daec5c0ae3c7ffb", size = 6696, upload-time = "2024-06-14T17:14:38.48Z" },
+]
+
+[[package]]
+name = "mockito"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/4b/d342e6910379d04557fc1c32ea63d49d0c630d0dbeb81240482fbf13be87/mockito-2.0.3.tar.gz", hash = "sha256:8cb4981b56b0b96295c9581fff55e3d669ecdbcdc547762a4f10b46ae4032aea", size = 217711, upload-time = "2026-03-15T17:27:22.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/bf/138a95593c5fbaca78090e5c10259a682ec0c544974188a9defb726dd8b1/mockito-2.0.3-py3-none-any.whl", hash = "sha256:c6b104bda0b4808d4f6063b877e2c59dbaada940aad8eebd16463b5f5d423da2", size = 51944, upload-time = "2026-03-15T17:27:21.534Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" },
+    { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" },
+    { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathlib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298, upload-time = "2014-09-03T15:41:57.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363, upload-time = "2022-05-04T13:37:20.585Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[[package]]
+name = "pysignalr"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "msgpack" },
+    { name = "orjson" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/a6/ac80bd4972604c6930050e8b0eba41d6fde41cb3286087be0188a8865f55/pysignalr-1.3.0.tar.gz", hash = "sha256:ca2e4372f213d82148fa2f060f0fefd096f1f66fca1107ac05e76ec6abd4cf52", size = 16790, upload-time = "2025-04-29T21:23:38.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/54/74e35563927ab8538e1bd1404b35027861434aecf2bcc945ff30c188e56d/pysignalr-1.3.0-py3-none-any.whl", hash = "sha256:423c91b0d1dc8387f37118ac2d1dc87ed6b9e01993a04612eab8452193f40344", size = 19966, upload-time = "2025-04-29T21:23:37.513Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-engineio"
+version = "4.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "simple-websocket" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/12/bdef9dbeedbe2cdeba2a2056ad27b1fb081557d34b69a97f574843462cae/python_engineio-4.13.1.tar.gz", hash = "sha256:0a853fcef52f5b345425d8c2b921ac85023a04dfcf75d7b74696c61e940fd066", size = 92348, upload-time = "2026-02-06T23:38:06.12Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/54/0cce26da03a981f949bb8449c9778537f75f5917c172e1d2992ff25cb57d/python_engineio-4.13.1-py3-none-any.whl", hash = "sha256:f32ad10589859c11053ad7d9bb3c9695cdf862113bfb0d20bc4d890198287399", size = 59847, upload-time = "2026-02-06T23:38:04.861Z" },
+]
+
+[[package]]
+name = "python-socketio"
+version = "5.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bidict" },
+    { name = "python-engineio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/81/cf8284f45e32efa18d3848ed82cdd4dcc1b657b082458fbe01ad3e1f2f8d/python_socketio-5.16.1.tar.gz", hash = "sha256:f863f98eacce81ceea2e742f6388e10ca3cdd0764be21d30d5196470edf5ea89", size = 128508, upload-time = "2026-02-06T23:42:07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c7/deb8c5e604404dbf10a3808a858946ca3547692ff6316b698945bb72177e/python_socketio-5.16.1-py3-none-any.whl", hash = "sha256:a3eb1702e92aa2f2b5d3ba00261b61f062cce51f1cfb6900bf3ab4d1934d2d35", size = 82054, upload-time = "2026-02-06T23:42:05.772Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "simple-websocket"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/59/0782e51887ac6b07ffd1570e0364cf901ebc36345fea669969d2084baebb/simple_websocket-1.1.0-py3-none-any.whl", hash = "sha256:4af6069630a38ed6c561010f0e11a5bc0d4ca569b36306eb257cd9a192497c8c", size = 13842, upload-time = "2024-10-10T22:39:29.645Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath"
+version = "2.10.30"
+source = { editable = "../../" }
+dependencies = [
+    { name = "applicationinsights" },
+    { name = "click" },
+    { name = "coverage" },
+    { name = "graphtty" },
+    { name = "httpx" },
+    { name = "mermaid-builder" },
+    { name = "mockito" },
+    { name = "pathlib" },
+    { name = "pydantic-function-models" },
+    { name = "pyjwt" },
+    { name = "pysignalr" },
+    { name = "python-dotenv" },
+    { name = "python-socketio" },
+    { name = "rich" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+    { name = "uipath-platform" },
+    { name = "uipath-runtime" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "applicationinsights", specifier = ">=0.11.10" },
+    { name = "click", specifier = ">=8.3.1" },
+    { name = "coverage", specifier = ">=7.8.2" },
+    { name = "graphtty", specifier = "==0.1.8" },
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "mermaid-builder", specifier = "==0.0.3" },
+    { name = "mockito", specifier = ">=1.5.4" },
+    { name = "pathlib", specifier = ">=1.0.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "pyjwt", specifier = ">=2.10.1" },
+    { name = "pysignalr", specifier = "==1.3.0" },
+    { name = "python-dotenv", specifier = ">=1.0.1" },
+    { name = "python-socketio", specifier = ">=5.15.0,<6.0.0" },
+    { name = "rich", specifier = ">=14.2.0" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+    { name = "uipath-platform", editable = "../../../uipath-platform" },
+    { name = "uipath-runtime", specifier = ">=0.9.1,<0.10.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "filelock", specifier = ">=3.20.3" },
+    { name = "inflection", specifier = ">=0.5.1" },
+    { name = "mkdocs", specifier = ">=1.6.1" },
+    { name = "mkdocs-click", specifier = ">=0.9.0" },
+    { name = "mkdocs-llmstxt", specifier = ">=0.5.0" },
+    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.7.0" },
+    { name = "mkdocs-open-in-new-tab", specifier = ">=1.0.8" },
+    { name = "mkdocs-simple-hooks", specifier = ">=0.1.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.30.1" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.5.1" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+    { name = "termynal", specifier = ">=0.13.1" },
+    { name = "tomli-w", specifier = ">=1.2.0" },
+    { name = "types-toml", specifier = ">=0.10.8" },
+    { name = "virtualenv", specifier = ">=20.36.1" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.7"
+source = { editable = "../../../uipath-core" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.8"
+source = { editable = "../../../uipath-platform" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "sqlparse", specifier = ">=0.5.5" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../../../uipath-core" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-runtime"
+version = "0.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/eb/774d503e174e17af84eabb9d315683c5616fb0da956f93f99cf79912a6ff/uipath_runtime-0.9.3.tar.gz", hash = "sha256:5010ede13919d6883a6373cd137c06c18de2b6e2e9fa6b65e11f2d255db444e5", size = 139338, upload-time = "2026-03-04T20:49:11.153Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/83/52dc4d5bf534368d753656881306dffeed658e5e7eefcb91fe6c3bd0dfac/uipath_runtime-0.9.3-py3-none-any.whl", hash = "sha256:20aefc8d9b23978032bec67d2057b5457059aaf1ea788a71d218ba8b6816ff98", size = 41766, upload-time = "2026-03-04T20:49:10.005Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "wsproto"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/79/12135bdf8b9c9367b8701c2c19a14c913c120b882d50b014ca0d38083c2c/wsproto-1.3.2.tar.gz", hash = "sha256:b86885dcf294e15204919950f666e06ffc6c7c114ca900b060d6e16293528294", size = 50116, upload-time = "2025-11-20T18:18:01.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/packages/uipath/samples/list-mcp-agent/bindings.json b/packages/uipath/samples/list-mcp-agent/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/list-mcp-agent/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/list-mcp-agent/input.json b/packages/uipath/samples/list-mcp-agent/input.json
new file mode 100644
index 000000000..6f536603d
--- /dev/null
+++ b/packages/uipath/samples/list-mcp-agent/input.json
@@ -0,0 +1,3 @@
+{
+  "server_name": "mcpfinanceserver"
+}
diff --git a/packages/uipath/samples/list-mcp-agent/main.py b/packages/uipath/samples/list-mcp-agent/main.py
new file mode 100644
index 000000000..2d71c7697
--- /dev/null
+++ b/packages/uipath/samples/list-mcp-agent/main.py
@@ -0,0 +1,114 @@
+import os
+
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+from pydantic.dataclasses import dataclass
+
+from uipath.platform import UiPath
+from uipath.platform.orchestrator import McpServer
+from uipath.tracing import traced
+
+
+@dataclass
+class McpAgentInput:
+    server_name: str
+
+
+@dataclass
+class McpAgentOutput:
+    message: str
+
+
+def list_mcp_servers() -> list[McpServer]:
+    uipath = UiPath()
+    return uipath.mcp.list(folder_path="Shared")
+
+
+def retrieve_mcp_server(slug: str) -> McpServer:
+    uipath = UiPath()
+    return uipath.mcp.retrieve(slug, folder_path="Shared")
+
+
+async def connect_and_list_tools(server: McpServer) -> list[str]:
+    tool_descriptions = []
+
+    try:
+        access_token = os.environ.get("UIPATH_ACCESS_TOKEN")
+        if not access_token:
+            tool_descriptions.append("No UIPATH_ACCESS_TOKEN environment variable found. Please authenticate using `uipath auth`")
+            return tool_descriptions
+
+        if not server.mcp_url:
+            tool_descriptions.append("No MCP URL available for this server")
+            return tool_descriptions
+
+        headers = {"Authorization": f"Bearer {access_token}"}
+
+        async with streamablehttp_client(
+            url=server.mcp_url,
+            headers=headers,
+            timeout=60,
+            sse_read_timeout=60,
+        ) as (read, write, _):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                tools_result = await session.list_tools()
+
+                if not tools_result.tools:
+                    tool_descriptions.append("No tools available")
+                else:
+                    for tool in tools_result.tools:
+                        tool_descriptions.append(
+                            f"  - {tool.name}: {tool.description or 'No description'}"
+                        )
+
+    except Exception as e:
+        tool_descriptions.append(f"Error connecting to server: {str(e)}")
+
+    return tool_descriptions
+
+
+def format_servers_with_tools(
+    detailed_server: McpServer | None = None,
+    tools: list[str] | None = None,
+) -> str:
+    result_lines = [f"Available Tools for {detailed_server.name if detailed_server else 'Unknown Server'}\n"]
+    if tools:
+        result_lines.extend(tools)
+
+    return "\n".join(result_lines).strip()
+
+
+def format_server_not_found(servers: list[McpServer], requested_name: str) -> str:
+    result_lines = [
+        f"Server '{requested_name}' Not Found\n",
+        "The requested MCP server does not exist.\n",
+        "Available MCP servers:",
+    ]
+
+    if servers:
+        for server in servers:
+            status = "active" if server.is_active else "inactive"
+            server_type = server.type if server.type is not None else "unknown"
+            result_lines.append(f"  - {server.name} (slug: {server.slug}, status: {status}, type: {server_type})")
+    else:
+        result_lines.append("No servers available")
+
+    return "\n".join(result_lines)
+
+
+@traced()
+async def main(input: McpAgentInput) -> McpAgentOutput:
+    servers = list_mcp_servers()
+
+    target_server = next((s for s in servers if s.name == input.server_name), None)
+
+    if not target_server:
+        message = format_server_not_found(servers, input.server_name)
+        return McpAgentOutput(message=message)
+
+    detailed_server = retrieve_mcp_server(target_server.slug)
+    tools = await connect_and_list_tools(detailed_server)
+
+    message = format_servers_with_tools(detailed_server=detailed_server, tools=tools)
+    return McpAgentOutput(message=message)
diff --git a/packages/uipath/samples/list-mcp-agent/pyproject.toml b/packages/uipath/samples/list-mcp-agent/pyproject.toml
new file mode 100644
index 000000000..b4d0c5f29
--- /dev/null
+++ b/packages/uipath/samples/list-mcp-agent/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "list-mcp-agent"
+version = "0.0.1"
+description = "UiPath MCP agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+    "mcp>=1.0.0",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/list-mcp-agent/uipath.json b/packages/uipath/samples/list-mcp-agent/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/list-mcp-agent/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/bindings.json b/packages/uipath/samples/list_target_output_key_test/bindings.json
new file mode 100644
index 000000000..6122d0e77
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/entry-points.json b/packages/uipath/samples/list_target_output_key_test/entry-points.json
new file mode 100644
index 000000000..55ce49fba
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/entry-points.json
@@ -0,0 +1,41 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+  "$id": "entry-points.json",
+  "entryPoints": [
+    {
+      "filePath": "main",
+      "uniqueId": "main",
+      "type": "function",
+      "input": {
+        "type": "object",
+        "properties": {
+          "product_id": {
+            "type": "string"
+          }
+        },
+        "description": "Input schema.",
+        "required": [
+          "product_id"
+        ]
+      },
+      "output": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string" },
+          "price": { "type": "number" },
+          "category": { "type": "string" },
+          "in_stock": { "type": "boolean" },
+          "rating": { "type": "number" }
+        },
+        "description": "Output schema.",
+        "required": [
+          "name",
+          "price",
+          "category",
+          "in_stock",
+          "rating"
+        ]
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/evaluations/eval-sets/default.json b/packages/uipath/samples/list_target_output_key_test/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..87c49fdc0
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/evaluations/eval-sets/default.json
@@ -0,0 +1,74 @@
+{
+  "version": "1.0",
+  "id": "list-target-output-key-tests",
+  "name": "List Target Output Key Tests",
+  "evaluatorRefs": [
+    "ListKeysExactMatch",
+    "ListKeysJsonSimilarity"
+  ],
+  "evaluations": [
+    {
+      "id": "headphones-all-match",
+      "name": "Headphones - all keys match",
+      "inputs": {
+        "product_id": "p001"
+      },
+      "evaluationCriterias": {
+        "ListKeysExactMatch": {
+          "expectedOutput": {
+            "name": "Wireless Headphones",
+            "price": 79.99
+          }
+        },
+        "ListKeysJsonSimilarity": {
+          "expectedOutput": {
+            "category": "Electronics",
+            "in_stock": true
+          }
+        }
+      }
+    },
+    {
+      "id": "shoes-all-match",
+      "name": "Running Shoes - all keys match",
+      "inputs": {
+        "product_id": "p002"
+      },
+      "evaluationCriterias": {
+        "ListKeysExactMatch": {
+          "expectedOutput": {
+            "name": "Running Shoes",
+            "price": 120.0
+          }
+        },
+        "ListKeysJsonSimilarity": {
+          "expectedOutput": {
+            "category": "Sports",
+            "in_stock": false
+          }
+        }
+      }
+    },
+    {
+      "id": "headphones-wrong-price",
+      "name": "Headphones - wrong price (should fail)",
+      "inputs": {
+        "product_id": "p001"
+      },
+      "evaluationCriterias": {
+        "ListKeysExactMatch": {
+          "expectedOutput": {
+            "name": "Wireless Headphones",
+            "price": 999.0
+          }
+        },
+        "ListKeysJsonSimilarity": {
+          "expectedOutput": {
+            "category": "Electronics",
+            "in_stock": true
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-exact-match.json b/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-exact-match.json
new file mode 100644
index 000000000..65e77a8b1
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-exact-match.json
@@ -0,0 +1,10 @@
+{
+  "version": "1.0",
+  "id": "ListKeysExactMatch",
+  "description": "Asserts 'name' and 'price' together using a list of target output keys",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ListKeysExactMatch",
+    "targetOutputKey": ["name", "price"]
+  }
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-json-similarity.json b/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-json-similarity.json
new file mode 100644
index 000000000..f36f1fdea
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/evaluations/evaluators/list-keys-json-similarity.json
@@ -0,0 +1,10 @@
+{
+  "version": "1.0",
+  "id": "ListKeysJsonSimilarity",
+  "description": "Checks 'category' and 'in_stock' together using a list of target output keys",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "ListKeysJsonSimilarity",
+    "targetOutputKey": ["category", "in_stock"]
+  }
+}
diff --git a/packages/uipath/samples/list_target_output_key_test/main.py b/packages/uipath/samples/list_target_output_key_test/main.py
new file mode 100644
index 000000000..ef7e56c73
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/main.py
@@ -0,0 +1,74 @@
+"""Agent demonstrating list targetOutputKey evaluation.
+
+This agent simulates a product lookup: given a product ID it returns
+a structured response with several fields. The evaluators use a list
+of keys so that multiple fields can be asserted in a single evaluator
+configuration, without comparing the entire output dict.
+"""
+
+from pydantic import BaseModel
+
+CATALOG: dict[str, dict[str, object]] = {
+    "p001": {
+        "name": "Wireless Headphones",
+        "price": 79.99,
+        "category": "Electronics",
+        "in_stock": True,
+        "rating": 4.5,
+    },
+    "p002": {
+        "name": "Running Shoes",
+        "price": 120.0,
+        "category": "Sports",
+        "in_stock": False,
+        "rating": 4.8,
+    },
+    "p003": {
+        "name": "Coffee Maker",
+        "price": 49.99,
+        "category": "Kitchen",
+        "in_stock": True,
+        "rating": 4.2,
+    },
+}
+
+
+class Input(BaseModel):
+    """Input schema."""
+
+    product_id: str
+
+
+class Output(BaseModel):
+    """Output schema."""
+
+    name: str
+    price: float
+    category: str
+    in_stock: bool
+    rating: float
+
+
+def main(input_data: Input) -> Output:
+    """Look up a product by ID and return its details.
+
+    Args:
+        input_data: Input containing the product ID.
+
+    Returns:
+        Output with product details.
+
+    Raises:
+        ValueError: If the product ID is not found.
+    """
+    product = CATALOG.get(input_data.product_id)
+    if product is None:
+        raise ValueError(f"Product '{input_data.product_id}' not found")
+
+    return Output(
+        name=str(product["name"]),
+        price=float(product["price"]),  # type: ignore[arg-type]
+        category=str(product["category"]),
+        in_stock=bool(product["in_stock"]),
+        rating=float(product["rating"]),  # type: ignore[arg-type]
+    )
diff --git a/packages/uipath/samples/list_target_output_key_test/pyproject.toml b/packages/uipath/samples/list_target_output_key_test/pyproject.toml
new file mode 100644
index 000000000..ef529b400
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "list-target-output-key-test"
+version = "0.1.0"
+description = "Sample agent demonstrating list targetOutputKey evaluation"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+requires-python = ">=3.11"
+dependencies = [
+  "uipath"
+]
+
+[tool.uv.sources]
+uipath = { path = "../..", editable = true }
diff --git a/packages/uipath/samples/list_target_output_key_test/uipath.json b/packages/uipath/samples/list_target_output_key_test/uipath.json
new file mode 100644
index 000000000..e2a331e84
--- /dev/null
+++ b/packages/uipath/samples/list_target_output_key_test/uipath.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "main.py:main"
+  },
+  "agents": {}
+}
diff --git a/packages/uipath/samples/llm_chat_agent/README.md b/packages/uipath/samples/llm_chat_agent/README.md
new file mode 100644
index 000000000..c2a50329e
--- /dev/null
+++ b/packages/uipath/samples/llm_chat_agent/README.md
@@ -0,0 +1,318 @@
+# LLM Chat Agent Sample
+
+This sample demonstrates how to create an agent that makes actual LLM calls using the UiPath LLM Gateway services.
+
+## Features
+
+- **Simple Chat Completions**: Make basic LLM calls for question answering
+- **Tool/Function Calling**: Enable LLM to use real API integrations
+  - **Weather Tool**: Real-time weather data via OpenWeatherMap API
+  - **Calculator Tool**: Math calculations via Newton API with local fallback
+- **Multi-turn Conversations**: Handle follow-up responses after tool execution
+- **Tracing**: Built-in observability with OpenTelemetry tracing
+- **Type Safety**: Full Pydantic models for inputs and outputs
+
+## Setup
+
+### 1. Install Dependencies
+
+From the repository root:
+
+```bash
+pip install -e .
+```
+
+Or install specific dependencies:
+
+```bash
+cd samples/llm_chat_agent
+pip install -r requirements.txt
+```
+
+### 2. Configure Environment
+
+Set the required environment variables:
+
+**UiPath Configuration:**
+```bash
+export UIPATH_URL="https://cloud.uipath.com/your-org/your-tenant"
+export UIPATH_ACCESS_TOKEN="your_access_token_here"
+```
+
+**Weather API (OpenWeatherMap):**
+```bash
+export OPENWEATHER_API_KEY="your_openweather_api_key"
+```
+
+Get a free API key at: https://openweathermap.org/api
+
+**Note:** The calculator tool uses the free Newton API and doesn't require an API key. It also has a local fallback using Python's eval.
+
+### 3. Run the Agent
+
+```bash
+python agent.py
+```
+
+## Usage Examples
+
+### Example 1: Simple Question (No Tools)
+
+```python
+from agent import main, AgentInput
+import asyncio
+
+input = AgentInput(
+    query="What is the capital of France?",
+    use_tools=False
+)
+result = asyncio.run(main(input))
+print(result.response)
+```
+
+**Output:**
+```
+The capital of France is Paris.
+```
+
+### Example 2: Weather Query (With Tools)
+
+```python
+input = AgentInput(
+    query="What's the weather like in Tokyo?",
+    use_tools=True
+)
+result = asyncio.run(main(input))
+print(result.response)
+print(f"Tools used: {result.tool_calls_made}")
+```
+
+**Output:**
+```
+The weather in Tokyo is currently scattered clouds with a temperature of 68.5°F and humidity at 62%.
+Tools used: ['get_current_weather']
+```
+
+**Note:** This makes a real API call to OpenWeatherMap and returns actual current weather data.
+
+### Example 3: Calculation (With Tools)
+
+```python
+input = AgentInput(
+    query="What is 25 * 47 + 123?",
+    use_tools=True
+)
+result = asyncio.run(main(input))
+print(result.response)
+print(f"Tools used: {result.tool_calls_made}")
+```
+
+**Output:**
+```
+The result of 25 * 47 + 123 is 1,298.
+Tools used: ['calculate']
+```
+
+**Note:** This makes a real API call to Newton API for calculation. If the API is unavailable, it falls back to local evaluation.
+
+## Key Components
+
+### LLM Service Initialization
+
+```python
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import (
+    ChatModels,
+    UiPathLlmChatService,
+)
+
+config = UiPathApiConfig()  # Loads from environment
+execution_context = UiPathExecutionContext()
+llm_service = UiPathLlmChatService(config=config, execution_context=execution_context)
+```
+
+### Making Chat Completions
+
+```python
+result = await llm_service.chat_completions(
+    messages=messages,
+    model=ChatModels.gpt_4_1_mini_2025_04_14,
+    max_tokens=500,
+    temperature=0.7,
+    tools=[WEATHER_TOOL, CALCULATOR_TOOL],  # Optional
+    tool_choice=AutoToolChoice(type="auto"),  # Optional
+)
+```
+
+### Tool Definition
+
+```python
+from uipath.platform.chat import (
+    ToolDefinition,
+    ToolFunctionDefinition,
+    ToolParametersDefinition,
+    ToolPropertyDefinition,
+)
+
+WEATHER_TOOL = ToolDefinition(
+    type="function",
+    function=ToolFunctionDefinition(
+        name="get_current_weather",
+        description="Get the current weather information for a specific city",
+        parameters=ToolParametersDefinition(
+            type="object",
+            properties={
+                "city": ToolPropertyDefinition(
+                    type="string",
+                    description="The name of the city"
+                )
+            },
+            required=["city"],
+        ),
+    ),
+)
+```
+
+### Tool Execution
+
+```python
+# Check if LLM wants to call tools
+if result.choices[0].message.tool_calls:
+    for tool_call in result.choices[0].message.tool_calls:
+        # Execute the tool
+        tool_result = await execute_tool_call(
+            tool_call.name,
+            tool_call.arguments
+        )
+
+        # Add result back to conversation
+        messages.append({
+            "role": "tool",
+            "tool_call_id": tool_call.id,
+            "content": str(tool_result),
+        })
+
+    # Make follow-up LLM call with tool results
+    result = await llm_service.chat_completions(messages=messages, ...)
+```
+
+## Available Models
+
+The agent uses `ChatModels.gpt_4_1_mini_2025_04_14` by default. Other available models:
+
+- `ChatModels.gpt_4`
+- `ChatModels.gpt_4_turbo_2024_04_09`
+- `ChatModels.gpt_4o_2024_05_13`
+- `ChatModels.gpt_4o_2024_08_06`
+- `ChatModels.gpt_4o_mini_2024_07_18`
+- `ChatModels.gpt_4_1_mini_2025_04_14`
+- `ChatModels.o3_mini`
+
+## Tracing and Observability
+
+The agent uses the `@traced()` decorator for automatic tracing:
+
+```python
+from uipath.tracing import traced
+
+@traced()
+async def main(input: AgentInput) -> AgentOutput:
+    # Your implementation
+    pass
+```
+
+This creates OpenTelemetry spans for each function, allowing you to track:
+- LLM call latency
+- Tool execution times
+- Token usage
+- Error rates
+
+## Adding Custom Tools
+
+To add a new tool:
+
+1. **Implement the tool function:**
+
+```python
+@traced()
+async def my_custom_tool(param: str) -> Dict[str, Any]:
+    """Tool implementation."""
+    return {"result": "value"}
+```
+
+2. **Define the tool schema:**
+
+```python
+MY_TOOL = ToolDefinition(
+    type="function",
+    function=ToolFunctionDefinition(
+        name="my_custom_tool",
+        description="Description of what the tool does",
+        parameters=ToolParametersDefinition(
+            type="object",
+            properties={
+                "param": ToolPropertyDefinition(
+                    type="string",
+                    description="Parameter description"
+                )
+            },
+            required=["param"],
+        ),
+    ),
+)
+```
+
+3. **Add to tool execution:**
+
+```python
+async def execute_tool_call(tool_name: str, tool_arguments: Dict[str, Any]) -> Dict[str, Any]:
+    if tool_name == "my_custom_tool":
+        return await my_custom_tool(**tool_arguments)
+    # ... other tools
+```
+
+4. **Pass to LLM:**
+
+```python
+result = await llm_service.chat_completions(
+    messages=messages,
+    tools=[WEATHER_TOOL, CALCULATOR_TOOL, MY_TOOL],
+    # ...
+)
+```
+
+## Troubleshooting
+
+### Authentication Errors
+
+If you see authentication errors, ensure:
+- Your `.env` file has the correct credentials
+- Your OAuth client has the necessary permissions
+- Your tenant name is correct
+
+### Import Errors
+
+If you encounter import errors:
+```bash
+# From repository root
+pip install -e .
+```
+
+### Connection Timeouts
+
+If requests timeout:
+- Check your `UIPATH_BASE_URL` is accessible
+- Verify network connectivity to UiPath Orchestrator
+- Consider increasing timeout values in the Config
+
+## Related Samples
+
+- `weather_tools/` - Shows tool calling with trajectory evaluation
+- `google-ADK-agent/` - Example using Google ADK with Gemini models
+- `calculator/` - Simple calculator agent example
+
+## References
+
+- [UiPath Python SDK Documentation](https://docs.uipath.com/automation-suite/automation-cloud/latest/user-guide/python-sdk)
+- [LLM Gateway Service API](../../src/uipath/_services/llm_gateway_service.py)
+- [Tool Calling Models](../../src/uipath/models/llm_gateway.py)
diff --git a/packages/uipath/samples/llm_chat_agent/agent.py b/packages/uipath/samples/llm_chat_agent/agent.py
new file mode 100644
index 000000000..5a4d2067f
--- /dev/null
+++ b/packages/uipath/samples/llm_chat_agent/agent.py
@@ -0,0 +1,472 @@
+"""
+Sample agent demonstrating actual LLM calls using UiPath LLM Gateway.
+
+This agent shows how to:
+1. Make chat completions with LLM models
+2. Use tools/function calling with real API integrations
+3. Handle multi-turn conversations
+4. Use tracing for observability
+
+API Integrations:
+- Weather: Uses Open-Meteo API (free, no API key required)
+- Calculator: Uses Newton API (free, no API key required) with local eval fallback
+"""
+
+import asyncio
+import json
+import os
+from typing import Any
+
+import httpx
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from uipath.platform import UiPathApiConfig, UiPathExecutionContext
+from uipath.platform.chat import (
+    AutoToolChoice,
+    ChatModels,
+    ToolDefinition,
+    ToolFunctionDefinition,
+    ToolParametersDefinition,
+    ToolPropertyDefinition,
+    UiPathLlmChatService,
+)
+from uipath.tracing import traced
+
+# Load environment variables from .env file if it exists
+# This will not override existing environment variables
+load_dotenv()
+
+
+# Input/Output models
+class AgentInput(BaseModel):
+    """Input model for the agent."""
+
+    query: str = Field(description="User's question or request")
+    use_tools: bool = Field(
+        default=False, description="Whether to enable tool calling"
+    )
+
+
+class AgentOutput(BaseModel):
+    """Output model for the agent."""
+
+    response: str = Field(description="Agent's response to the user")
+    tool_calls_made: list[str] = Field(
+        default_factory=list, description="Names of tools that were called"
+    )
+
+
+# Tool implementations
+@traced()
+async def get_current_weather(city: str) -> dict[str, Any]:
+    """
+    Get the current weather for a city using Open-Meteo API.
+
+    This makes a real API call to fetch current weather data.
+    Open-Meteo is completely free, requires no API key, and has no rate limits for reasonable use.
+    Learn more at: https://open-meteo.com/
+    """
+    try:
+        async with httpx.AsyncClient() as client:
+            # First, geocode the city name to get coordinates
+            # Using Open-Meteo's geocoding API
+            geocoding_url = "https://geocoding-api.open-meteo.com/v1/search"
+            geocoding_params = {
+                "name": city,
+                "count": 1,
+                "language": "en",
+                "format": "json"
+            }
+
+            geo_response = await client.get(geocoding_url, params=geocoding_params, timeout=10.0)
+            geo_response.raise_for_status()
+            geo_data = geo_response.json()
+
+            if not geo_data.get("results"):
+                return {
+                    "city": city,
+                    "error": f"City '{city}' not found",
+                }
+
+            # Get the first result
+            location = geo_data["results"][0]
+            latitude = location["latitude"]
+            longitude = location["longitude"]
+            city_name = location["name"]
+            country = location.get("country", "")
+
+            # Now get the weather data using the coordinates
+            weather_url = "https://api.open-meteo.com/v1/forecast"
+            weather_params = {
+                "latitude": latitude,
+                "longitude": longitude,
+                "current": "temperature_2m,relative_humidity_2m,weather_code",
+                "temperature_unit": "fahrenheit",
+                "timezone": "auto"
+            }
+
+            weather_response = await client.get(weather_url, params=weather_params, timeout=10.0)
+            weather_response.raise_for_status()
+            weather_data = weather_response.json()
+
+            current = weather_data["current"]
+
+            # Map weather codes to descriptions
+            # https://open-meteo.com/en/docs
+            weather_code = current.get("weather_code", 0)
+            condition = get_weather_description(weather_code)
+
+            return {
+                "city": f"{city_name}, {country}" if country else city_name,
+                "temperature": current["temperature_2m"],
+                "condition": condition,
+                "humidity": current["relative_humidity_2m"],
+                "unit": "fahrenheit",
+            }
+
+    except httpx.HTTPStatusError as e:
+        return {
+            "city": city,
+            "error": f"API error: {e.response.status_code}",
+        }
+    except Exception as e:
+        return {
+            "city": city,
+            "error": f"Failed to fetch weather data: {str(e)}",
+        }
+
+
+def get_weather_description(code: int) -> str:
+    """
+    Convert Open-Meteo weather codes to human-readable descriptions.
+    Based on WMO Weather interpretation codes.
+    """
+    weather_codes = {
+        0: "clear sky",
+        1: "mainly clear",
+        2: "partly cloudy",
+        3: "overcast",
+        45: "foggy",
+        48: "depositing rime fog",
+        51: "light drizzle",
+        53: "moderate drizzle",
+        55: "dense drizzle",
+        61: "slight rain",
+        63: "moderate rain",
+        65: "heavy rain",
+        71: "slight snow fall",
+        73: "moderate snow fall",
+        75: "heavy snow fall",
+        77: "snow grains",
+        80: "slight rain showers",
+        81: "moderate rain showers",
+        82: "violent rain showers",
+        85: "slight snow showers",
+        86: "heavy snow showers",
+        95: "thunderstorm",
+        96: "thunderstorm with slight hail",
+        99: "thunderstorm with heavy hail",
+    }
+    return weather_codes.get(code, "unknown")
+
+
+@traced()
+async def calculate(expression: str) -> dict[str, Any]:
+    """
+    Perform a mathematical calculation using Newton API.
+
+    This makes a real API call to evaluate mathematical expressions.
+    The Newton API is free and doesn't require an API key.
+
+    Args:
+        expression: A mathematical expression to evaluate (e.g., "2 + 2", "10 * 5")
+
+    Returns:
+        Dictionary with the result or error message
+    """
+    try:
+        # For simple arithmetic, we'll use Newton API's simplify endpoint
+        # Newton API: https://newton.vercel.app/
+        async with httpx.AsyncClient() as client:
+            # URL encode the expression
+            encoded_expr = expression.replace(" ", "")
+            url = f"https://newton.vercel.app/api/v2/simplify/{encoded_expr}"
+
+            response = await client.get(url, timeout=10.0)
+            response.raise_for_status()
+
+            data = response.json()
+
+            if data.get("result"):
+                return {
+                    "expression": expression,
+                    "result": data["result"]
+                }
+            else:
+                return {
+                    "expression": expression,
+                    "error": "Could not evaluate expression"
+                }
+
+    except httpx.HTTPStatusError as e:
+        return {
+            "expression": expression,
+            "error": f"API error: {e.response.status_code}"
+        }
+    except Exception as e:
+        # Fallback to local evaluation for simple cases
+        try:
+            allowed_chars = set("0123456789+-*/()%. ")
+            if not all(c in allowed_chars for c in expression):
+                return {"expression": expression, "error": "Invalid characters in expression"}
+
+            result = eval(expression)
+            return {
+                "expression": expression,
+                "result": result,
+                "note": "Evaluated locally (API unavailable)"
+            }
+        except Exception as eval_error:
+            return {
+                "expression": expression,
+                "error": f"Failed to calculate: {str(e)}, fallback error: {str(eval_error)}"
+            }
+
+
+# Tool definitions for LLM
+WEATHER_TOOL = ToolDefinition(
+    type="function",
+    function=ToolFunctionDefinition(
+        name="get_current_weather",
+        description="Get the current weather information for a specific city",
+        parameters=ToolParametersDefinition(
+            type="object",
+            properties={
+                "city": ToolPropertyDefinition(
+                    type="string", description="The name of the city"
+                )
+            },
+            required=["city"],
+        ),
+    ),
+)
+
+CALCULATOR_TOOL = ToolDefinition(
+    type="function",
+    function=ToolFunctionDefinition(
+        name="calculate",
+        description="Perform mathematical calculations. Can evaluate expressions like '2 + 2' or '10 * 5'",
+        parameters=ToolParametersDefinition(
+            type="object",
+            properties={
+                "expression": ToolPropertyDefinition(
+                    type="string",
+                    description="The mathematical expression to evaluate",
+                )
+            },
+            required=["expression"],
+        ),
+    ),
+)
+
+
+@traced()
+async def execute_tool_call(tool_name: str, tool_arguments: dict[str, Any]) -> dict[str, Any]:
+    """
+    Execute a tool based on its name and arguments.
+
+    Args:
+        tool_name: Name of the tool to execute
+        tool_arguments: Arguments to pass to the tool
+
+    Returns:
+        Result from the tool execution
+    """
+    if tool_name == "get_current_weather":
+        return await get_current_weather(**tool_arguments)
+    elif tool_name == "calculate":
+        return await calculate(**tool_arguments)
+    else:
+        return {"error": f"Unknown tool: {tool_name}"}
+
+
+@traced()
+async def main(input: AgentInput) -> AgentOutput:
+    """
+    Main agent function that makes LLM calls.
+
+    This demonstrates:
+    1. Simple chat completions
+    2. Tool/function calling
+    3. Multi-turn conversations with tool results
+    """
+    # Initialize the LLM service
+    # Get credentials from environment variables
+    base_url = os.environ.get("UIPATH_URL")
+    access_token = os.environ.get("UIPATH_ACCESS_TOKEN")
+
+    if not base_url or not access_token:
+        error_msg = """
+        Missing required environment variables. Please set:
+        - UIPATH_URL: Your UiPath Orchestrator URL (e.g., https://cloud.uipath.com/org/tenant)
+        - UIPATH_ACCESS_TOKEN: Your API access token
+
+        You can set them in your shell:
+        export UIPATH_URL="https://cloud.uipath.com/your-org/your-tenant"
+        export UIPATH_ACCESS_TOKEN="your_token_here"
+
+        Or create a .env file with these variables.
+        """
+        print(error_msg)
+        return AgentOutput(response=error_msg.strip(), tool_calls_made=[])
+
+    config = UiPathApiConfig(base_url=base_url, secret=access_token)
+    execution_context = UiPathExecutionContext()
+    llm_service = UiPathLlmChatService(config=config, execution_context=execution_context)
+
+    # Prepare the conversation
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a helpful assistant that can answer questions and use tools when needed.",
+        },
+        {"role": "user", "content": input.query},
+    ]
+
+    tool_calls_made = []
+
+    try:
+        if input.use_tools:
+            # Make LLM call with tool support
+            print(f"Making LLM call with tools enabled for query: {input.query}")
+
+            result = await llm_service.chat_completions(
+                messages=messages,
+                model=ChatModels.gpt_4_1_mini_2025_04_14,
+                max_tokens=500,
+                temperature=0.7,
+                tools=[WEATHER_TOOL, CALCULATOR_TOOL],
+                tool_choice=AutoToolChoice(type="auto"),
+            )
+
+            # Check if the model wants to call tools
+            if result.choices[0].message.tool_calls:
+                print(f"LLM requested {len(result.choices[0].message.tool_calls)} tool call(s)")
+
+                # Add assistant's response to messages
+                # Convert tool calls to proper format
+                tool_calls_for_message = []
+                for tc in result.choices[0].message.tool_calls:
+                    tool_call_dict = {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.name,
+                            "arguments": tc.arguments if isinstance(tc.arguments, str) else json.dumps(tc.arguments),
+                        },
+                    }
+                    tool_calls_for_message.append(tool_call_dict)
+
+                # Execute each tool call and collect results
+                tool_results_text = []
+                for tool_call in result.choices[0].message.tool_calls:
+                    print(f"Executing tool: {tool_call.name} with args: {tool_call.arguments}")
+                    tool_calls_made.append(tool_call.name)
+
+                    # Execute the tool
+                    tool_result = await execute_tool_call(
+                        tool_call.name, tool_call.arguments
+                    )
+                    tool_results_text.append(f"{tool_call.name}: {json.dumps(tool_result)}")
+
+                # Add a simple assistant acknowledgment and user message with tool results
+                # NOTE: UiPath LLM Gateway API doesn't support assistant messages with tool_calls
+                # or messages with "tool" role, so we work around it
+                messages.append(
+                    {
+                        "role": "assistant",
+                        "content": "Let me check that for you.",
+                    }
+                )
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": f"Here are the tool results: {'; '.join(tool_results_text)}. Please provide a natural language response to my original question.",
+                    }
+                )
+
+                # Make another LLM call with tool results
+                # No need to pass tools again since we've already executed them
+                print("Making follow-up LLM call with tool results")
+                result = await llm_service.chat_completions(
+                    messages=messages,
+                    model=ChatModels.gpt_4_1_mini_2025_04_14,
+                    max_tokens=500,
+                    temperature=0.7,
+                )
+
+            response = result.choices[0].message.content or "No response generated"
+            print(f"Final response: {response}")
+
+        else:
+            # Simple chat completion without tools
+            print(f"Making simple LLM call for query: {input.query}")
+
+            result = await llm_service.chat_completions(
+                messages=messages,
+                model=ChatModels.gpt_4_1_mini_2025_04_14,
+                max_tokens=300,
+                temperature=0.7,
+            )
+
+            response = result.choices[0].message.content or "No response generated"
+            print(f"Response: {response}")
+
+        return AgentOutput(response=response, tool_calls_made=tool_calls_made)
+
+    except Exception as e:
+        error_msg = f"Error making LLM call: {str(e)}"
+        print(error_msg)
+        return AgentOutput(response=error_msg, tool_calls_made=tool_calls_made)
+
+
+# Example usage
+if __name__ == "__main__":
+    # Example 1: Simple question without tools
+    print("=" * 80)
+    print("Example 1: Simple question")
+    print("=" * 80)
+    input1 = AgentInput(
+        query="What is the capital of France?",
+        use_tools=False
+    )
+    result1 = asyncio.run(main(input1))
+    print(f"\nQuery: {input1.query}")
+    print(f"Response: {result1.response}")
+    print(f"Tools used: {result1.tool_calls_made or 'None'}")
+
+    # Example 2: Question that requires weather tool
+    print("\n" + "=" * 80)
+    print("Example 2: Weather query with tools")
+    print("=" * 80)
+    input2 = AgentInput(
+        query="What's the weather like in Tokyo?",
+        use_tools=True
+    )
+    result2 = asyncio.run(main(input2))
+    print(f"\nQuery: {input2.query}")
+    print(f"Response: {result2.response}")
+    print(f"Tools used: {result2.tool_calls_made}")
+
+    # Example 3: Question that requires calculator tool
+    print("\n" + "=" * 80)
+    print("Example 3: Calculation with tools")
+    print("=" * 80)
+    input3 = AgentInput(
+        query="What is 25 * 47 + 123?",
+        use_tools=True
+    )
+    result3 = asyncio.run(main(input3))
+    print(f"\nQuery: {input3.query}")
+    print(f"Response: {result3.response}")
+    print(f"Tools used: {result3.tool_calls_made}")
diff --git a/packages/uipath/samples/llm_chat_agent/bindings.json b/packages/uipath/samples/llm_chat_agent/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/llm_chat_agent/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/llm_chat_agent/pyproject.toml b/packages/uipath/samples/llm_chat_agent/pyproject.toml
new file mode 100644
index 000000000..d47757abe
--- /dev/null
+++ b/packages/uipath/samples/llm_chat_agent/pyproject.toml
@@ -0,0 +1,13 @@
+[project]
+name = "llm-chat-agent"
+version = "0.0.1"
+description = "Sample agent demonstrating actual LLM calls with UiPath LLM Gateway"
+requires-python = ">=3.11"
+dependencies = [
+    "uipath",
+]
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/llm_chat_agent/uipath.json b/packages/uipath/samples/llm_chat_agent/uipath.json
new file mode 100644
index 000000000..77b646626
--- /dev/null
+++ b/packages/uipath/samples/llm_chat_agent/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "agent": "agent.py:main"
+  }
+}
diff --git a/packages/uipath/samples/multi-output-agent/bindings.json b/packages/uipath/samples/multi-output-agent/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/list-keys.json b/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/list-keys.json
new file mode 100644
index 000000000..d1f6e177b
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/list-keys.json
@@ -0,0 +1,51 @@
+{
+  "version": "1.0",
+  "id": "list-keys-eval-set",
+  "name": "List Target Output Key Tests",
+  "evaluatorRefs": [
+    "list-keys-exact-match"
+  ],
+  "evaluations": [
+    {
+      "id": "list-keys-basic",
+      "name": "Check multiple keys - order completed",
+      "inputs": {
+        "customer_name": "John Doe",
+        "items": [
+          {"name": "Widget", "quantity": 2, "price": 9.99},
+          {"name": "Gadget", "quantity": 1, "price": 24.99}
+        ]
+      },
+      "evaluationCriterias": {
+        "list-keys-exact-match": {
+          "expectedOutput": {
+            "summary": {
+              "status": "completed",
+              "total": 44.97
+            }
+          }
+        }
+      }
+    },
+    {
+      "id": "list-keys-mismatch",
+      "name": "Check multiple keys - wrong total (should fail)",
+      "inputs": {
+        "customer_name": "Jane Smith",
+        "items": [
+          {"name": "Book", "quantity": 1, "price": 15.0}
+        ]
+      },
+      "evaluationCriterias": {
+        "list-keys-exact-match": {
+          "expectedOutput": {
+            "summary": {
+              "status": "completed",
+              "total": 999.0
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/target-output-key.json b/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/target-output-key.json
new file mode 100644
index 000000000..b513c9565
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/eval-sets/target-output-key.json
@@ -0,0 +1,93 @@
+{
+  "fileName": "target-output-key.json",
+  "id": "target-output-key-eval-set",
+  "name": "Target Output Key Path Resolution Tests",
+  "batchSize": 10,
+  "evaluatorRefs": [
+    "legacy-equality-full-output",
+    "legacy-equality-flat-key",
+    "legacy-equality-nested-path",
+    "legacy-equality-deep-nested",
+    "legacy-equality-array-index",
+    "legacy-equality-array-tag",
+    "legacy-json-similarity-nested",
+    "legacy-json-similarity-customer"
+  ],
+  "evaluations": [
+    {
+      "id": "test-order-basic",
+      "name": "Test Order - Basic",
+      "inputs": {
+        "customer_name": "John Doe",
+        "items": [
+          {"name": "Widget", "quantity": 2, "price": 9.99},
+          {"name": "Gadget", "quantity": 1, "price": 24.99}
+        ]
+      },
+      "expectedOutput": {
+        "order_id": "ORD-001",
+        "customer": {
+          "name": "John Doe",
+          "email": "john.doe@example.com",
+          "address": {
+            "street": "123 Main St",
+            "city": "Springfield",
+            "zip_code": "62701"
+          }
+        },
+        "items": [
+          {"name": "Widget", "quantity": 2, "price": 9.99},
+          {"name": "Gadget", "quantity": 1, "price": 24.99}
+        ],
+        "summary": {
+          "total": 44.97,
+          "item_count": 3,
+          "status": "completed"
+        },
+        "tags": ["priority", "express", "verified"]
+      },
+      "expectedAgentBehavior": "The agent should process the order and return the correct nested output.",
+      "evalSetId": "target-output-key-eval-set",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    },
+    {
+      "id": "test-order-single-item",
+      "name": "Test Order - Single Item",
+      "inputs": {
+        "customer_name": "Jane Smith",
+        "items": [
+          {"name": "Book", "quantity": 3, "price": 15.0}
+        ]
+      },
+      "expectedOutput": {
+        "order_id": "ORD-001",
+        "customer": {
+          "name": "Jane Smith",
+          "email": "jane.smith@example.com",
+          "address": {
+            "street": "123 Main St",
+            "city": "Springfield",
+            "zip_code": "62701"
+          }
+        },
+        "items": [
+          {"name": "Book", "quantity": 3, "price": 15.0}
+        ],
+        "summary": {
+          "total": 45.0,
+          "item_count": 3,
+          "status": "completed"
+        },
+        "tags": ["priority", "express", "verified"]
+      },
+      "expectedAgentBehavior": "The agent should process a single-item order correctly.",
+      "evalSetId": "target-output-key-eval-set",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-09-04T18:54:58.379Z",
+  "updatedAt": "2025-09-04T18:55:55.416Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-index.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-index.json
new file mode 100644
index 000000000..f34bfad3f
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-index.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-array-index.json",
+    "id": "legacy-equality-array-index",
+    "name": "Equality - Array Index (items[0].name)",
+    "description": "Exact match on an array element's nested property: items[0].name",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "items[0].name",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-tag.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-tag.json
new file mode 100644
index 000000000..f9f555b6c
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-array-tag.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-array-tag.json",
+    "id": "legacy-equality-array-tag",
+    "name": "Equality - Array Index (tags[1])",
+    "description": "Exact match on an array element by index: tags[1]",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "tags[1]",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-deep-nested.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-deep-nested.json
new file mode 100644
index 000000000..c8d47ea5b
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-deep-nested.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-deep-nested.json",
+    "id": "legacy-equality-deep-nested",
+    "name": "Equality - Deep Nested (customer.address.city)",
+    "description": "Exact match on a deeply nested path: customer.address.city",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "customer.address.city",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-flat-key.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-flat-key.json
new file mode 100644
index 000000000..458bdd575
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-flat-key.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-flat-key.json",
+    "id": "legacy-equality-flat-key",
+    "name": "Equality - Flat Key (order_id)",
+    "description": "Exact match on a flat top-level key: order_id",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "order_id",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-full-output.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-full-output.json
new file mode 100644
index 000000000..90431d744
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-full-output.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-full-output.json",
+    "id": "legacy-equality-full-output",
+    "name": "Equality - Full Output",
+    "description": "Exact match on the entire output (targetOutputKey=*)",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "*",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-nested-path.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-nested-path.json
new file mode 100644
index 000000000..6ed0c45b7
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-equality-nested-path.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-equality-nested-path.json",
+    "id": "legacy-equality-nested-path",
+    "name": "Equality - Nested Path (summary.status)",
+    "description": "Exact match on a nested path: summary.status",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "summary.status",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-customer.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-customer.json
new file mode 100644
index 000000000..b31c9e3f2
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-customer.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-json-similarity-customer.json",
+    "id": "legacy-json-similarity-customer",
+    "name": "JSON Similarity - Customer Object (customer)",
+    "description": "JSON similarity on the customer nested object",
+    "category": 0,
+    "type": 6,
+    "targetOutputKey": "customer",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-nested.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-nested.json
new file mode 100644
index 000000000..721fe250d
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/legacy-json-similarity-nested.json
@@ -0,0 +1,11 @@
+{
+    "fileName": "legacy-json-similarity-nested.json",
+    "id": "legacy-json-similarity-nested",
+    "name": "JSON Similarity - Nested Object (summary)",
+    "description": "JSON similarity on a nested object: summary",
+    "category": 0,
+    "type": 6,
+    "targetOutputKey": "summary",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}
diff --git a/packages/uipath/samples/multi-output-agent/evaluations/evaluators/list-keys-exact-match.json b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/list-keys-exact-match.json
new file mode 100644
index 000000000..d2b685bb3
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/evaluations/evaluators/list-keys-exact-match.json
@@ -0,0 +1,10 @@
+{
+  "version": "1.0",
+  "id": "list-keys-exact-match",
+  "description": "Exact match on multiple output keys at once (summary.status and summary.total)",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ListKeysExactMatch",
+    "targetOutputKey": ["summary.status", "summary.total"]
+  }
+}
diff --git a/packages/uipath/samples/multi-output-agent/main.py b/packages/uipath/samples/multi-output-agent/main.py
new file mode 100644
index 000000000..fc963dbac
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/main.py
@@ -0,0 +1,89 @@
+"""Multi-output agent for testing targetOutputKey path resolution.
+
+This agent returns a complex nested output with multiple properties,
+nested objects, and arrays of objects - designed to test evaluator
+targetOutputKey with dot-notation and bracket-index paths.
+"""
+
+from pydantic.dataclasses import dataclass
+
+from uipath.tracing import traced
+
+
+@dataclass
+class OrderItem:
+    name: str
+    quantity: int
+    price: float
+
+
+@dataclass
+class Address:
+    street: str
+    city: str
+    zip_code: str
+
+
+@dataclass
+class Customer:
+    name: str
+    email: str
+    address: Address
+
+
+@dataclass
+class OrderInput:
+    customer_name: str
+    items: list[dict[str, object]]
+
+
+@dataclass
+class OrderSummary:
+    total: float
+    item_count: int
+    status: str
+
+
+@dataclass
+class OrderOutput:
+    order_id: str
+    customer: Customer
+    items: list[OrderItem]
+    summary: OrderSummary
+    tags: list[str]
+
+
+@traced()
+async def main(input: OrderInput) -> OrderOutput:
+    """Process an order and return a complex nested output."""
+    items = [
+        OrderItem(
+            name=str(item.get("name", "")),
+            quantity=int(item.get("quantity", 0)),
+            price=float(item.get("price", 0.0)),
+        )
+        for item in input.items
+    ]
+
+    total = sum(item.price * item.quantity for item in items)
+    item_count = sum(item.quantity for item in items)
+
+    return OrderOutput(
+        order_id="ORD-001",
+        customer=Customer(
+            name=input.customer_name,
+            email=f"{input.customer_name.lower().replace(' ', '.')}@example.com",
+            address=Address(
+                street="123 Main St",
+                city="Springfield",
+                zip_code="62701",
+            ),
+        ),
+        items=items,
+        summary=OrderSummary(
+            total=total,
+            item_count=item_count,
+            status="completed",
+        ),
+        tags=["priority", "express", "verified"],
+    )
diff --git a/packages/uipath/samples/multi-output-agent/pyproject.toml b/packages/uipath/samples/multi-output-agent/pyproject.toml
new file mode 100644
index 000000000..a6e04d420
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "multi-output-agent"
+version = "0.0.1"
+description = "Multi-output agent for testing targetOutputKey path resolution"
+authors = [{ name = "Test", email = "test@example.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/multi-output-agent/uipath.json b/packages/uipath/samples/multi-output-agent/uipath.json
new file mode 100644
index 000000000..681601f5f
--- /dev/null
+++ b/packages/uipath/samples/multi-output-agent/uipath.json
@@ -0,0 +1,16 @@
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "packOptions": {
+    "fileExtensionsIncluded": [],
+    "filesIncluded": [],
+    "filesExcluded": [],
+    "directoriesExcluded": [],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/pizza-order-function/README.md b/packages/uipath/samples/pizza-order-function/README.md
new file mode 100644
index 000000000..7f0097824
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/README.md
@@ -0,0 +1,16 @@
+
+# Pizza Order Function
+
+A coded agent that prices and confirms pizza orders with quantity discounts, crust surcharges, and prep time estimates.
+
+## Run
+
+```
+uipath run main '{"size": "large", "crust": "stuffed", "toppings": ["pepperoni", "mushrooms", "olives"], "quantity": 3, "customer_name": "Alice"}'
+```
+
+## Debug
+
+```
+uipath dev web
+```
diff --git a/packages/uipath/samples/pizza-order-function/bindings.json b/packages/uipath/samples/pizza-order-function/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/pizza-order-function/main.mermaid b/packages/uipath/samples/pizza-order-function/main.mermaid
new file mode 100644
index 000000000..424d4318e
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/main.mermaid
@@ -0,0 +1,23 @@
+flowchart TB
+  main.py:138(main)
+  main.py:98(compute_price)
+  main.py:64(calculate_base_price)
+  main.py:59(log_step)
+  main.py:71(calculate_topping_surcharge)
+  main.py:79(calculate_crust_surcharge)
+  main.py:86(apply_discount)
+  main.py:114(estimate_prep_time)
+  main.py:127(format_confirmation)
+  main.py:53(generate_order_id)
+  main.py:64 --> main.py:59
+  main.py:98 --> main.py:64
+  main.py:71 --> main.py:59
+  main.py:98 --> main.py:71
+  main.py:79 --> main.py:59
+  main.py:98 --> main.py:79
+  main.py:86 --> main.py:59
+  main.py:98 --> main.py:86
+  main.py:138 --> main.py:98
+  main.py:138 --> main.py:114
+  main.py:138 --> main.py:127
+  main.py:138 --> main.py:53
diff --git a/packages/uipath/samples/pizza-order-function/main.py b/packages/uipath/samples/pizza-order-function/main.py
new file mode 100644
index 000000000..499c0313b
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/main.py
@@ -0,0 +1,147 @@
+import logging
+import random
+from enum import Enum
+
+from pydantic.dataclasses import dataclass
+
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+
+class Size(Enum):
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+
+
+class CrustType(Enum):
+    THIN = "thin"
+    THICK = "thick"
+    STUFFED = "stuffed"
+
+
+@dataclass
+class PizzaOrder:
+    size: Size
+    crust: CrustType
+    toppings: list[str]
+    quantity: int
+    customer_name: str
+
+
+@dataclass
+class PriceBreakdown:
+    base_price: float
+    topping_surcharge: float
+    crust_surcharge: float
+    discount: float
+    total: float
+
+
+@dataclass
+class OrderConfirmation:
+    order_id: str
+    price: PriceBreakdown
+    estimated_minutes: int
+    message: str
+
+
+@traced()
+async def generate_order_id() -> str:
+    """Generate a unique order ID."""
+    return f"PZA-{random.randint(1000, 9999)}"
+
+
+@traced(name="log_step")
+def log_step(step_name: str, details: str) -> None:
+    """Log each processing step for auditing."""
+    logger.info("[%s] %s", step_name, details)
+
+
+@traced(name="calculate_base_price")
+def calculate_base_price(size: Size, quantity: int) -> float:
+    prices = {Size.SMALL: 8.99, Size.MEDIUM: 12.99, Size.LARGE: 16.99}
+    log_step("base_price", f"{size.value} x{quantity}")
+    return prices[size] * quantity
+
+
+@traced(name="calculate_topping_surcharge")
+def calculate_topping_surcharge(toppings: list[str], quantity: int) -> float:
+    free_toppings = 2
+    extra = max(0, len(toppings) - free_toppings)
+    log_step("topping_surcharge", f"{len(toppings)} toppings, {extra} extra")
+    return extra * 1.50 * quantity
+
+
+@traced(name="calculate_crust_surcharge")
+def calculate_crust_surcharge(crust: CrustType, quantity: int) -> float:
+    surcharges = {CrustType.THIN: 0.0, CrustType.THICK: 1.00, CrustType.STUFFED: 2.50}
+    log_step("crust_surcharge", f"{crust.value} crust")
+    return surcharges[crust] * quantity
+
+
+@traced(name="apply_discount")
+def apply_discount(subtotal: float, quantity: int) -> float:
+    if quantity >= 5:
+        discount = subtotal * 0.15
+    elif quantity >= 3:
+        discount = subtotal * 0.10
+    else:
+        discount = 0.0
+    log_step("discount", f"qty={quantity}, discount=${discount:.2f}")
+    return discount
+
+
+@traced(name="compute_price")
+def compute_price(order: PizzaOrder) -> PriceBreakdown:
+    base = calculate_base_price(order.size, order.quantity)
+    topping = calculate_topping_surcharge(order.toppings, order.quantity)
+    crust = calculate_crust_surcharge(order.crust, order.quantity)
+    subtotal = base + topping + crust
+    discount = apply_discount(subtotal, order.quantity)
+    return PriceBreakdown(
+        base_price=base,
+        topping_surcharge=topping,
+        crust_surcharge=crust,
+        discount=discount,
+        total=subtotal - discount,
+    )
+
+
+@traced(name="estimate_prep_time")
+def estimate_prep_time(order: PizzaOrder) -> int:
+    base_minutes = 15
+    per_extra_pizza = 5
+    stuffed_penalty = 7
+    minutes = base_minutes + (order.quantity - 1) * per_extra_pizza
+    if order.crust == CrustType.STUFFED:
+        minutes += stuffed_penalty
+    return minutes
+
+
+@traced(name="format_confirmation")
+def format_confirmation(
+    order: PizzaOrder, order_id: str, price: PriceBreakdown, eta: int
+) -> str:
+    return (
+        f"Hey {order.customer_name}! Order {order_id} confirmed. "
+        f"{order.quantity}x {order.size.value} {order.crust.value} crust pizza "
+        f"with {', '.join(order.toppings) or 'cheese only'}. "
+        f"Total: ${price.total:.2f} (saved ${price.discount:.2f}). "
+        f"Ready in ~{eta} min."
+    )
+
+
+@traced()
+async def main(input: PizzaOrder) -> OrderConfirmation:
+    order_id = await generate_order_id()
+    price = compute_price(input)
+    eta = estimate_prep_time(input)
+    message = format_confirmation(input, order_id, price, eta)
+    return OrderConfirmation(
+        order_id=order_id,
+        price=price,
+        estimated_minutes=eta,
+        message=message,
+    )
diff --git a/packages/uipath/samples/pizza-order-function/pyproject.toml b/packages/uipath/samples/pizza-order-function/pyproject.toml
new file mode 100644
index 000000000..ca14514c2
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "pizza-order-function"
+version = "0.0.1"
+description = "pizza-order-function"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/pizza-order-function/uipath.json b/packages/uipath/samples/pizza-order-function/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/pizza-order-function/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/queue-interactions/README.md b/packages/uipath/samples/queue-interactions/README.md
new file mode 100644
index 000000000..e0d0a2330
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/README.md
@@ -0,0 +1,230 @@
+# UiPath Coded Agent: Queue Item Manager
+
+This project demonstrates how to create a Python-based UiPath Coded Agent that connects to UiPath Orchestrator and manages queue items with multiple interaction patterns.
+
+## Overview
+
+The agent uses the UiPath Python SDK to:
+
+* Connect to UiPath Orchestrator
+* Add queue items using multiple methods (single, bulk, dictionary, with dates)
+* List and view queue items
+* Return detailed operation results
+
+## Prerequisites
+
+* [UV package manager](https://docs.astral.sh/uv/) installed
+* UiPath Orchestrator access with appropriate credentials
+* At least one queue configured in your Orchestrator instance
+
+## Setup
+
+### Step 1: Create and Activate Virtual Environment
+
+```bash
+uv venv
+```
+
+Activate the virtual environment:
+- **Windows**: `.venv\Scripts\activate`
+- **Linux/Mac**: `source .venv/bin/activate`
+
+### Step 2: Install Dependencies
+
+```bash
+uv sync
+```
+
+### Step 3: Initialize the Agent
+
+```bash
+uv run uipath init
+```
+
+### Step 4: Prepare Input Data
+
+The agent supports multiple operations. Format your `input.json` file based on the operation:
+
+#### Add Single Item
+
+```json
+{
+  "operation": "add_single",
+  "queue_name": "TestQueue",
+  "items": [
+    {
+      "reference": "ITEM-001",
+      "priority": "Normal",
+      "specific_content": {
+        "customer_id": "CUST-001",
+        "order_number": "ORD-2024-001"
+      }
+    }
+  ]
+}
+```
+
+#### Add Bulk Items
+
+```json
+{
+  "operation": "add_bulk",
+  "queue_name": "TestQueue",
+  "items": [
+    {
+      "reference": "ITEM-001",
+      "priority": "High",
+      "specific_content": {"data": "item1"}
+    },
+    {
+      "reference": "ITEM-002",
+      "priority": "Low",
+      "specific_content": {"data": "item2"}
+    }
+  ]
+}
+```
+
+#### Add Item via Dictionary
+
+```json
+{
+  "operation": "add_dict",
+  "queue_name": "TestQueue",
+  "items": [
+    {
+      "reference": "ITEM-DICT-001",
+      "priority": "High",
+      "specific_content": {
+        "transaction_type": "payment"
+      }
+    }
+  ]
+}
+```
+
+#### Add Item with Date Constraints
+
+```json
+{
+  "operation": "add_with_dates",
+  "queue_name": "TestQueue",
+  "items": [
+    {
+      "reference": "TIME-SENSITIVE-001",
+      "priority": "High",
+      "specific_content": {"task": "urgent"},
+      "defer_date": "2026-02-13 12:00:00.000",
+      "due_date": "2026-02-14 11:00:00.000"
+    }
+  ]
+}
+```
+
+#### List Queue Items
+
+```json
+{
+  "operation": "list",
+  "queue_name": "TestQueue"
+}
+```
+
+**Input Parameters:**
+- `operation` (required): Operation to perform
+  - `add_single`: Add a single queue item using QueueItem object
+  - `add_dict`: Add a single queue item using dictionary method
+  - `add_bulk`: Add multiple queue items in one operation
+  - `add_with_dates`: Add item with defer/due date constraints
+  - `list`: List all queue items
+- `queue_name` (required): The name of the UiPath queue
+- `items` (optional): Array of queue items (required for add operations)
+  - `reference` (optional): Unique reference identifier
+  - `priority` (optional): Priority level (Low, Normal, High)
+  - `specific_content` (optional): Custom data payload
+  - `defer_date` (optional): Earliest processing date in UTC format
+  - `due_date` (optional): Latest processing date in UTC format
+
+### Step 5: Run the Agent
+
+Execute the agent locally:
+
+```bash
+uipath run main --input-file input.json
+```
+
+## How It Works
+
+When this agent runs, it will:
+
+1. Load input values (`operation`, `queue_name`, and optionally `items`)
+2. Connect to UiPath Orchestrator
+3. Execute the specified operation:
+   - **add_single**: Creates a single queue item using QueueItem object
+   - **add_dict**: Creates a single queue item using dictionary method
+   - **add_bulk**: Creates multiple queue items in bulk with independent processing
+   - **add_with_dates**: Creates a time-sensitive queue item with defer/due dates
+   - **list**: Retrieves and displays queue items (up to 10 shown)
+4. Return a detailed message with the operation results
+
+**Sample Outputs:**
+
+```
+# add_single
+Successfully added item 'ITEM-001' (ID: 12345) to queue 'TestQueue'
+
+# add_bulk
+Bulk operation: 3 item(s) added successfully, 0 failed in queue 'TestQueue'
+
+# add_with_dates
+Successfully added time-sensitive item (ID: 12346) with defer date: 2026-02-13T12:00:00Z
+
+# list
+Found 5 queue item(s):
+ID: 12345 | Status: New | Priority: Low | Ref: ITEM-001
+ID: 12346 | Status: New | Priority: High | Ref: ITEM-002
+...
+```
+
+## Queue Item Properties
+
+Each queue item supports the following properties:
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `reference` | str | No | Optional unique identifier (max 128 chars) |
+| `priority` | str | No | Low, Normal, or High (default: None) |
+| `specific_content` | dict | No | Custom data payload for the work item |
+| `defer_date` | str | No | Earliest processing date (UTC format: "YYYY-MM-DD HH:MM:SS.mmm") |
+| `due_date` | str | No | Latest processing date (UTC format: "YYYY-MM-DD HH:MM:SS.mmm") |
+
+## Operations Reference
+
+### add_single
+Adds a single queue item using the QueueItem class. This is the standard method for adding items with full type safety.
+
+### add_dict
+Adds a single queue item using a dictionary. Alternative approach that demonstrates dictionary-based item creation.
+
+### add_bulk
+Adds multiple queue items in a single operation using `CommitType.PROCESS_ALL_INDEPENDENTLY`. Each item is processed independently, and the operation reports success/failure counts.
+
+### add_with_dates
+Adds a queue item with defer and due date constraints. Useful for time-sensitive processing where items should not be processed before a certain time or must be completed by a deadline.
+
+### list
+Lists all queue items from the queue. Returns up to 10 items with their ID, Status, Priority, and Reference. Indicates if more items exist beyond the displayed limit.
+
+## Publish Your Coded Agent
+
+Once tested locally, publish your agent to Orchestrator:
+
+1. Pack the agent:
+   ```bash
+   uipath pack
+   ```
+
+2. Publish to Orchestrator:
+   ```bash
+   uipath publish
+   ```
diff --git a/packages/uipath/samples/queue-interactions/bindings.json b/packages/uipath/samples/queue-interactions/bindings.json
new file mode 100644
index 000000000..6122d0e77
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
diff --git a/packages/uipath/samples/queue-interactions/input.json b/packages/uipath/samples/queue-interactions/input.json
new file mode 100644
index 000000000..1f0b0f018
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/input.json
@@ -0,0 +1,33 @@
+{
+  "operation": "add_bulk",
+  "queue_name": "some-random-queue",
+  "items": [
+    {
+      "reference": "ITEM-001",
+      "priority": "High",
+      "specific_content": {
+        "customer_id": "CUST-001",
+        "order_number": "ORD-2024-001",
+        "amount": 150.50
+      }
+    },
+    {
+      "reference": "ITEM-002",
+      "priority": "High",
+      "specific_content": {
+        "customer_id": "CUST-002",
+        "order_number": "ORD-2024-002",
+        "amount": 250.75
+      }
+    },
+    {
+      "reference": "ITEM-003",
+      "priority": "Low",
+      "specific_content": {
+        "customer_id": "CUST-003",
+        "order_number": "ORD-2024-003",
+        "amount": 99.99
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/queue-interactions/main.py b/packages/uipath/samples/queue-interactions/main.py
new file mode 100644
index 000000000..12dd16aa4
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/main.py
@@ -0,0 +1,193 @@
+import logging
+from typing import Any
+from pydantic import BaseModel, Field
+from uipath.platform import UiPath
+from uipath.platform.orchestrator import QueueItem, CommitType
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+class QueueItemData(BaseModel):
+    """Data structure for a queue item.
+
+    Attributes:
+        reference (str | None): Optional reference identifier.
+        priority (str | None): Priority level (Low, Normal, High).
+        specific_content (dict[str, Any]): Custom data payload.
+        defer_date (str | None): Earliest processing date in UTC format.
+        due_date (str | None): Latest processing date in UTC format.
+    """
+    reference: str | None = None
+    priority: str | None = None
+    specific_content: dict[str, Any] = Field(default_factory=dict)
+    defer_date: str | None = None
+    due_date: str | None = None
+
+class AgentInput(BaseModel):
+    """Input data structure for the UiPath agent.
+
+    Attributes:
+        operation (str): Operation to perform (add_single, add_bulk, add_dict, add_with_dates, list).
+        queue_name (str): The name of the queue to interact with.
+        items (list[QueueItemData] | None): List of queue items for add operations.
+    """
+    operation: str
+    queue_name: str
+    items: list[QueueItemData] | None = None
+
+def add_single_queue_item(client: UiPath, queue_name: str, item_data: QueueItemData) -> dict[str, Any]:
+    """Add a single queue item using QueueItem object.
+
+    Args:
+        client (UiPath): The UiPath client instance.
+        queue_name (str): The name of the queue.
+        item_data (QueueItemData): Item data to add.
+
+    Returns:
+        dict: Result from the API.
+    """
+    queue_item = QueueItem(
+        name=queue_name,
+        priority=item_data.priority,
+        specific_content=item_data.specific_content,
+        reference=item_data.reference,
+        defer_date=item_data.defer_date,
+        due_date=item_data.due_date
+    )
+    return client.queues.create_item(queue_item)
+
+def add_queue_item_with_dict(client: UiPath, queue_name: str, item_data: QueueItemData) -> dict[str, Any]:
+    """Add a queue item using dictionary method.
+
+    Args:
+        client (UiPath): The UiPath client instance.
+        queue_name (str): The name of the queue.
+        item_data (QueueItemData): Item data to add.
+
+    Returns:
+        dict: Result from the API.
+    """
+    item_dict = {
+        "name": queue_name,
+        "priority": item_data.priority,
+        "specific_content": item_data.specific_content,
+        "reference": item_data.reference
+    }
+    return client.queues.create_item(item_dict)
+
+def add_multiple_queue_items(client: UiPath, queue_name: str, items: list[QueueItemData]) -> dict[str, Any]:
+    """Add multiple queue items in bulk.
+
+    Args:
+        client (UiPath): The UiPath client instance.
+        queue_name (str): The name of the queue.
+        items (list[QueueItemData]): List of items to add.
+
+    Returns:
+        dict: Result from the API with success/failure counts.
+    """
+    queue_items = []
+    for item_data in items:
+        queue_item = QueueItem(
+            name=queue_name,
+            priority=item_data.priority,
+            specific_content=item_data.specific_content,
+            reference=item_data.reference
+        )
+        queue_items.append(queue_item)
+
+    return client.queues.create_items(
+        items=queue_items,
+        queue_name=queue_name,
+        commit_type=CommitType.PROCESS_ALL_INDEPENDENTLY
+    )
+
+def add_items_with_dates(client: UiPath, queue_name: str, item_data: QueueItemData) -> dict[str, Any]:
+    """Add queue items with defer and due dates.
+
+    Args:
+        client (UiPath): The UiPath client instance.
+        queue_name (str): The name of the queue.
+        item_data (QueueItemData): Item data with date constraints.
+
+    Returns:
+        dict: Result from the API.
+    """
+    queue_item = QueueItem(
+        name=queue_name,
+        priority=item_data.priority,
+        specific_content=item_data.specific_content,
+        reference=item_data.reference,
+        defer_date=item_data.defer_date,
+        due_date=item_data.due_date
+    )
+    return client.queues.create_item(queue_item)
+
+def list_queue_items(client: UiPath) -> dict[str, Any]:
+    """List all queue items.
+
+    Args:
+        client (UiPath): The UiPath client instance.
+
+    Returns:
+        dict: Result containing queue items.
+    """
+    return client.queues.list_items()
+
+@traced()
+def main(input: AgentInput) -> str:
+    """Main entry point for the agent.
+
+    Args:
+        input (AgentInput): The input containing operation and queue details.
+
+    Returns:
+        str: Message with the result of the queue operation.
+    """
+    try:
+        client = UiPath()
+
+        if input.operation == "add_single":
+            if not input.items or len(input.items) == 0:
+                return "Error: No item provided for add_single operation"
+            result = add_single_queue_item(client, input.queue_name, input.items[0])
+            return f"Successfully added item '{result.get('Reference')}' (ID: {result.get('Id')}) to queue '{input.queue_name}'"
+
+        elif input.operation == "add_dict":
+            if not input.items or len(input.items) == 0:
+                return "Error: No item provided for add_dict operation"
+            result = add_queue_item_with_dict(client, input.queue_name, input.items[0])
+            return f"Successfully added item via dictionary (ID: {result.get('Id')}) to queue '{input.queue_name}'"
+
+        elif input.operation == "add_bulk":
+            if not input.items or len(input.items) == 0:
+                return "Error: No items provided for add_bulk operation"
+            result = add_multiple_queue_items(client, input.queue_name, input.items)
+            failed = len(result.get('FailedItems', []))
+            success = len(input.items) - failed
+            return f"Bulk operation: {success} item(s) added successfully, {failed} failed in queue '{input.queue_name}'"
+
+        elif input.operation == "add_with_dates":
+            if not input.items or len(input.items) == 0:
+                return "Error: No item provided for add_with_dates operation"
+            result = add_items_with_dates(client, input.queue_name, input.items[0])
+            return f"Successfully added time-sensitive item (ID: {result.get('Id')}) with defer date: {result.get('DeferDate')}"
+
+        elif input.operation == "list":
+            result = list_queue_items(client)
+            items = result.get('value', [])
+            if len(items) == 0:
+                return "No items found in the queue"
+            item_summary = []
+            for item in items[:10]:
+                item_summary.append(f"ID: {item.get('Id')} | Status: {item.get('Status')} | Priority: {item.get('Priority')} | Ref: {item.get('Reference')}")
+            summary = "\n".join(item_summary)
+            total = len(items)
+            return f"Found {total} queue item(s):\n{summary}" + (f"\n... and {total - 10} more items" if total > 10 else "")
+
+        else:
+            return f"Error: Unknown operation '{input.operation}'. Valid operations: add_single, add_dict, add_bulk, add_with_dates, list"
+
+    except Exception as e:
+        logger.exception(f"Operation failed: {input.operation}")
+        return f"Failed to perform '{input.operation}' on queue '{input.queue_name}': {str(e)}"
diff --git a/packages/uipath/samples/queue-interactions/pyproject.toml b/packages/uipath/samples/queue-interactions/pyproject.toml
new file mode 100644
index 000000000..1387e5de7
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "queue-interactions"
+version = "0.0.1"
+description = "UiPath agent to manage queue items via External Application integration with Orchestrator."
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/queue-interactions/uipath.json b/packages/uipath/samples/queue-interactions/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/queue-interactions/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/resource-overrides/.claude/commands/eval.md b/packages/uipath/samples/resource-overrides/.claude/commands/eval.md
new file mode 100644
index 000000000..15fa04f7c
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/.claude/commands/eval.md
@@ -0,0 +1,287 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create and run agent evaluations
+---
+
+I'll help you create and run evaluations for your UiPath agent.
+
+## Step 1: Check project setup
+
+Let me check your project structure:
+
+!ls -la evaluations/ entry-points.json 2>/dev/null || echo "NEEDS_SETUP"
+
+# Check if schemas might be stale (main.py newer than entry-points.json)
+!if [ -f main.py ] && [ -f entry-points.json ] && [ main.py -nt entry-points.json ]; then echo "SCHEMAS_MAY_BE_STALE"; fi
+
+### If NEEDS_SETUP
+
+If `entry-points.json` doesn't exist, initialize the project first:
+
+!uv run uipath init
+
+Then re-run this skill.
+
+### If SCHEMAS_MAY_BE_STALE
+
+Your `main.py` is newer than `entry-points.json`. Refresh schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 2: What would you like to do?
+
+1. **Create new eval set** - Set up evaluations from scratch
+2. **Add test case** - Add a test to existing eval set
+3. **Run evaluations** - Execute tests and see results
+4. **Analyze failures** - Debug failing tests
+
+---
+
+## Creating an Eval Set
+
+First, create the directory structure:
+
+!mkdir -p evaluations/eval-sets evaluations/evaluators
+
+Read the agent's Input/Output schema from entry-points.json to understand the data types.
+
+### Evaluator Selection Guide
+
+| If your output is... | Use this evaluator | evaluatorTypeId |
+|---------------------|-------------------|-----------------|
+| Exact string/number | `ExactMatchEvaluator` | `uipath-exact-match` |
+| Contains key phrases | `ContainsEvaluator` | `uipath-contains` |
+| Semantically correct | `LLMJudgeOutputEvaluator` | `uipath-llm-judge-output-semantic-similarity` |
+| JSON with numbers | `JsonSimilarityEvaluator` | `uipath-json-similarity` |
+
+### Step 1: Create Evaluator Config Files
+
+**Each evaluator needs a JSON config file** in `evaluations/evaluators/`.
+
+**ExactMatchEvaluator** (`evaluations/evaluators/exact-match.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ExactMatchEvaluator",
+  "name": "ExactMatchEvaluator",
+  "description": "Checks for exact output match",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ExactMatchEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**LLMJudgeOutputEvaluator** (`evaluations/evaluators/llm-judge-output.json`):
+```json
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluator",
+  "name": "LLMJudgeOutputEvaluator",
+  "description": "Uses LLM to judge semantic similarity",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluator",
+    "model": "gpt-4o-mini-2024-07-18"
+  }
+}
+```
+
+**JsonSimilarityEvaluator** (`evaluations/evaluators/json-similarity.json`):
+```json
+{
+  "version": "1.0",
+  "id": "JsonSimilarityEvaluator",
+  "name": "JsonSimilarityEvaluator",
+  "description": "Compares JSON structures",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "JsonSimilarityEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**ContainsEvaluator** (`evaluations/evaluators/contains.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ContainsEvaluator",
+  "name": "ContainsEvaluator",
+  "description": "Checks if output contains text",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "ContainsEvaluator"
+  }
+}
+```
+
+### Step 2: Create Eval Set
+
+**Eval Set Template** (`evaluations/eval-sets/default.json`):
+```json
+{
+  "version": "1.0",
+  "id": "default-eval-set",
+  "name": "Default Evaluation Set",
+  "evaluatorRefs": ["ExactMatchEvaluator"],
+  "evaluations": [
+    {
+      "id": "test-1",
+      "name": "Test description",
+      "inputs": {
+        "field": "value"
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": "expected value"
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+**Important notes:**
+- `evaluatorRefs` must list ALL evaluators used in any test case
+- Each evaluator in `evaluatorRefs` needs a matching JSON config in `evaluations/evaluators/`
+- `evaluationCriterias` keys must match entries in `evaluatorRefs`
+- Use `expectedOutput` for most evaluators
+- LLM evaluators need `model` in their config. Available models are defined in the SDK's `ChatModels` class (`uipath.platform.chat.ChatModels`):
+  - `gpt-4o-mini-2024-07-18` (recommended for cost-efficiency)
+  - `gpt-4o-2024-08-06` (higher quality, higher cost)
+  - `o3-mini-2025-01-31` (latest reasoning model)
+  - Model availability varies by region and tenant configuration
+  - Check your UiPath Automation Cloud portal under AI Trust Layer for available models in your region
+
+---
+
+## Adding a Test Case
+
+When adding a test to an existing eval set:
+
+1. Read the existing eval set
+2. Check which evaluators are in `evaluatorRefs`
+3. Add the new test to `evaluations` array
+4. If using a new evaluator, add it to `evaluatorRefs`
+
+### Test Case Template
+
+```json
+{
+  "id": "test-{n}",
+  "name": "Description of what this tests",
+  "inputs": { },
+  "evaluationCriterias": {
+    "EvaluatorName": {
+      "expectedOutput": { }
+    }
+  }
+}
+```
+
+---
+
+## Running Evaluations
+
+First, read entry-points.json to get the entrypoint name (e.g., `main`):
+
+!uv run uipath eval main evaluations/eval-sets/default.json --output-file eval-results.json
+
+**Note:** Replace `main` with your actual entrypoint from entry-points.json.
+
+### Analyze Results
+
+After running, read `eval-results.json` and show:
+- Pass/fail summary table
+- For failures: expected vs actual output
+- Suggestions for fixing or changing evaluators
+
+### Results Format
+
+```json
+{
+  "evaluationSetResults": [{
+    "evaluationRunResults": [
+      {
+        "evaluationId": "test-1",
+        "evaluatorId": "ExactMatchEvaluator",
+        "result": { "score": 1.0 },
+        "errorMessage": null
+      }
+    ]
+  }]
+}
+```
+
+- Score 1.0 = PASS
+- Score < 1.0 = FAIL (show expected vs actual)
+- errorMessage present = ERROR (show message)
+
+---
+
+## Evaluator Reference
+
+### Deterministic Evaluators
+
+**ExactMatchEvaluator** - Exact output matching
+```json
+"ExactMatchEvaluator": {
+  "expectedOutput": { "result": "exact value" }
+}
+```
+
+**ContainsEvaluator** - Output contains substring
+```json
+"ContainsEvaluator": {
+  "searchText": "must contain this"
+}
+```
+
+**JsonSimilarityEvaluator** - JSON comparison with tolerance
+```json
+"JsonSimilarityEvaluator": {
+  "expectedOutput": { "value": 10.0 }
+}
+```
+
+### LLM-Based Evaluators
+
+**LLMJudgeOutputEvaluator** - Semantic correctness
+```json
+"LLMJudgeOutputEvaluator": {
+  "expectedOutput": { "summary": "Expected semantic meaning" }
+}
+```
+
+**LLMJudgeTrajectoryEvaluator** - Validate agent reasoning
+```json
+"LLMJudgeTrajectoryEvaluator": {
+  "expectedAgentBehavior": "The agent should first fetch data, then process it"
+}
+```
+
+---
+
+## Common Issues
+
+### "No evaluations found"
+- Check `evaluations/eval-sets/` directory exists
+- Verify JSON file is valid
+
+### Evaluator not found
+- Each evaluator needs a JSON config file in `evaluations/evaluators/`
+- Config file must have correct `evaluatorTypeId` (see templates above)
+- Config file must have `name` field at root level
+- LLM evaluators need `model` in `evaluatorConfig`
+
+### Evaluator skipped
+- Ensure evaluator is listed in root `evaluatorRefs` array
+- Check evaluator config file exists in `evaluations/evaluators/`
+
+### Schema mismatch
+- Run `uv run uipath init --no-agents-md-override` to refresh schemas
+- Check `entry-points.json` matches your Input/Output models
diff --git a/packages/uipath/samples/resource-overrides/.claude/commands/new-agent.md b/packages/uipath/samples/resource-overrides/.claude/commands/new-agent.md
new file mode 100644
index 000000000..b1d051866
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/.claude/commands/new-agent.md
@@ -0,0 +1,103 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create a new UiPath coded agent from a description
+---
+
+I'll help you create a new UiPath coded agent.
+
+## Step 1: Check existing project
+
+Let me check if this is an existing UiPath project:
+
+!ls uipath.json main.py 2>/dev/null || echo "NEW_PROJECT"
+
+## Step 2: Gather requirements
+
+**What should this agent do?**
+
+Please describe:
+
+-   What inputs it needs (e.g., "a file path and bucket name")
+-   What it should accomplish (e.g., "process CSV data")
+-   What outputs it should return (e.g., "total count and status")
+
+I'll generate the agent structure based on your description.
+
+## Step 3: Generate agent
+
+After you describe the agent, I will:
+
+1. Create `main.py` with Input/Output Pydantic models and `async def main()`
+2. Add entrypoint to `uipath.json` under `"functions": {"agent_name": "main.py:main"}`
+3. Run `uv run uipath init --no-agents-md-override` to generate schemas
+
+**Template structure** (from .agent/REQUIRED_STRUCTURE.md):
+
+```python
+from pydantic import BaseModel
+from uipath.platform import UiPath
+
+class Input(BaseModel):
+    """Input fields for the agent."""
+    # Fields based on your description
+    pass
+
+
+class Output(BaseModel):
+    """Output fields returned by the agent."""
+    # Fields based on your description
+    pass
+
+
+async def main(input: Input) -> Output:
+    """Main entry point for the agent.
+
+    Args:
+        input: The input data for the agent.
+
+    Returns:
+        The output data from the agent.
+    """
+
+    uipath = UiPath()
+
+    # TODO: Implement agent logic
+    return Output()
+```
+
+**Important notes:**
+
+-   Use `async def main` - many SDK methods are async
+-   Initialize `UiPath()` inside the function, not at module level
+-   After creating main.py, add entrypoint to `uipath.json` under `"functions"`
+
+## Step 4: Update entry-point schemas
+
+After creating main.py, regenerate the schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 5: Verify
+
+Quick test to verify the setup:
+
+!uv run uipath run main '{}' 2>&1 | head -30
+
+## Summary
+
+Once complete, you'll have:
+
+| File                | Purpose                             |
+| ------------------- | ----------------------------------- |
+| `main.py`           | Agent code with Input/Output models |
+| `uipath.json`       | Project configuration               |
+| `entry-points.json` | Entry point schemas                 |
+| `bindings.json`     | Resource bindings                   |
+| `.agent/`           | SDK and CLI reference docs          |
+
+**Next steps:**
+
+1. Implement your logic in `main()`
+2. Test: `uv run uipath run main '{"field": "value"}'`
+3. Create `eval_set.json` for evaluations
+4. Evaluate: `uv run uipath eval`
diff --git a/packages/uipath/samples/resource-overrides/.vscode/launch.json b/packages/uipath/samples/resource-overrides/.vscode/launch.json
new file mode 100644
index 000000000..5fa0da7cc
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/.vscode/launch.json
@@ -0,0 +1,15 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python Debugger: Attach",
+      "type": "debugpy",
+      "request": "attach",
+      "connect": {
+        "host": "localhost",
+        "port": 5678
+      },
+      "justMyCode": false
+    }
+  ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/resource-overrides/README.md b/packages/uipath/samples/resource-overrides/README.md
new file mode 100644
index 000000000..55279d113
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/README.md
@@ -0,0 +1,132 @@
+# UiPath Coded Agent: Resource Bindings Demo
+
+## Overview
+
+This sample demonstrates how to use resource bindings within your coded agent to enable dynamic resource replacement at runtime. It showcases how UiPath resources (assets, connections, apps, indexes, buckets and processes) defined in your agent code can be mapped and replaced with different resources when the agent is published to UiPath Orchestrator.
+
+## Features
+
+- **Dynamic Resource Binding**: Define resources in code that can be replaced at deployment
+- **Multiple Resource Types**: Demonstrates bindings for all major UiPath resource types
+- **Runtime Flexibility**: Replace resources without modifying code
+- **Environment Separation**: Use different resources for development, staging, and production
+
+## Prerequisites
+
+1. Python 3.11+
+2. UiPath Platform account with access to Orchestrator
+3. Access to the following resource types in your Orchestrator:
+   - Assets
+   - Connections (Integration Service)
+   - Apps (Action Center)
+   - Context Grounding Indexes
+   - Storage Buckets
+   - Processes
+
+## Setup and Configuration
+
+### 1. Install Dependencies
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Install dependencies
+uv sync
+```
+
+### 2. Understanding Resource Bindings
+
+The agent uses various UiPath SDK methods to interact with resources. The `bindings.json` file maps these resources with their default values:
+
+- **Assets**: `asset_name` in folder `folder_key`
+- **Connections**: `connection_key` (e.g., Salesforce, Slack)
+- **Apps**: `app_name` in folder `app_folder_path`
+- **Indexes**: `index_name` in folder `folder_path`
+- **Buckets**: `bucket_name` in folder `folder_path`
+- **Processes**: `process_name` in folder `folder_path`
+
+## How It Works
+
+1. **Code Definition**: The agent code defines interactions with various UiPath resources using their identifiers
+2. **Binding Definition**: The bindings.json file contains the resources that are overridable at runtime
+3. **Publishing**: When published to Orchestrator, each resource binding becomes configurable
+4. **Runtime Replacement**: In Orchestrator, you can select replacement resources of the same type
+
+### Resource Replacement in Orchestrator
+
+When you publish this agent to UiPath Orchestrator, for each resource defined in `bindings.json`, you can select a replacement resource of the same kind from the resources you have access to:
+
+![Package requirements page](../../docs/sample_images/resource-overrides/package-requirements.png)
+
+*Screenshot: UiPath Orchestrator showing resource replacement options for each bound resource*
+
+This allows you to:
+- Use test resources in development environments
+- Switch to production resources without code changes
+- Share agents across teams with different resource configurations
+- Maintain environment-specific configurations easily
+
+## Running the Agent
+
+### Local Development
+
+```bash
+# Run the agent locally (will use default resource values defined in code)
+uv run uipath run main.py
+```
+
+### On UiPath Platform
+
+1. **Authenticate with UiPath**:
+   ```bash
+   uv run uipath auth
+   ```
+
+2. **Package the agent**:
+   ```bash
+   uv run uipath pack
+   ```
+
+3. **Publish to your workspace**:
+   ```bash
+   uv run uipath publish --my-workspace
+   ```
+
+4. **Configure Resources in Orchestrator**:
+   - Navigate to your agent in Orchestrator
+   - For each resource in the bindings, select the appropriate replacement
+   - Save the configuration
+
+5. **Run the Agent**:
+   - Execute the agent from Orchestrator
+   - The agent will use the configured replacement resources
+
+## Implementation Details
+
+### Resource Types and Methods
+
+The agent demonstrates the following resource interactions:
+
+| Resource Type | SDK Method | Purpose |
+|---------------|------------|---------|
+| **Asset** | `uipath.assets.retrieve_async()` | Retrieve asset values |
+| **Connection** | `uipath.connections.retrieve_async()` | Get connection details |
+| **App (Task)** | `uipath.tasks.create_async()` | Create tasks |
+| **Index** | `uipath.context_grounding.retrieve_async()` | Access context grounding data |
+| **Bucket** | `uipath.buckets.retrieve_async()` | Access storage buckets |
+| **Process** | `uipath.processes.invoke_async()` | Trigger process execution |
+
+### Output Structure
+
+The agent returns a `Response` object containing details about each accessed resource:
+
+```python
+class Resource(BaseModel):
+    name: str
+    value: Any
+
+class Response(BaseModel):
+    resources: list[Resource] = []
+```
+
diff --git a/packages/uipath/samples/resource-overrides/bindings.json b/packages/uipath/samples/resource-overrides/bindings.json
new file mode 100644
index 000000000..eb1f645c8
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/bindings.json
@@ -0,0 +1,126 @@
+{
+  "version": "2.0",
+  "resources": [
+    {
+      "resource": "asset",
+      "key": "asset_name.folder_key",
+      "value": {
+        "name": {
+          "defaultValue": "asset_name",
+          "isExpression": false,
+          "displayName": "Name"
+        },
+        "folderPath": {
+          "defaultValue": "folder_key",
+          "isExpression": false,
+          "displayName": "Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "retrieve_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "FullName"
+      }
+    },
+    {
+      "resource": "process",
+      "key": "process_name.folder_path",
+      "value": {
+        "name": {
+          "defaultValue": "process_name",
+          "isExpression": false,
+          "displayName": "Name"
+        },
+        "folderPath": {
+          "defaultValue": "folder_path",
+          "isExpression": false,
+          "displayName": "Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "invoke_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "FullName"
+      }
+    },
+    {
+      "resource": "bucket",
+      "key": "bucket_name.folder_path",
+      "value": {
+        "name": {
+          "defaultValue": "bucket_name",
+          "isExpression": false,
+          "displayName": "Name"
+        },
+        "folderPath": {
+          "defaultValue": "folder_path",
+          "isExpression": false,
+          "displayName": "Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "retrieve_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "FullName"
+      }
+    },
+    {
+      "resource": "app",
+      "key": "app_name.app_folder_path",
+      "value": {
+        "name": {
+          "defaultValue": "app_name",
+          "isExpression": false,
+          "displayName": "App Name"
+        },
+        "folderPath": {
+          "defaultValue": "app_folder_path",
+          "isExpression": false,
+          "displayName": "App Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "create_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "app_name"
+      }
+    },
+    {
+      "resource": "index",
+      "key": "index_name.folder_path",
+      "value": {
+        "name": {
+          "defaultValue": "index_name",
+          "isExpression": false,
+          "displayName": "Name"
+        },
+        "folderPath": {
+          "defaultValue": "folder_path",
+          "isExpression": false,
+          "displayName": "Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "retrieve_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "FullName"
+      }
+    },
+    {
+      "resource": "connection",
+      "key": "connection_key",
+      "value": {
+        "ConnectionId": {
+          "defaultValue": "connection_key",
+          "isExpression": false,
+          "displayName": "Connection"
+        }
+      },
+      "metadata": {
+        "BindingsVersion": "2.2",
+        "Connector": "",
+        "UseConnectionService": "True"
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/resource-overrides/main.py b/packages/uipath/samples/resource-overrides/main.py
new file mode 100644
index 000000000..c3d33d6d8
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/main.py
@@ -0,0 +1,57 @@
+from typing import Any
+from uipath.platform import UiPath
+from pydantic import BaseModel
+
+
+class Resource(BaseModel):
+    name: str
+    value: Any
+
+class Response(BaseModel):
+    resources: list[Resource] = []
+
+async def main() -> Response:
+
+    uipath = UiPath()
+
+    response = Response()
+
+    # Assets - retrieve asset value
+    asset = await uipath.assets.retrieve_async("asset_name", folder_path="folder_key")
+    response.resources.append(Resource(name="asset", value=str(asset.model_dump())))
+
+    # Connections - retrieve connection
+    connection = await uipath.connections.retrieve_async("connection_key")
+    response.resources.append(Resource(name="connection", value=connection.model_dump()))
+
+    # Actions (Apps) - create action
+    action = await uipath.tasks.create_async(
+        title="Action Title",
+        data={"key": "value"},
+        app_name="app_name",
+        app_folder_path="app_folder_path"
+    )
+    response.resources.append(Resource(name="action", value=str(action.model_dump())))
+
+    # Context Grounding (Indexes) - add to index
+    await uipath.context_grounding.retrieve_async(
+        name="index_name",
+        folder_path="folder_path"
+    )
+
+    # Buckets - retrieve bucket
+    bucket = await uipath.buckets.retrieve_async(
+        name="bucket_name",
+        folder_path="folder_path"
+    )
+    response.resources.append(Resource(name="bucket", value=str(bucket.model_dump())))
+
+    # Processes - invoke process
+    process_result = await uipath.processes.invoke_async(
+        name="process_name",
+        input_arguments={"arg1": "value1"},
+        folder_path="folder_path"
+    )
+    response.resources.append(Resource(name="process_result", value=str(process_result.model_dump())))
+
+    return response
diff --git a/packages/uipath/samples/resource-overrides/pyproject.toml b/packages/uipath/samples/resource-overrides/pyproject.toml
new file mode 100644
index 000000000..59b49b556
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "bindings-function"
+version = "0.0.1"
+description = "Function with resource bindings"
+authors = [{ name = "John Doe" }]
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "uipath",
+]
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/resource-overrides/uipath.json b/packages/uipath/samples/resource-overrides/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/resource-overrides/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/runtime-simulations-agent/input.json b/packages/uipath/samples/runtime-simulations-agent/input.json
new file mode 100644
index 000000000..9bfb2eef8
--- /dev/null
+++ b/packages/uipath/samples/runtime-simulations-agent/input.json
@@ -0,0 +1,4 @@
+{
+  "code": "def add(a, b):\n  return a+b\n\ndef divide(a,b):\n  return a/b",
+  "language": "python"
+}
diff --git a/packages/uipath/samples/runtime-simulations-agent/main.py b/packages/uipath/samples/runtime-simulations-agent/main.py
new file mode 100644
index 000000000..46440b459
--- /dev/null
+++ b/packages/uipath/samples/runtime-simulations-agent/main.py
@@ -0,0 +1,186 @@
+"""Coding agent that reviews code and suggests improvements.
+
+This sample demonstrates the --simulation flag: the three tool functions
+(check_syntax, check_style, suggest_improvements) are decorated with @mockable,
+so they can be intercepted by an LLM during a simulated run instead of
+requiring a real linter or compiler to be installed.
+
+Run with real tools:
+    uipath run main.py:main -f input.json
+
+Run with simulation (no real tools needed):
+    uipath run main.py:main -f input.json --simulation "$(cat simulation.json)"
+"""
+
+import logging
+
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+
+from uipath.eval.mocks import ExampleCall, mockable
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Input / Output models
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CodeReviewInput:
+    code: str
+    language: str = "python"
+
+
+class SyntaxResult(BaseModel):
+    valid: bool
+    errors: list[str] = []
+
+
+class StyleResult(BaseModel):
+    score: int  # 0-100
+    violations: list[str] = []
+
+
+class ImprovementResult(BaseModel):
+    suggestions: list[str] = []
+    refactored_snippet: str = ""
+
+
+class CodeReviewOutput(BaseModel):
+    syntax: SyntaxResult
+    style: StyleResult
+    improvements: ImprovementResult
+    summary: str
+
+
+# ---------------------------------------------------------------------------
+# Mockable tool functions
+# ---------------------------------------------------------------------------
+
+CHECK_SYNTAX_EXAMPLES = [
+    ExampleCall(
+        id="valid-python",
+        input='{"code": "def hello():\\n    return 42", "language": "python"}',
+        output='{"valid": true, "errors": []}',
+    ),
+    ExampleCall(
+        id="syntax-error",
+        input='{"code": "def hello(\\n    return 42", "language": "python"}',
+        output='{"valid": false, "errors": ["SyntaxError: unexpected EOF"]}',
+    ),
+]
+
+
+@traced(name="check_syntax", span_type="tool")
+@mockable(example_calls=CHECK_SYNTAX_EXAMPLES)
+async def check_syntax(code: str, language: str = "python") -> SyntaxResult:
+    """Check code for syntax errors using the language's parser.
+
+    Args:
+        code: Source code to check.
+        language: Programming language (default: python).
+
+    Returns:
+        SyntaxResult with valid flag and list of error messages.
+    """
+    if language != "python":
+        return SyntaxResult(valid=True, errors=[])
+
+    try:
+        compile(code, "<string>", "exec")
+        return SyntaxResult(valid=True, errors=[])
+    except SyntaxError as exc:
+        return SyntaxResult(valid=False, errors=[str(exc)])
+
+
+CHECK_STYLE_EXAMPLES = [
+    ExampleCall(
+        id="clean-code",
+        input='{"code": "def hello():\\n    return 42\\n", "language": "python"}',
+        output='{"score": 95, "violations": []}',
+    ),
+    ExampleCall(
+        id="style-issues",
+        input='{"code": "def hello( ):\\n  return 42", "language": "python"}',
+        output='{"score": 60, "violations": ["E211 whitespace before \'(\'", "W291 trailing whitespace"]}',
+    ),
+]
+
+
+@traced(name="check_style", span_type="tool")
+@mockable(example_calls=CHECK_STYLE_EXAMPLES)
+async def check_style(code: str, language: str = "python") -> StyleResult:
+    """Run style checks (e.g. PEP 8 for Python) on the provided code.
+
+    Args:
+        code: Source code to check.
+        language: Programming language (default: python).
+
+    Returns:
+        StyleResult with a 0-100 score and list of style violations.
+    """
+    # Real implementation would call ruff / pycodestyle / eslint etc.
+    # For demo purposes we return a perfect score when not simulated.
+    return StyleResult(score=100, violations=[])
+
+
+SUGGEST_IMPROVEMENTS_EXAMPLES = [
+    ExampleCall(
+        id="basic-function",
+        input='{"code": "def add(a, b):\\n    return a + b"}',
+        output=(
+            '{"suggestions": ["Add type annotations", "Add a docstring"],'
+            ' "refactored_snippet": "def add(a: int, b: int) -> int:\\n    '
+            "'''Return the sum of a and b.'''\\n    return a + b\"}"
+        ),
+    )
+]
+
+
+@traced(name="suggest_improvements", span_type="tool")
+@mockable(example_calls=SUGGEST_IMPROVEMENTS_EXAMPLES)
+async def suggest_improvements(code: str) -> ImprovementResult:
+    """Analyse code and return actionable improvement suggestions.
+
+    Args:
+        code: Source code to analyse.
+
+    Returns:
+        ImprovementResult with suggestions and an optional refactored snippet.
+    """
+    # Real implementation would call an LLM or static analysis tool.
+    return ImprovementResult(suggestions=[], refactored_snippet=code)
+
+
+# ---------------------------------------------------------------------------
+# Agent entrypoint
+# ---------------------------------------------------------------------------
+
+
+@traced(name="main")
+async def main(input: CodeReviewInput) -> CodeReviewOutput:
+    """Orchestrate three code-review tools and produce a unified report.
+
+    Each tool call creates its own OpenTelemetry span with span_type="tool",
+    which enables trajectory-based evaluation and simulation.
+    """
+    syntax = await check_syntax(input.code, input.language)
+    style = await check_style(input.code, input.language)
+    improvements = await suggest_improvements(input.code)
+
+    issues = len(syntax.errors) + len(style.violations)
+    summary = (
+        f"Found {issues} issue(s). "
+        f"Style score: {style.score}/100. "
+        f"{len(improvements.suggestions)} improvement suggestion(s)."
+    )
+
+    return CodeReviewOutput(
+        syntax=syntax,
+        style=style,
+        improvements=improvements,
+        summary=summary,
+    )
diff --git a/packages/uipath/samples/runtime-simulations-agent/pyproject.toml b/packages/uipath/samples/runtime-simulations-agent/pyproject.toml
new file mode 100644
index 000000000..335c55783
--- /dev/null
+++ b/packages/uipath/samples/runtime-simulations-agent/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "runtime-simulations-agent"
+version = "0.0.1"
+description = "Code review agent demonstrating runtime simulation"
+authors = [{ name = "UiPath", email = "python-sdk@uipath.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/runtime-simulations-agent/simulation.json b/packages/uipath/samples/runtime-simulations-agent/simulation.json
new file mode 100644
index 000000000..d89bb253f
--- /dev/null
+++ b/packages/uipath/samples/runtime-simulations-agent/simulation.json
@@ -0,0 +1,15 @@
+{
+  "enabled": true,
+  "toolsToSimulate": [
+    {
+      "name": "check_syntax"
+    },
+    {
+      "name": "check_style"
+    },
+    {
+      "name": "suggest_improvements"
+    }
+  ],
+  "instructions": "You are simulating a code review system. Given a tool name and its input arguments, produce a realistic JSON response that matches the tool's output schema.\n\n- check_syntax: return {\"valid\": <bool>, \"errors\": [<string>, ...]}. If the code looks syntactically correct return valid=true and an empty errors list. Otherwise list the syntax errors.\n- check_style: return {\"score\": <0-100>, \"violations\": [<string>, ...]}. Evaluate PEP 8 compliance for Python code. Deduct points for missing spaces, missing type annotations, etc.\n- suggest_improvements: return {\"suggestions\": [<string>, ...], \"refactored_snippet\": \"<improved code>\"}. Suggest concrete improvements such as adding type hints, docstrings, or handling edge cases (e.g. division by zero)."
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/runtime-simulations-agent/uipath.json b/packages/uipath/samples/runtime-simulations-agent/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/runtime-simulations-agent/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/simulate-component-agent/input.json b/packages/uipath/samples/simulate-component-agent/input.json
new file mode 100644
index 000000000..68093d7d0
--- /dev/null
+++ b/packages/uipath/samples/simulate-component-agent/input.json
@@ -0,0 +1,4 @@
+{
+  "city": "London",
+  "days": 3
+}
diff --git a/packages/uipath/samples/simulate-component-agent/main.py b/packages/uipath/samples/simulate-component-agent/main.py
new file mode 100644
index 000000000..0acd8f0cb
--- /dev/null
+++ b/packages/uipath/samples/simulate-component-agent/main.py
@@ -0,0 +1,118 @@
+"""Weather forecast agent demonstrating per-component simulation.
+
+This sample shows the new ``components`` simulation format where each tool
+has its own simulation strategy and instructions, routed to the
+simulate-component API instead of a local LLM.
+
+Run with real tools (no weather API — returns hardcoded defaults):
+    uipath run main -f input.json
+
+Run with per-component simulation (routes each tool call to the API):
+    uipath run main -f input.json --simulation "$(cat simulation.json)"
+"""
+
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+
+from uipath.eval.mocks import mockable
+from uipath.tracing import traced
+
+# ---------------------------------------------------------------------------
+# Input / Output models
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class WeatherInput:
+    city: str
+    days: int = 3
+
+
+class CurrentWeather(BaseModel):
+    city: str
+    temperature: float  # Celsius
+    condition: str
+    humidity: int  # percent
+
+
+class ForecastDay(BaseModel):
+    date: str  # YYYY-MM-DD
+    high: float
+    low: float
+    condition: str
+
+
+class WeatherReport(BaseModel):
+    current: CurrentWeather
+    forecast: list[ForecastDay]
+    summary: str
+
+
+# ---------------------------------------------------------------------------
+# Mockable tool functions
+# ---------------------------------------------------------------------------
+
+
+@traced(name="get_current_weather", span_type="tool")
+@mockable()
+async def get_current_weather(city: str) -> CurrentWeather:
+    """Fetch current weather conditions for a city from an external weather API.
+
+    Args:
+        city: Name of the city (e.g. "London", "New York").
+
+    Returns:
+        CurrentWeather with temperature, condition, and humidity.
+    """
+    # Real implementation would call a weather API such as OpenWeatherMap.
+    # Returns hardcoded defaults when not simulated.
+    return CurrentWeather(city=city, temperature=20.0, condition="unknown", humidity=50)
+
+
+@traced(name="get_forecast", span_type="tool")
+@mockable()
+async def get_forecast(city: str, days: int = 3) -> list[ForecastDay]:
+    """Retrieve a multi-day weather forecast for a city.
+
+    Args:
+        city: Name of the city.
+        days: Number of forecast days to retrieve (default: 3).
+
+    Returns:
+        List of ForecastDay objects, one per requested day.
+    """
+    # Real implementation would call a forecast API.
+    # Returns an empty list when not simulated.
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Agent entry point
+# ---------------------------------------------------------------------------
+
+
+@traced(name="main")
+async def main(input: WeatherInput) -> WeatherReport:
+    """Fetch current weather and forecast for a city and produce a report.
+
+    Args:
+        input: WeatherInput with city name and number of forecast days.
+
+    Returns:
+        WeatherReport combining current conditions, forecast, and a summary.
+    """
+    current = await get_current_weather(input.city)
+    forecast = await get_forecast(input.city, input.days)
+
+    issues = []
+    if current.humidity > 80:
+        issues.append("high humidity")
+    if current.temperature < 0:
+        issues.append("freezing temperatures")
+
+    alert = f" Alerts: {', '.join(issues)}." if issues else ""
+    summary = (
+        f"{input.city}: {current.temperature}°C, {current.condition}."
+        f" {len(forecast)}-day forecast available.{alert}"
+    )
+    return WeatherReport(current=current, forecast=forecast, summary=summary)
diff --git a/packages/uipath/samples/simulate-component-agent/pyproject.toml b/packages/uipath/samples/simulate-component-agent/pyproject.toml
new file mode 100644
index 000000000..c4228e861
--- /dev/null
+++ b/packages/uipath/samples/simulate-component-agent/pyproject.toml
@@ -0,0 +1,17 @@
+[project]
+name = "simulate-component-agent"
+version = "0.0.1"
+description = "Weather forecast agent demonstrating per-component simulation"
+authors = [{ name = "UiPath", email = "python-sdk@uipath.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
+
+[tool.uv.sources]
+uipath = { path = "../..", editable = true }
diff --git a/packages/uipath/samples/simulate-component-agent/simulation.json b/packages/uipath/samples/simulate-component-agent/simulation.json
new file mode 100644
index 000000000..fc87bd527
--- /dev/null
+++ b/packages/uipath/samples/simulate-component-agent/simulation.json
@@ -0,0 +1,73 @@
+{
+  "enabled": true,
+  "components": [
+    {
+      "componentId": "get_current_weather",
+      "componentType": "tool",
+      "simulationStrategy": 0,
+      "simulationInstruction": "Return realistic current weather for the given city. Use typical seasonal temperatures for the Northern Hemisphere in winter. the humidity should always be 70%",
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "city": {
+            "type": "string"
+          },
+          "temperature": {
+            "type": "number",
+            "description": "Temperature in Celsius"
+          },
+          "condition": {
+            "type": "string",
+            "description": "e.g. cloudy, rainy, sunny"
+          },
+          "humidity": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 100
+          }
+        },
+        "required": [
+          "city",
+          "temperature",
+          "condition",
+          "humidity"
+        ]
+      }
+    },
+    {
+      "componentId": "get_forecast",
+      "componentType": "tool",
+      "simulationStrategy": 0,
+      "simulationInstruction": "Return a realistic multi-day weather forecast for the given city.",
+      "outputSchema": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "date": {
+              "type": "string",
+              "description": "YYYY-MM-DD"
+            },
+            "high": {
+              "type": "number",
+              "description": "High temperature in Celsius"
+            },
+            "low": {
+              "type": "number",
+              "description": "Low temperature in Celsius"
+            },
+            "condition": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "date",
+            "high",
+            "low",
+            "condition"
+          ]
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/simulate-component-agent/uipath.json b/packages/uipath/samples/simulate-component-agent/uipath.json
new file mode 100644
index 000000000..a991b6914
--- /dev/null
+++ b/packages/uipath/samples/simulate-component-agent/uipath.json
@@ -0,0 +1,6 @@
+{
+  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/tree-recursive-function/README.md b/packages/uipath/samples/tree-recursive-function/README.md
new file mode 100644
index 000000000..3a6ffb50e
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/README.md
@@ -0,0 +1,15 @@
+# Tree Analyzer Function
+
+A coded agent that recursively analyzes binary trees — computing depth, node counts, leaf counts, max values, and paths.
+
+## Run
+
+```
+uipath run main '{"value": 10, "left": {"value": 25, "left": {"value": 4}, "right": {"value": 30, "left": {"value": 11}}}, "right": {"value": 7, "right": {"value": 2}}}'
+```
+
+## Debug
+
+```
+uipath dev web
+```
diff --git a/packages/uipath/samples/tree-recursive-function/bindings.json b/packages/uipath/samples/tree-recursive-function/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/tree-recursive-function/main.mermaid b/packages/uipath/samples/tree-recursive-function/main.mermaid
new file mode 100644
index 000000000..4725085c9
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/main.mermaid
@@ -0,0 +1,28 @@
+flowchart TB
+  main.py:103(main)
+  main.py:85(analyze_tree)
+  main.py:27(log_visit)
+  main.py:36(compute_depth)
+  main.py:45(count_nodes)
+  main.py:52(count_leaves)
+  main.py:31(is_leaf)
+  main.py:61(find_max)
+  main.py:70(find_path_to_value)
+  main.py:85 --> main.py:27
+  main.py:36 --> main.py:36
+  main.py:36 --> main.py:36
+  main.py:85 --> main.py:36
+  main.py:45 --> main.py:45
+  main.py:45 --> main.py:45
+  main.py:85 --> main.py:45
+  main.py:52 --> main.py:31
+  main.py:52 --> main.py:52
+  main.py:52 --> main.py:52
+  main.py:85 --> main.py:52
+  main.py:61 --> main.py:61
+  main.py:61 --> main.py:61
+  main.py:85 --> main.py:61
+  main.py:70 --> main.py:70
+  main.py:70 --> main.py:70
+  main.py:85 --> main.py:70
+  main.py:103 --> main.py:85
diff --git a/packages/uipath/samples/tree-recursive-function/main.py b/packages/uipath/samples/tree-recursive-function/main.py
new file mode 100644
index 000000000..f11543f7d
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/main.py
@@ -0,0 +1,103 @@
+"""Sample with recursive calls for testing call graph visualization."""
+
+import logging
+from pydantic.dataclasses import dataclass
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TreeNode:
+    value: int
+    left: "TreeNode | None" = None
+    right: "TreeNode | None" = None
+
+
+@dataclass
+class TreeStats:
+    depth: int
+    total_nodes: int
+    leaf_count: int
+    max_value: int
+    path_to_max: list[str]
+
+@traced
+def log_visit(node_value: int, depth: int) -> None:
+    logger.info("Visiting node %d at depth %d", node_value, depth)
+
+@traced
+def is_leaf(node: TreeNode) -> bool:
+    return node.left is None and node.right is None
+
+@traced
+def compute_depth(node: TreeNode | None) -> int:
+    """Classic recursive depth computation."""
+    if node is None:
+        return 0
+    left_depth = compute_depth(node.left)
+    right_depth = compute_depth(node.right)
+    return 1 + max(left_depth, right_depth)
+
+@traced
+def count_nodes(node: TreeNode | None) -> int:
+    """Recursive node count."""
+    if node is None:
+        return 0
+    return 1 + count_nodes(node.left) + count_nodes(node.right)
+
+@traced
+def count_leaves(node: TreeNode | None) -> int:
+    """Recursive leaf count — calls is_leaf."""
+    if node is None:
+        return 0
+    if is_leaf(node):
+        return 1
+    return count_leaves(node.left) + count_leaves(node.right)
+
+@traced
+def find_max(node: TreeNode | None) -> int:
+    """Recursive max-value search."""
+    if node is None:
+        return float("-inf")
+    left_max = find_max(node.left)
+    right_max = find_max(node.right)
+    return max(node.value, left_max, right_max)
+
+@traced
+def find_path_to_value(node: TreeNode | None, target: int) -> list[str]:
+    """Recursive path finding — uses is_leaf as a helper."""
+    if node is None:
+        return []
+    if node.value == target:
+        return [str(node.value)]
+    left_path = find_path_to_value(node.left, target)
+    if left_path:
+        return [str(node.value)] + left_path
+    right_path = find_path_to_value(node.right, target)
+    if right_path:
+        return [str(node.value)] + right_path
+    return []
+
+@traced
+def analyze_tree(tree: TreeNode) -> TreeStats:
+    """Entrypoint that fans out into multiple recursive helpers."""
+    log_visit(tree.value, 0)
+
+    depth = compute_depth(tree)
+    total = count_nodes(tree)
+    leaves = count_leaves(tree)
+    max_val = find_max(tree)
+    path = find_path_to_value(tree, max_val)
+
+    return TreeStats(
+        depth=depth,
+        total_nodes=total,
+        leaf_count=leaves,
+        max_value=max_val,
+        path_to_max=path,
+    )
+
+@traced
+async def main(input: TreeNode) -> TreeStats:
+    return analyze_tree(input)
diff --git a/packages/uipath/samples/tree-recursive-function/pyproject.toml b/packages/uipath/samples/tree-recursive-function/pyproject.toml
new file mode 100644
index 000000000..8b1f017b8
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "tree-recursive-function"
+version = "0.0.1"
+description = "tree-recursive-function"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/tree-recursive-function/uipath.json b/packages/uipath/samples/tree-recursive-function/uipath.json
new file mode 100644
index 000000000..9b02c2654
--- /dev/null
+++ b/packages/uipath/samples/tree-recursive-function/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/README.md b/packages/uipath/samples/weather_tools/README.md
new file mode 100644
index 000000000..887048bc6
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/README.md
@@ -0,0 +1,199 @@
+# Weather Tools Mocked Agent
+
+A sample mocked agent demonstrating multiple tool calls with trajectory evaluation and tool call evaluators.
+
+## Overview
+
+This is a **mocked agent** designed for testing and demonstration purposes. It does not make real weather API calls. Instead, it returns simulated weather data from hardcoded values to demonstrate:
+
+- How to structure tools with proper tracing for trajectory evaluation
+- How multiple tool calls are captured and validated
+- How tool call evaluators verify tool usage, arguments, and outputs
+- Best practices for integrating mocked tools with UiPath's evaluation framework
+- Custom serialization with content wrapper pattern
+
+All weather data is simulated for five cities (New York, London, Tokyo, Paris, Sydney) with predefined responses.
+
+## Tools
+
+The agent provides five mocked tools that return simulated data:
+
+1. **get_temperature** - Returns simulated temperature in fahrenheit
+2. **get_weather_condition** - Returns simulated weather condition (sunny, rainy, etc.)
+3. **get_humidity** - Returns simulated humidity percentage
+4. **get_forecast** - Returns simulated weather forecast text
+5. **get_weather_alerts** - Returns simulated weather alerts
+
+**Note:** All tools return hardcoded responses wrapped in a `{"content": {...}}` structure for demonstration purposes. No actual weather APIs are called.
+
+## Data Models
+
+### Input Model
+```python
+@dataclass
+class WeatherInput:
+    city: City  # Enum: NEW_YORK, LONDON, TOKYO, PARIS, SYDNEY
+    action: Literal["get_weather", "get_forecast", "get_alerts"]
+```
+
+### Output Model
+```python
+class WeatherOutput(_WeatherOutputContent):
+    content: _WeatherOutputContent  # Wraps all data under "content" key
+
+class _WeatherOutputContent(BaseModel):
+    city: str
+    temperature: float
+    condition: WeatherCondition  # Enum: SUNNY, CLOUDY, RAINY, SNOWY
+    humidity: int
+    forecast: str | None = None
+    alerts: list[str] | None = None
+```
+
+## Multiple Tool Calls
+
+The agent demonstrates multiple tool calls in a single execution:
+
+### Example: "get_weather" action
+```
+1. get_temperature("New York")       -> {"content": {"temperature": 72.5, "unit": "fahrenheit"}}
+2. get_weather_condition("New York") -> {"content": {"condition": "sunny"}}
+3. get_humidity("New York")          -> {"content": {"humidity": 60}}
+```
+
+### Example: "get_forecast" action
+```
+1. get_temperature("Paris")       -> {"content": {"temperature": 18.0, "unit": "fahrenheit"}}
+2. get_weather_condition("Paris") -> {"content": {"condition": "cloudy"}}
+3. get_humidity("Paris")          -> {"content": {"humidity": 70}}
+4. get_forecast("Paris")          -> {"content": {"forecast": "Cloudy with a chance of rain..."}}
+```
+
+### Example: "get_alerts" action
+```
+1. get_temperature("London")       -> {"content": {"temperature": 15.0, "unit": "fahrenheit"}}
+2. get_weather_condition("London") -> {"content": {"condition": "rainy"}}
+3. get_humidity("London")          -> {"content": {"humidity": 80}}
+4. get_weather_alerts("London")    -> {"content": {"alerts": ["Heavy rain warning until 6 PM"]}}
+```
+
+## Trajectory Evaluation
+
+Each tool call creates its own OTEL span with the `tool.name` attribute set, allowing UiPath's trajectory evaluation to extract:
+
+### Tool Call Sequence
+The evaluator extracts tool names in order:
+```python
+["get_temperature", "get_weather_condition", "get_humidity", "get_forecast"]
+```
+
+### Tool Arguments
+Each tool's input arguments are captured:
+```python
+ToolCall(name="get_temperature", args={"city": "New York"})
+ToolCall(name="get_weather_condition", args={"city": "New York"})
+...
+```
+
+### Tool Outputs
+Each tool's output is captured with content wrapper:
+```python
+ToolOutput(name="get_temperature", output='{"content": {"temperature": 72.5, "unit": "fahrenheit"}}')
+ToolOutput(name="get_weather_condition", output='{"content": {"condition": "sunny"}}')
+...
+```
+
+## Implementation Details
+
+### Decorator Stack
+Each mocked tool uses a specific decorator order to ensure proper tracing:
+
+```python
+@traced(name="get_temperature", span_type="tool")  # Creates OTEL spans for tracing
+@mockable(example_calls=...) # Provides mock data during evaluation
+async def get_temperature(city: str) -> dict:
+    """Returns simulated temperature data"""
+    city_enum = City(city)
+    temps = {City.NEW_YORK: 72.5, City.LONDON: 15.0, ...}
+    return {"content": {"temperature": temps.get(city_enum, 20.0), "unit": "fahrenheit"}}
+```
+
+### Tool Invocation
+Mocked tools are invoked directly as async functions (not LangChain tools):
+
+```python
+temp_data = await get_temperature(city)
+```
+
+This ensures:
+1. `@traced()` creates an OTEL span for the tool call
+2. `@mockable()` can provide mock responses during evaluation
+3. The trajectory evaluator can extract the tool call with its arguments and output
+4. Simulated data is returned from hardcoded dictionaries with content wrapper
+
+### Content Wrapper Pattern
+All tool outputs and final agent output use a consistent `{"content": {...}}` structure:
+- Tool outputs: `{"content": {"temperature": 72.5, "unit": "fahrenheit"}}`
+- Agent output: `{"content": {"city": "NYC", "temperature": 72.5, ...}}`
+
+This pattern ensures consistent serialization and makes it easy to extract the actual data from the wrapper.
+
+## Running Evaluations
+
+### Basic Evaluation
+Run the evaluation to test the mocked agent's behavior:
+
+```bash
+uv run uipath eval main samples/weather_tools/evaluations/eval-sets/default.json --workers 1
+```
+
+### Evaluation Output
+The evaluators will verify the mocked agent's behavior:
+- ✅ **Trajectory evaluation**: Validates tool call sequence and orchestration logic
+- ✅ **Tool call count**: Verifies correct number of each tool call
+- ✅ **Tool call order**: Ensures tools are called in the expected sequence
+- ✅ **Tool call args**: Validates arguments passed to each tool
+- ✅ **Tool call output**: Checks that tool outputs match expectations with content wrapper
+- ✅ **JSON similarity**: Compares final agent output structure
+- ✅ **Exact match**: Validates specific output values
+
+## Test Cases
+
+The eval set includes 5 test cases covering:
+1. Basic weather check (3 tool calls)
+2. Weather with forecast (4 tool calls)
+3. Weather with alerts (4 tool calls)
+4. Sunny weather conditions (3 tool calls)
+5. Tokyo forecast sequence validation (4 tool calls)
+
+Each test case validates that the agent calls the correct tools in the right order with proper arguments and content-wrapped outputs.
+
+## Usage Examples
+
+### Running the Agent
+```python
+from main import main, WeatherInput, City
+
+# Basic weather check
+input_data = WeatherInput(city=City.NEW_YORK, action="get_weather")
+result = await main(input_data)
+print(result.model_dump())  # {"content": {"city": "New York", "temperature": 72.5, ...}}
+
+# Weather with forecast
+input_data = WeatherInput(city=City.PARIS, action="get_forecast")
+result = await main(input_data)
+print(result.model_dump())  # Includes forecast in content
+```
+
+### Custom Serialization
+The `WeatherOutput` class includes custom serialization methods:
+```python
+# Get content-wrapped dictionary
+data = result.model_dump()
+
+# Get JSON string with content wrapper
+json_str = result.to_json()
+
+# Exclude None values
+data_clean = result.model_dump(exclude_none=True)
+```
diff --git a/packages/uipath/samples/weather_tools/TOOL_EVALUATORS.md b/packages/uipath/samples/weather_tools/TOOL_EVALUATORS.md
new file mode 100644
index 000000000..f2127bf06
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/TOOL_EVALUATORS.md
@@ -0,0 +1,322 @@
+# Tool Call Evaluators
+
+This document explains the tool call evaluators available in the weather_tools sample and how to use them for trajectory evaluation.
+
+## Overview
+
+Tool call evaluators validate specific aspects of how tools are invoked during agent execution. They extract tool information from OpenTelemetry spans and compare against expected criteria.
+
+## Available Evaluators
+
+### 1. ToolCallCountEvaluator
+
+**Purpose**: Validates that tools are called the expected number of times.
+
+**Configuration**: `evaluations/evaluators/tool-call-count.json`
+
+**Example Usage**:
+```json
+"ToolCallCountEvaluator": {
+  "toolCallsCount": {
+    "get_temperature": ["=", 1],
+    "get_weather_condition": ["=", 1],
+    "get_humidity": ["=", 1]
+  }
+}
+```
+
+**Supported Operators**:
+- `"="` - Exactly equal to
+- `">"` - Greater than
+- `"<"` - Less than
+- `">="` - Greater than or equal to
+- `"<="` - Less than or equal to
+- `"!="` - Not equal to
+
+**Use Cases**:
+- Ensure a tool is called exactly once
+- Verify a tool is called at least N times
+- Validate a tool is not called more than N times
+
+### 2. ToolCallOrderEvaluator
+
+**Purpose**: Validates that tools are called in the correct sequence.
+
+**Configuration**: `evaluations/evaluators/tool-call-order.json`
+
+**Example Usage**:
+```json
+"ToolCallOrderEvaluator": {
+  "toolCallsOrder": [
+    "get_temperature",
+    "get_weather_condition",
+    "get_humidity",
+    "get_forecast"
+  ]
+}
+```
+
+**Behavior**:
+- Uses Longest Common Subsequence (LCS) algorithm
+- Allows partial matches (non-strict mode by default)
+- Returns score from 0.0 to 1.0 based on order similarity
+
+**Use Cases**:
+- Validate critical operations happen in sequence
+- Ensure dependencies are respected (e.g., auth before data fetch)
+- Verify optimization patterns (e.g., caching checks before computation)
+
+### 3. ToolCallArgsEvaluator
+
+**Purpose**: Validates that tools are called with correct arguments.
+
+**Configuration**: `evaluations/evaluators/tool-call-args.json`
+
+**Example Usage**:
+```json
+"ToolCallArgsEvaluator": {
+  "toolCalls": [
+    {
+      "name": "get_temperature",
+      "args": {"city": "New York"}
+    },
+    {
+      "name": "get_weather_condition",
+      "args": {"city": "New York"}
+    }
+  ]
+}
+```
+
+**Modes**:
+- **Subset Mode** (default: `true`): Expected args must be present but can have additional args
+- **Exact Mode** (`subset: false`): Args must match exactly
+
+**Use Cases**:
+- Validate correct parameters are passed
+- Ensure data consistency across tool calls
+- Verify input transformation logic
+
+### 4. ToolCallOutputEvaluator
+
+**Purpose**: Validates that tools produce expected outputs.
+
+**Configuration**: `evaluations/evaluators/tool-call-output.json`
+
+**Example Usage**:
+```json
+"ToolCallOutputEvaluator": {
+  "toolOutputs": [
+    {
+      "name": "get_temperature",
+      "output": "{'temperature': 25.0, 'unit': 'fahrenheit'}"
+    },
+    {
+      "name": "get_forecast",
+      "output": "{'forecast': 'Overcast with mild temperatures'}"
+    }
+  ]
+}
+```
+
+**Behavior**:
+- Compares output strings exactly
+- Output must be JSON-serialized string
+- Returns 1.0 for exact match, 0.0 otherwise
+- **Note**: Current implementation uses single quotes for Python dict format
+
+**Use Cases**:
+- Validate tool output format
+- Ensure deterministic tool behavior
+- Verify data transformations
+
+## Complete Example
+
+### Test Case: "tokyo_forecast"
+
+This test validates all aspects of tool usage for fetching Tokyo's weather forecast:
+
+```json
+{
+  "id": "tokyo_forecast",
+  "name": "Tokyo Weather Forecast",
+  "inputs": {
+    "city": "Tokyo",
+    "action": "get_forecast"
+  },
+  "evaluationCriterias": {
+    "ToolCallCountEvaluator": {
+      "toolCallsCount": {
+        "get_temperature": ["=", 1],
+        "get_weather_condition": ["=", 1],
+        "get_humidity": ["=", 1],
+        "get_forecast": ["=", 1]
+      }
+    },
+    "ToolCallOrderEvaluator": {
+      "toolCallsOrder": [
+        "get_temperature",
+        "get_weather_condition",
+        "get_humidity",
+        "get_forecast"
+      ]
+    },
+    "ToolCallArgsEvaluator": {
+      "toolCalls": [
+        {
+          "name": "get_temperature",
+          "args": {"city": "Tokyo"}
+        },
+        {
+          "name": "get_weather_condition",
+          "args": {"city": "Tokyo"}
+        },
+        {
+          "name": "get_humidity",
+          "args": {"city": "Tokyo"}
+        },
+        {
+          "name": "get_forecast",
+          "args": {"city": "Tokyo"}
+        }
+      ]
+    },
+    "ToolCallOutputEvaluator": {
+      "toolOutputs": [
+        {
+          "name": "get_temperature",
+          "output": "{'temperature': 25.0, 'unit': 'fahrenheit'}"
+        },
+        {
+          "name": "get_weather_condition",
+          "output": "{'condition': 'cloudy'}"
+        },
+        {
+          "name": "get_humidity",
+          "output": "{'humidity': 65}"
+        },
+        {
+          "name": "get_forecast",
+          "output": "{'forecast': 'Overcast with mild temperatures'}"
+        }
+      ]
+    }
+  }
+}
+```
+
+### What This Validates
+
+1. **Count**: Each tool is called exactly once ✓
+2. **Order**: Tools are called in the correct sequence ✓
+3. **Args**: All tools receive "Tokyo" as the city argument ✓
+4. **Output**: All tools return the expected data ✓
+
+## How Tool Calls Are Extracted
+
+Tool calls are extracted from OpenTelemetry spans that have the `tool.name` attribute set. The weather_tools agent uses the `@mock_tool_span` decorator to ensure each tool invocation creates a span with:
+
+- `tool.name`: The tool function name
+- `input.value`: JSON-serialized tool arguments
+- `output.value`: JSON-serialized tool output
+
+### Current Implementation
+
+The weather_tools sample uses direct async function calls (not LangChain tools) with the following decorator stack:
+
+```python
+@traced()                    # Creates OTEL span for tracing
+@mockable(example_calls=...) # Provides mock data during evaluation
+@mock_tool_span              # Sets tool.name attribute on span
+async def get_temperature(city: str) -> dict:
+    return {"content": {"temperature": 72.5, "unit": "fahrenheit"}}
+```
+
+### Content Wrapper Pattern
+
+All tool outputs use a consistent `{"content": {...}}` structure:
+- Tool outputs: `{"content": {"temperature": 72.5, "unit": "fahrenheit"}}`
+- This ensures consistent serialization and makes data extraction predictable
+
+## Running Evaluations
+
+Execute all evaluators including tool call evaluators:
+
+```bash
+uv run uipath eval samples/weather_tools/main.py samples/weather_tools/evaluations/eval-sets/default.json --workers 1
+```
+
+## Test Cases in Default Eval Set
+
+The `default.json` eval set includes 5 comprehensive test cases:
+
+1. **basic_weather** - Tests 3 tool calls (temperature, condition, humidity)
+2. **weather_with_forecast** - Tests 4 tool calls including forecast
+3. **weather_with_alerts** - Tests 4 tool calls including alerts
+4. **sunny_weather** - Tests sunny weather conditions
+5. **tokyo_forecast** - Tests Tokyo-specific forecast sequence
+
+Each test case validates:
+- Correct tool call count
+- Proper tool call order
+- Accurate tool arguments
+- Expected tool outputs
+
+## Best Practices
+
+### 1. Start with Order, Then Add Count
+Begin with `ToolCallOrderEvaluator` to ensure correct sequencing, then add `ToolCallCountEvaluator` for precise counts.
+
+### 2. Use Subset Mode for Args
+Unless you need exact matching, keep `subset: true` in args evaluator to allow flexibility.
+
+### 3. Selective Output Validation
+Only validate outputs for critical tools - validating all outputs can be brittle.
+
+### 4. Combine with Trajectory Evaluator
+Use `TrajectoryEvaluator` for high-level behavior validation alongside specific tool evaluators.
+
+### 5. Test Different Action Paths
+Create separate test cases for different action types (get_weather, get_forecast, get_alerts) to validate all code paths.
+
+### 6. Content Wrapper Consistency
+Ensure all tool outputs follow the `{"content": {...}}` pattern for consistent evaluation.
+
+## Troubleshooting
+
+### Order Validation Failing
+
+**Problem**: Order evaluator score is low
+
+**Solutions**:
+- Check if conditional tool calls are included in expected order
+- Use trajectory evaluator to see actual execution sequence
+- Consider if strict mode is appropriate for your use case
+
+### Args Validation Failing
+
+**Problem**: Args evaluator reports mismatches
+
+**Solutions**:
+- Verify argument names match exactly (case-sensitive)
+- Check if subset mode is appropriate
+- Ensure arguments are JSON-serializable
+
+### Output Validation Failing
+
+**Problem**: Output evaluator reports mismatches
+
+**Solutions**:
+- Ensure outputs are JSON-serialized strings
+- Check for trailing whitespace or formatting differences
+- Verify content wrapper structure is consistent
+- Consider if output validation is too strict
+
+### Content Wrapper Issues
+
+**Problem**: Tool outputs don't match expected format
+
+**Solutions**:
+- Ensure all tools return `{"content": {...}}` structure
+- Check that serialization is consistent across tools
+- Verify that evaluator expectations match actual output format
diff --git a/packages/uipath/samples/weather_tools/bindings.json b/packages/uipath/samples/weather_tools/bindings.json
new file mode 100644
index 000000000..5dd5a0fd8
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/bindings.json
@@ -0,0 +1,4 @@
+{
+    "version": "2.0",
+    "resources": []
+}
\ No newline at end of file
diff --git a/packages/uipath/samples/weather_tools/evaluations/eval-sets/default.json b/packages/uipath/samples/weather_tools/evaluations/eval-sets/default.json
new file mode 100644
index 000000000..7ba01fa69
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/eval-sets/default.json
@@ -0,0 +1,373 @@
+{
+  "version": "1.0",
+  "id": "WeatherToolsEval",
+  "name": "Weather Tools Agent Evaluation",
+  "evaluatorRefs": [
+    "TrajectoryEvaluator",
+    "ToolCallCountEvaluator",
+    "ToolCallOrderEvaluator",
+    "ToolCallArgsEvaluator",
+    "ToolCallOutputEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "basic_weather",
+      "name": "Basic Weather Check",
+      "inputs": {
+        "city": "New York",
+        "action": "get_weather"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should call get_temperature, get_weather_condition, and get_humidity tools for New York, then return the combined weather data without forecast or alerts."
+        },
+        "ToolCallCountEvaluator": {
+          "toolCallsCount": {
+            "get_temperature": [
+              "=",
+              1
+            ],
+            "get_weather_condition": [
+              "=",
+              1
+            ],
+            "get_humidity": [
+              "=",
+              1
+            ]
+          }
+        },
+        "ToolCallOrderEvaluator": {
+          "toolCallsOrder": [
+            "get_temperature",
+            "get_weather_condition",
+            "get_humidity"
+          ]
+        },
+        "ToolCallArgsEvaluator": {
+          "toolCalls": [
+            {
+              "name": "get_temperature",
+              "args": {
+                "city": "New York"
+              }
+            },
+            {
+              "name": "get_weather_condition",
+              "args": {
+                "city": "New York"
+              }
+            },
+            {
+              "name": "get_humidity",
+              "args": {
+                "city": "New York"
+              }
+            }
+          ]
+        }
+      }
+    },
+    {
+      "id": "weather_with_forecast",
+      "name": "Weather with Forecast",
+      "inputs": {
+        "city": "Paris",
+        "action": "get_forecast"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should call get_temperature, get_weather_condition, get_humidity, and get_forecast tools for Paris. It should return weather data including the forecast but not alerts."
+        },
+        "ToolCallCountEvaluator": {
+          "toolCallsCount": {
+            "get_temperature": [
+              "=",
+              1
+            ],
+            "get_weather_condition": [
+              "=",
+              1
+            ],
+            "get_humidity": [
+              "=",
+              1
+            ],
+            "get_forecast": [
+              "=",
+              1
+            ]
+          }
+        },
+        "ToolCallOrderEvaluator": {
+          "toolCallsOrder": [
+            "get_temperature",
+            "get_weather_condition",
+            "get_humidity",
+            "get_forecast"
+          ]
+        },
+        "ToolCallArgsEvaluator": {
+          "toolCalls": [
+            {
+              "name": "get_temperature",
+              "args": {
+                "city": "Paris"
+              }
+            },
+            {
+              "name": "get_weather_condition",
+              "args": {
+                "city": "Paris"
+              }
+            },
+            {
+              "name": "get_humidity",
+              "args": {
+                "city": "Paris"
+              }
+            },
+            {
+              "name": "get_forecast",
+              "args": {
+                "city": "Paris"
+              }
+            }
+          ]
+        },
+        "ToolCallOutputEvaluator": {
+          "toolOutputs": [
+            {
+              "name": "get_forecast",
+              "output": "{'forecast': 'Cloudy with a chance of rain in the afternoon'}"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "id": "weather_with_alerts",
+      "name": "Weather with Alerts",
+      "inputs": {
+        "city": "London",
+        "action": "get_alerts"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should call get_temperature, get_weather_condition, get_humidity, and get_weather_alerts tools for London. It should return weather data including alerts but not forecast. The alerts should indicate heavy rain warning."
+        },
+        "ToolCallCountEvaluator": {
+          "toolCallsCount": {
+            "get_temperature": [
+              "=",
+              1
+            ],
+            "get_weather_condition": [
+              "=",
+              1
+            ],
+            "get_humidity": [
+              "=",
+              1
+            ],
+            "get_weather_alerts": [
+              "=",
+              1
+            ]
+          }
+        },
+        "ToolCallOrderEvaluator": {
+          "toolCallsOrder": [
+            "get_temperature",
+            "get_weather_condition",
+            "get_humidity",
+            "get_weather_alerts"
+          ]
+        },
+        "ToolCallArgsEvaluator": {
+          "toolCalls": [
+            {
+              "name": "get_temperature",
+              "args": {
+                "city": "London"
+              }
+            },
+            {
+              "name": "get_weather_condition",
+              "args": {
+                "city": "London"
+              }
+            },
+            {
+              "name": "get_humidity",
+              "args": {
+                "city": "London"
+              }
+            },
+            {
+              "name": "get_weather_alerts",
+              "args": {
+                "city": "London"
+              }
+            }
+          ]
+        },
+        "ToolCallOutputEvaluator": {
+          "toolOutputs": [
+            {
+              "name": "get_weather_alerts",
+              "output": "{'alerts': ['Heavy rain warning until 6 PM']}"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "id": "sunny_weather",
+      "name": "Sunny Weather Check",
+      "inputs": {
+        "city": "Sydney",
+        "action": "get_weather"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should call get_temperature, get_weather_condition, and get_humidity for Sydney, then return sunny weather conditions without forecast or alerts."
+        },
+        "ToolCallCountEvaluator": {
+          "toolCallsCount": {
+            "get_temperature": [
+              "=",
+              1
+            ],
+            "get_weather_condition": [
+              "=",
+              1
+            ],
+            "get_humidity": [
+              "=",
+              1
+            ]
+          }
+        },
+        "ToolCallOrderEvaluator": {
+          "toolCallsOrder": [
+            "get_temperature",
+            "get_weather_condition",
+            "get_humidity"
+          ]
+        },
+        "ToolCallArgsEvaluator": {
+          "toolCalls": [
+            {
+              "name": "get_temperature",
+              "args": {
+                "city": "Sydney"
+              }
+            },
+            {
+              "name": "get_weather_condition",
+              "args": {
+                "city": "Sydney"
+              }
+            },
+            {
+              "name": "get_humidity",
+              "args": {
+                "city": "Sydney"
+              }
+            }
+          ]
+        }
+      }
+    },
+    {
+      "id": "tokyo_forecast",
+      "name": "Tokyo Weather Forecast",
+      "inputs": {
+        "city": "Tokyo",
+        "action": "get_forecast"
+      },
+      "evaluationCriterias": {
+        "TrajectoryEvaluator": {
+          "expectedAgentBehavior": "The agent should sequentially call get_temperature, get_weather_condition, get_humidity, and get_forecast for Tokyo. The trajectory should show all four tool calls in the correct order, gathering basic weather data first, then the forecast."
+        },
+        "ToolCallCountEvaluator": {
+          "toolCallsCount": {
+            "get_temperature": [
+              "=",
+              1
+            ],
+            "get_weather_condition": [
+              "=",
+              1
+            ],
+            "get_humidity": [
+              "=",
+              1
+            ],
+            "get_forecast": [
+              "=",
+              1
+            ]
+          }
+        },
+        "ToolCallOrderEvaluator": {
+          "toolCallsOrder": [
+            "get_temperature",
+            "get_weather_condition",
+            "get_humidity",
+            "get_forecast"
+          ]
+        },
+        "ToolCallArgsEvaluator": {
+          "toolCalls": [
+            {
+              "name": "get_temperature",
+              "args": {
+                "city": "Tokyo"
+              }
+            },
+            {
+              "name": "get_weather_condition",
+              "args": {
+                "city": "Tokyo"
+              }
+            },
+            {
+              "name": "get_humidity",
+              "args": {
+                "city": "Tokyo"
+              }
+            },
+            {
+              "name": "get_forecast",
+              "args": {
+                "city": "Tokyo"
+              }
+            }
+          ]
+        },
+        "ToolCallOutputEvaluator": {
+          "toolOutputs": [
+            {
+              "name": "get_temperature",
+              "output": "{'temperature': 25.0, 'unit': 'fahrenheit'}"
+            },
+            {
+              "name": "get_weather_condition",
+              "output": "{'condition': 'cloudy'}"
+            },
+            {
+              "name": "get_humidity",
+              "output": "{'humidity': 65}"
+            },
+            {
+              "name": "get_forecast",
+              "output": "{'forecast': 'Overcast with mild temperatures'}"
+            }
+          ]
+        }
+      }
+    }
+  ]
+}
diff --git a/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-args.json b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-args.json
new file mode 100644
index 000000000..6c5854301
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-args.json
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "id": "ToolCallArgsEvaluator",
+  "description": "Evaluates if tool calls have the correct arguments.",
+  "evaluatorTypeId": "uipath-tool-call-args",
+  "evaluatorConfig": {
+    "name": "ToolCallArgsEvaluator",
+    "strict": false,
+    "subset": true,
+    "defaultEvaluationCriteria": {
+      "toolCalls": []
+    }
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-count.json b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-count.json
new file mode 100644
index 000000000..083d74214
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-count.json
@@ -0,0 +1,26 @@
+{
+  "version": "1.0",
+  "id": "ToolCallCountEvaluator",
+  "description": "Evaluates if the correct number of tool calls were made.",
+  "evaluatorTypeId": "uipath-tool-call-count",
+  "evaluatorConfig": {
+    "name": "ToolCallCountEvaluator",
+    "strict": false,
+    "defaultEvaluationCriteria": {
+      "toolCallsCount": {
+        "get_temperature": [
+          "=",
+          1
+        ],
+        "get_weather_condition": [
+          "=",
+          1
+        ],
+        "get_humidity": [
+          "=",
+          1
+        ]
+      }
+    }
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-order.json b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-order.json
new file mode 100644
index 000000000..dc2b352a7
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-order.json
@@ -0,0 +1,13 @@
+{
+  "version": "1.0",
+  "id": "ToolCallOrderEvaluator",
+  "description": "Evaluates if tools were called in the correct sequence.",
+  "evaluatorTypeId": "uipath-tool-call-order",
+  "evaluatorConfig": {
+    "name": "ToolCallOrderEvaluator",
+    "strict": false,
+    "defaultEvaluationCriteria": {
+      "toolCallsOrder": []
+    }
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-output.json b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-output.json
new file mode 100644
index 000000000..a0e32203c
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/evaluators/tool-call-output.json
@@ -0,0 +1,30 @@
+{
+  "version": "1.0",
+  "id": "ToolCallOutputEvaluator",
+  "description": "Evaluates if tool calls produced the correct outputs.",
+  "evaluatorTypeId": "uipath-tool-call-output",
+  "evaluatorConfig": {
+    "name": "ToolCallOutputEvaluator",
+    "strict": false,
+    "defaultEvaluationCriteria": {
+      "toolOutputs": [
+        {
+          "name": "get_temperature",
+          "output": "{'temperature': 25.0, 'unit': 'fahrenheit'}"
+        },
+        {
+          "name": "get_weather_condition",
+          "output": "{'condition': 'cloudy'}"
+        },
+        {
+          "name": "get_humidity",
+          "output": "{'humidity': 65}"
+        },
+        {
+          "name": "get_forecast",
+          "output": "{'forecast': 'Overcast with mild temperatures'}"
+        }
+      ]
+    }
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/evaluations/evaluators/trajectory.json b/packages/uipath/samples/weather_tools/evaluations/evaluators/trajectory.json
new file mode 100644
index 000000000..743142467
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/evaluations/evaluators/trajectory.json
@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "id": "TrajectoryEvaluator",
+  "description": "Evaluates the agent's execution trajectory and decision sequence for weather operations.",
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+  "evaluatorConfig": {
+    "name": "TrajectoryEvaluator",
+    "model": "gpt-4.1-2025-04-14",
+    "prompt": "Evaluate the agent's execution trajectory based on the expected behavior.\n\nExpected Agent Behavior: {{ExpectedAgentBehavior}}\nAgent Run History: {{AgentRunHistory}}\n\nProvide a score from 0-100 based on how well the agent followed the expected trajectory, including:\n- Correct tool selection and sequencing\n- Appropriate data retrieval\n- Proper handling of different action types\n- Correct orchestration of multiple tool calls",
+    "temperature": 0.0,
+    "defaultEvaluationCriteria": {
+      "expectedAgentBehavior": "The agent should call the appropriate weather tools and return the correct weather information for the requested city and action."
+    }
+  }
+}
diff --git a/packages/uipath/samples/weather_tools/main.py b/packages/uipath/samples/weather_tools/main.py
new file mode 100644
index 000000000..89b2deb15
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/main.py
@@ -0,0 +1,261 @@
+import logging
+from enum import Enum
+from typing import Literal, TypeVar
+
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+
+from uipath.eval.mocks import ExampleCall, mockable
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class City(str, Enum):
+    NEW_YORK = "New York"
+    LONDON = "London"
+    TOKYO = "Tokyo"
+    PARIS = "Paris"
+    SYDNEY = "Sydney"
+
+
+class WeatherCondition(str, Enum):
+    SUNNY = "sunny"
+    CLOUDY = "cloudy"
+    RAINY = "rainy"
+    SNOWY = "snowy"
+
+
+@dataclass
+class WeatherInput:
+    city: City
+    action: Literal["get_weather", "get_forecast", "get_alerts"]
+
+
+class _WeatherOutputContent(BaseModel):
+    city: str = ""
+    temperature: float = 0.0
+    condition: WeatherCondition = WeatherCondition.CLOUDY
+    humidity: int = 0
+    forecast: str | None = None
+    alerts: list[str] | None = None
+
+class WeatherOutput(_WeatherOutputContent):
+    content: _WeatherOutputContent
+
+# Mock example for get_temperature tool
+GET_TEMPERATURE_EXAMPLES = [
+    ExampleCall(
+        id="example1",
+        input='{"city": "New York"}',
+        output='{"temperature": 72.5, "unit": "fahrenheit"}'
+    )
+]
+
+@traced(name="get_temperature", span_type="tool")
+@mockable(example_calls=GET_TEMPERATURE_EXAMPLES)
+async def get_temperature(city: str) -> dict:
+    """Get the current temperature for a city.
+
+    Args:
+        city: The name of the city (e.g., "New York", "London", "Tokyo")
+
+    Returns:
+        Dictionary with temperature in fahrenheit and unit
+    """
+    # Convert string to City enum
+    city_enum = City(city)
+
+    # Simulated temperature data
+    temps = {
+        City.NEW_YORK: 72.5,
+        City.LONDON: 15.0,
+        City.TOKYO: 25.0,
+        City.PARIS: 18.0,
+        City.SYDNEY: 22.0,
+    }
+    return {"content":{"temperature": temps.get(city_enum, 20.0), "unit": "fahrenheit"}}
+
+
+GET_CONDITION_EXAMPLES = [
+    ExampleCall(
+        id="example1",
+        input='{"city": "London"}',
+        output='{"condition": "rainy"}'
+    )
+]
+
+@traced(name="get_weather_condition", span_type="tool")
+@mockable(example_calls=GET_CONDITION_EXAMPLES)
+async def get_weather_condition(city: str) -> dict:
+    """Get the current weather condition for a city.
+
+    Args:
+        city: The name of the city (e.g., "New York", "London", "Tokyo")
+
+    Returns:
+        Dictionary with the current weather condition
+    """
+    # Convert string to City enum
+    city_enum = City(city)
+
+    # Simulated weather conditions
+    conditions = {
+        City.NEW_YORK: WeatherCondition.SUNNY,
+        City.LONDON: WeatherCondition.RAINY,
+        City.TOKYO: WeatherCondition.CLOUDY,
+        City.PARIS: WeatherCondition.CLOUDY,
+        City.SYDNEY: WeatherCondition.SUNNY,
+    }
+    return {"content":{"condition": conditions.get(city_enum, WeatherCondition.CLOUDY).value}}
+
+
+GET_HUMIDITY_EXAMPLES = [
+    ExampleCall(
+        id="example1",
+        input='{"city": "Tokyo"}',
+        output='{"humidity": 65}'
+    )
+]
+
+@traced(name="get_humidity", span_type="tool")
+@mockable(example_calls=GET_HUMIDITY_EXAMPLES)
+async def get_humidity(city: str) -> dict:
+    """Get the current humidity level for a city.
+
+    Args:
+        city: The name of the city (e.g., "New York", "London", "Tokyo")
+
+    Returns:
+        Dictionary with the humidity percentage
+    """
+    # Convert string to City enum
+    city_enum = City(city)
+
+    # Simulated humidity data
+    humidity_levels = {
+        City.NEW_YORK: 60,
+        City.LONDON: 80,
+        City.TOKYO: 65,
+        City.PARIS: 70,
+        City.SYDNEY: 55,
+    }
+    return {"content":{"humidity": humidity_levels.get(city_enum, 60)}}
+
+
+GET_FORECAST_EXAMPLES = [
+    ExampleCall(
+        id="example1",
+        input='{"city": "Paris"}',
+        output='{"forecast": "Cloudy with a chance of rain in the afternoon"}'
+    )
+]
+
+
+@traced(name="get_forecast", span_type="tool")
+@mockable(example_calls=GET_FORECAST_EXAMPLES)
+async def get_forecast(city: str) -> dict:
+    """Get the weather forecast for a city.
+
+    Args:
+        city: The name of the city (e.g., "New York", "London", "Tokyo")
+
+    Returns:
+        Dictionary with the weather forecast
+    """
+    # Convert string to City enum
+    city_enum = City(city)
+
+    # Simulated forecasts
+    forecasts = {
+        City.NEW_YORK: "Clear skies throughout the day",
+        City.LONDON: "Rainy with occasional breaks",
+        City.TOKYO: "Overcast with mild temperatures",
+        City.PARIS: "Cloudy with a chance of rain in the afternoon",
+        City.SYDNEY: "Sunny and warm",
+    }
+    return {"content":{"forecast": forecasts.get(city_enum, "No forecast available")}}
+
+
+GET_ALERTS_EXAMPLES = [
+    ExampleCall(
+        id="example1",
+        input='{"city": "London"}',
+        output='{"alerts": ["Heavy rain warning until 6 PM"]}'
+    )
+]
+
+@traced(name="get_weather_alerts", span_type="tool")
+@mockable(example_calls=GET_ALERTS_EXAMPLES)
+async def get_weather_alerts(city: str) -> dict:
+    """Get weather alerts for a city.
+
+    Args:
+        city: The name of the city (e.g., "New York", "London", "Tokyo")
+
+    Returns:
+        Dictionary with a list of active weather alerts
+    """
+    # Convert string to City enum
+    city_enum = City(city)
+
+    # Simulated alerts
+    alerts = {
+        City.NEW_YORK: [],
+        City.LONDON: ["Heavy rain warning until 6 PM"],
+        City.TOKYO: [],
+        City.PARIS: [],
+        City.SYDNEY: ["UV index very high"],
+    }
+    return {"content":{"alerts": alerts.get(city_enum, [])}}
+
+
+@traced(name="main")
+async def main(input: WeatherInput) -> WeatherOutput:
+    """Main weather agent that orchestrates different weather tools.
+
+    This agent demonstrates multiple tool calls in sequence. Each tool invocation
+    creates its own span with tool.name set, allowing trajectory evaluation to
+    extract the complete sequence of tool calls.
+
+    Example trace for "get_weather" action:
+        1. Span: tool.name="get_temperature", input={"city": "New York"}, output={"temperature": 72.5, ...}
+        2. Span: tool.name="get_weather_condition", input={"city": "New York"}, output={"condition": "sunny"}
+        3. Span: tool.name="get_humidity", input={"city": "New York"}, output={"humidity": 60}
+    """
+    city = input.city.value  # Get string value from enum
+
+    # Multiple tool calls - each creates its own span with tool.name attribute
+    temp_data = await get_temperature(city)
+    condition_data = await get_weather_condition(city)
+    humidity_data = await get_humidity(city)
+
+    forecast = None
+    alerts = None
+
+    # Conditional tool calls based on action - each also creates its own span
+    # For "get_forecast": 4 total tool spans (temp, condition, humidity, forecast)
+    # For "get_alerts": 4 total tool spans (temp, condition, humidity, alerts)
+    # For "get_weather": 3 total tool spans (temp, condition, humidity)
+    if input.action == "get_forecast":
+        forecast_data = await get_forecast(city)
+        forecast = forecast_data["content"]["forecast"]
+    elif input.action == "get_alerts":
+        alerts_data = await get_weather_alerts(city)
+        alerts = alerts_data["content"]["alerts"]
+    elif input.action == "get_weather":
+        # For simple weather requests, just return basic info
+        pass
+
+    return WeatherOutput(
+        content=_WeatherOutputContent(
+        city=city,
+        temperature=temp_data["content"]["temperature"],
+        condition=WeatherCondition(condition_data["content"]["condition"]),
+        humidity=humidity_data["content"]["humidity"],
+        forecast=forecast,
+        alerts=alerts,
+        )
+    )
diff --git a/packages/uipath/samples/weather_tools/pyproject.toml b/packages/uipath/samples/weather_tools/pyproject.toml
new file mode 100644
index 000000000..aad0b4b31
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "weather-tools"
+version = "0.0.1"
+description = "Weather agent"
+authors = [{ name = "John Doe" }]
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "uipath",
+]
+
+[dependency-groups]
+dev = [
+    "uipath-dev",
+]
diff --git a/packages/uipath/samples/weather_tools/uipath.json b/packages/uipath/samples/weather_tools/uipath.json
new file mode 100644
index 000000000..ee698d9df
--- /dev/null
+++ b/packages/uipath/samples/weather_tools/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/scripts/debug_test.py b/packages/uipath/scripts/debug_test.py
similarity index 100%
rename from scripts/debug_test.py
rename to packages/uipath/scripts/debug_test.py
diff --git a/scripts/lint_httpx_client.py b/packages/uipath/scripts/lint_httpx_client.py
similarity index 96%
rename from scripts/lint_httpx_client.py
rename to packages/uipath/scripts/lint_httpx_client.py
index d1562115b..c8ee79855 100644
--- a/scripts/lint_httpx_client.py
+++ b/packages/uipath/scripts/lint_httpx_client.py
@@ -1,237 +1,237 @@
-#!/usr/bin/env python3
-"""Custom linter to check for httpx.Client() usage.
-
-This script checks for direct usage of httpx.Client() without using the
-get_httpx_client_kwargs() function, which is required for proper SSL
-and proxy configuration in the UiPath Python SDK.
-"""
-
-import ast
-import sys
-from pathlib import Path
-from typing import List, NamedTuple
-
-
-class LintViolation(NamedTuple):
-    """Represents a linting violation."""
-
-    filename: str
-    line: int
-    column: int
-    message: str
-    rule_code: str
-
-
-class HttpxClientChecker(ast.NodeVisitor):
-    """AST visitor to check for httpx.Client() usage violations."""
-
-    def __init__(self, filename: str):
-        """Initialize the checker with a filename.
-
-        Args:
-            filename: The path to the file being checked.
-        """
-        self.filename = filename
-        self.violations: List[LintViolation] = []
-        self.has_httpx_import = False
-        self.has_get_httpx_client_kwargs_import = False
-        # Track variables that contain get_httpx_client_kwargs
-        self.variables_with_httpx_kwargs: set[str] = set()
-
-    def visit_Import(self, node: ast.Import) -> None:
-        """Check for httpx imports."""
-        for alias in node.names:
-            if alias.name == "httpx":
-                self.has_httpx_import = True
-        self.generic_visit(node)
-
-    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
-        """Check for imports from httpx or get_httpx_client_kwargs."""
-        if node.module == "httpx":
-            self.has_httpx_import = True
-        elif node.module and "get_httpx_client_kwargs" in [
-            alias.name for alias in (node.names or [])
-        ]:
-            self.has_get_httpx_client_kwargs_import = True
-        self.generic_visit(node)
-
-    def visit_Assign(self, node: ast.Assign) -> None:
-        """Track variable assignments that use get_httpx_client_kwargs."""
-        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
-            var_name = node.targets[0].id
-            if self._assignment_uses_get_httpx_client_kwargs(node.value):
-                self.variables_with_httpx_kwargs.add(var_name)
-        self.generic_visit(node)
-
-    def _assignment_uses_get_httpx_client_kwargs(self, value_node: ast.AST) -> bool:
-        """Check if an assignment value uses get_httpx_client_kwargs."""
-        if isinstance(value_node, ast.Call):
-            # Direct call: var = get_httpx_client_kwargs()
-            if isinstance(value_node.func, ast.Name):
-                if value_node.func.id == "get_httpx_client_kwargs":
-                    return True
-            elif isinstance(value_node.func, ast.Attribute):
-                if value_node.func.attr == "get_httpx_client_kwargs":
-                    return True
-        elif isinstance(value_node, ast.Dict):
-            # Dictionary that spreads get_httpx_client_kwargs: {..., **get_httpx_client_kwargs()}
-            for key in value_node.keys:
-                if key is None:  # This is a **kwargs expansion
-                    # Find corresponding value
-                    idx = value_node.keys.index(key)
-                    if idx < len(value_node.values):
-                        spread_value = value_node.values[idx]
-                        if isinstance(spread_value, ast.Call):
-                            if isinstance(spread_value.func, ast.Name):
-                                if spread_value.func.id == "get_httpx_client_kwargs":
-                                    return True
-                            elif isinstance(spread_value.func, ast.Attribute):
-                                if spread_value.func.attr == "get_httpx_client_kwargs":
-                                    return True
-                        elif isinstance(spread_value, ast.Name):
-                            # Spreading another variable that might contain httpx kwargs
-                            if spread_value.id in self.variables_with_httpx_kwargs:
-                                return True
-        return False
-
-    def visit_Call(self, node: ast.Call) -> None:
-        """Check for httpx.Client() and httpx.AsyncClient() calls."""
-        if self._is_httpx_client_call(node):
-            # Check if this is a proper usage with get_httpx_client_kwargs
-            if not self._is_using_get_httpx_client_kwargs(node):
-                client_type = self._get_client_type(node)
-                violation = LintViolation(
-                    filename=self.filename,
-                    line=node.lineno,
-                    column=node.col_offset,
-                    message=f"Use **get_httpx_client_kwargs() with {client_type}() - should be: {client_type}(**get_httpx_client_kwargs())",
-                    rule_code="UIPATH001",
-                )
-                self.violations.append(violation)
-
-        self.generic_visit(node)
-
-    def _is_httpx_client_call(self, node: ast.Call) -> bool:
-        """Check if the call is httpx.Client() or httpx.AsyncClient()."""
-        if isinstance(node.func, ast.Attribute):
-            if (
-                isinstance(node.func.value, ast.Name)
-                and node.func.value.id == "httpx"
-                and node.func.attr in ("Client", "AsyncClient")
-            ):
-                return True
-        elif isinstance(node.func, ast.Name) and node.func.id in (
-            "Client",
-            "AsyncClient",
-        ):
-            # This could be a direct Client/AsyncClient import, check if httpx is imported
-            return self.has_httpx_import
-        return False
-
-    def _get_client_type(self, node: ast.Call) -> str:
-        """Get the client type name (Client or AsyncClient)."""
-        if isinstance(node.func, ast.Attribute):
-            return f"httpx.{node.func.attr}"
-        elif isinstance(node.func, ast.Name):
-            return node.func.id
-        return "httpx.Client"
-
-    def _is_using_get_httpx_client_kwargs(self, node: ast.Call) -> bool:
-        """Check if the httpx.Client() call is using **get_httpx_client_kwargs()."""
-        # Check if there are any **kwargs that use get_httpx_client_kwargs directly
-        for keyword in node.keywords:
-            if keyword.arg is None:  # This is a **kwargs expansion
-                if isinstance(keyword.value, ast.Call):
-                    if isinstance(keyword.value.func, ast.Name):
-                        if keyword.value.func.id == "get_httpx_client_kwargs":
-                            return True
-                    elif isinstance(keyword.value.func, ast.Attribute):
-                        if keyword.value.func.attr == "get_httpx_client_kwargs":
-                            return True
-                elif isinstance(keyword.value, ast.Name):
-                    # Check if this variable might contain get_httpx_client_kwargs
-                    # This handles cases like: **client_kwargs where client_kwargs was built from get_httpx_client_kwargs
-                    var_name = keyword.value.id
-                    if self._variable_contains_get_httpx_client_kwargs(var_name):
-                        return True
-
-        # Also check if it's the ONLY argument and it's **get_httpx_client_kwargs()
-        # This handles cases like: httpx.Client(**get_httpx_client_kwargs())
-        if len(node.args) == 0 and len(node.keywords) == 1:
-            keyword = node.keywords[0]
-            if keyword.arg is None and isinstance(keyword.value, ast.Call):
-                if isinstance(keyword.value.func, ast.Name):
-                    if keyword.value.func.id == "get_httpx_client_kwargs":
-                        return True
-                elif isinstance(keyword.value.func, ast.Attribute):
-                    if keyword.value.func.attr == "get_httpx_client_kwargs":
-                        return True
-
-        return False
-
-    def _variable_contains_get_httpx_client_kwargs(self, var_name: str) -> bool:
-        """Check if a variable was built using get_httpx_client_kwargs()."""
-        # Check if we've tracked this variable as containing httpx kwargs
-        if var_name in self.variables_with_httpx_kwargs:
-            return True
-
-        # Fallback: Simple heuristic based on naming patterns
-        # This handles cases where the variable assignment might be complex
-        if "client_kwargs" in var_name.lower() or "httpx_kwargs" in var_name.lower():
-            return True
-
-        return False
-
-
-def check_file(filepath: Path) -> List[LintViolation]:
-    """Check a single Python file for httpx.Client() violations."""
-    try:
-        with open(filepath, "r", encoding="utf-8") as f:
-            content = f.read()
-
-        tree = ast.parse(content, filename=str(filepath))
-        checker = HttpxClientChecker(str(filepath))
-        checker.visit(tree)
-        return checker.violations
-
-    except SyntaxError:
-        # Skip files with syntax errors
-        return []
-    except Exception as e:
-        print(f"Error checking {filepath}: {e}", file=sys.stderr)
-        return []
-
-
-def main():
-    """Main function to run the linter."""
-    if len(sys.argv) > 1:
-        paths = [Path(p) for p in sys.argv[1:]]
-    else:
-        # Default to checking src and tests directories
-        paths = [Path("src"), Path("tests")]
-
-    all_violations = []
-
-    for path in paths:
-        if path.is_file() and path.suffix == ".py":
-            violations = check_file(path)
-            all_violations.extend(violations)
-        elif path.is_dir():
-            for py_file in path.rglob("*.py"):
-                violations = check_file(py_file)
-                all_violations.extend(violations)
-
-    # Report violations
-    if all_violations:
-        for violation in all_violations:
-            print(
-                f"{violation.filename}:{violation.line}:{violation.column}: {violation.rule_code} {violation.message}"
-            )
-        sys.exit(1)
-    else:
-        print("No httpx.Client() violations found.")
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Custom linter to check for httpx.Client() usage.
+
+This script checks for direct usage of httpx.Client() without using the
+get_httpx_client_kwargs() function, which is required for proper SSL
+and proxy configuration in the UiPath Python SDK.
+"""
+
+import ast
+import sys
+from pathlib import Path
+from typing import NamedTuple
+
+
+class LintViolation(NamedTuple):
+    """Represents a linting violation."""
+
+    filename: str
+    line: int
+    column: int
+    message: str
+    rule_code: str
+
+
+class HttpxClientChecker(ast.NodeVisitor):
+    """AST visitor to check for httpx.Client() usage violations."""
+
+    def __init__(self, filename: str):
+        """Initialize the checker with a filename.
+
+        Args:
+            filename: The path to the file being checked.
+        """
+        self.filename = filename
+        self.violations: list[LintViolation] = []
+        self.has_httpx_import = False
+        self.has_get_httpx_client_kwargs_import = False
+        # Track variables that contain get_httpx_client_kwargs
+        self.variables_with_httpx_kwargs: set[str] = set()
+
+    def visit_Import(self, node: ast.Import) -> None:
+        """Check for httpx imports."""
+        for alias in node.names:
+            if alias.name == "httpx":
+                self.has_httpx_import = True
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        """Check for imports from httpx or get_httpx_client_kwargs."""
+        if node.module == "httpx":
+            self.has_httpx_import = True
+        elif node.module and "get_httpx_client_kwargs" in [
+            alias.name for alias in (node.names or [])
+        ]:
+            self.has_get_httpx_client_kwargs_import = True
+        self.generic_visit(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """Track variable assignments that use get_httpx_client_kwargs."""
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            var_name = node.targets[0].id
+            if self._assignment_uses_get_httpx_client_kwargs(node.value):
+                self.variables_with_httpx_kwargs.add(var_name)
+        self.generic_visit(node)
+
+    def _assignment_uses_get_httpx_client_kwargs(self, value_node: ast.AST) -> bool:
+        """Check if an assignment value uses get_httpx_client_kwargs."""
+        if isinstance(value_node, ast.Call):
+            # Direct call: var = get_httpx_client_kwargs()
+            if isinstance(value_node.func, ast.Name):
+                if value_node.func.id == "get_httpx_client_kwargs":
+                    return True
+            elif isinstance(value_node.func, ast.Attribute):
+                if value_node.func.attr == "get_httpx_client_kwargs":
+                    return True
+        elif isinstance(value_node, ast.Dict):
+            # Dictionary that spreads get_httpx_client_kwargs: {..., **get_httpx_client_kwargs()}
+            for key in value_node.keys:
+                if key is None:  # This is a **kwargs expansion
+                    # Find corresponding value
+                    idx = value_node.keys.index(key)
+                    if idx < len(value_node.values):
+                        spread_value = value_node.values[idx]
+                        if isinstance(spread_value, ast.Call):
+                            if isinstance(spread_value.func, ast.Name):
+                                if spread_value.func.id == "get_httpx_client_kwargs":
+                                    return True
+                            elif isinstance(spread_value.func, ast.Attribute):
+                                if spread_value.func.attr == "get_httpx_client_kwargs":
+                                    return True
+                        elif isinstance(spread_value, ast.Name):
+                            # Spreading another variable that might contain httpx kwargs
+                            if spread_value.id in self.variables_with_httpx_kwargs:
+                                return True
+        return False
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Check for httpx.Client() and httpx.AsyncClient() calls."""
+        if self._is_httpx_client_call(node):
+            # Check if this is a proper usage with get_httpx_client_kwargs
+            if not self._is_using_get_httpx_client_kwargs(node):
+                client_type = self._get_client_type(node)
+                violation = LintViolation(
+                    filename=self.filename,
+                    line=node.lineno,
+                    column=node.col_offset,
+                    message=f"Use **get_httpx_client_kwargs() with {client_type}() - should be: {client_type}(**get_httpx_client_kwargs())",
+                    rule_code="UIPATH001",
+                )
+                self.violations.append(violation)
+
+        self.generic_visit(node)
+
+    def _is_httpx_client_call(self, node: ast.Call) -> bool:
+        """Check if the call is httpx.Client() or httpx.AsyncClient()."""
+        if isinstance(node.func, ast.Attribute):
+            if (
+                isinstance(node.func.value, ast.Name)
+                and node.func.value.id == "httpx"
+                and node.func.attr in ("Client", "AsyncClient")
+            ):
+                return True
+        elif isinstance(node.func, ast.Name) and node.func.id in (
+            "Client",
+            "AsyncClient",
+        ):
+            # This could be a direct Client/AsyncClient import, check if httpx is imported
+            return self.has_httpx_import
+        return False
+
+    def _get_client_type(self, node: ast.Call) -> str:
+        """Get the client type name (Client or AsyncClient)."""
+        if isinstance(node.func, ast.Attribute):
+            return f"httpx.{node.func.attr}"
+        elif isinstance(node.func, ast.Name):
+            return node.func.id
+        return "httpx.Client"
+
+    def _is_using_get_httpx_client_kwargs(self, node: ast.Call) -> bool:
+        """Check if the httpx.Client() call is using **get_httpx_client_kwargs()."""
+        # Check if there are any **kwargs that use get_httpx_client_kwargs directly
+        for keyword in node.keywords:
+            if keyword.arg is None:  # This is a **kwargs expansion
+                if isinstance(keyword.value, ast.Call):
+                    if isinstance(keyword.value.func, ast.Name):
+                        if keyword.value.func.id == "get_httpx_client_kwargs":
+                            return True
+                    elif isinstance(keyword.value.func, ast.Attribute):
+                        if keyword.value.func.attr == "get_httpx_client_kwargs":
+                            return True
+                elif isinstance(keyword.value, ast.Name):
+                    # Check if this variable might contain get_httpx_client_kwargs
+                    # This handles cases like: **client_kwargs where client_kwargs was built from get_httpx_client_kwargs
+                    var_name = keyword.value.id
+                    if self._variable_contains_get_httpx_client_kwargs(var_name):
+                        return True
+
+        # Also check if it's the ONLY argument and it's **get_httpx_client_kwargs()
+        # This handles cases like: httpx.Client(**get_httpx_client_kwargs())
+        if len(node.args) == 0 and len(node.keywords) == 1:
+            keyword = node.keywords[0]
+            if keyword.arg is None and isinstance(keyword.value, ast.Call):
+                if isinstance(keyword.value.func, ast.Name):
+                    if keyword.value.func.id == "get_httpx_client_kwargs":
+                        return True
+                elif isinstance(keyword.value.func, ast.Attribute):
+                    if keyword.value.func.attr == "get_httpx_client_kwargs":
+                        return True
+
+        return False
+
+    def _variable_contains_get_httpx_client_kwargs(self, var_name: str) -> bool:
+        """Check if a variable was built using get_httpx_client_kwargs()."""
+        # Check if we've tracked this variable as containing httpx kwargs
+        if var_name in self.variables_with_httpx_kwargs:
+            return True
+
+        # Fallback: Simple heuristic based on naming patterns
+        # This handles cases where the variable assignment might be complex
+        if "client_kwargs" in var_name.lower() or "httpx_kwargs" in var_name.lower():
+            return True
+
+        return False
+
+
+def check_file(filepath: Path) -> list[LintViolation]:
+    """Check a single Python file for httpx.Client() violations."""
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        tree = ast.parse(content, filename=str(filepath))
+        checker = HttpxClientChecker(str(filepath))
+        checker.visit(tree)
+        return checker.violations
+
+    except SyntaxError:
+        # Skip files with syntax errors
+        return []
+    except Exception as e:
+        print(f"Error checking {filepath}: {e}", file=sys.stderr)
+        return []
+
+
+def main():
+    """Main function to run the linter."""
+    if len(sys.argv) > 1:
+        paths = [Path(p) for p in sys.argv[1:]]
+    else:
+        # Default to checking src and tests directories
+        paths = [Path("src"), Path("tests")]
+
+    all_violations = []
+
+    for path in paths:
+        if path.is_file() and path.suffix == ".py":
+            violations = check_file(path)
+            all_violations.extend(violations)
+        elif path.is_dir():
+            for py_file in path.rglob("*.py"):
+                violations = check_file(py_file)
+                all_violations.extend(violations)
+
+    # Report violations
+    if all_violations:
+        for violation in all_violations:
+            print(
+                f"{violation.filename}:{violation.line}:{violation.column}: {violation.rule_code} {violation.message}"
+            )
+        sys.exit(1)
+    else:
+        print("No httpx.Client() violations found.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/scripts/update_agents_md.py b/packages/uipath/scripts/update_agents_md.py
new file mode 100644
index 000000000..dfd85dd92
--- /dev/null
+++ b/packages/uipath/scripts/update_agents_md.py
@@ -0,0 +1,671 @@
+#!/usr/bin/env python3
+"""Script to update AGENTS.md reference files with complete library documentation.
+
+This script extracts information from the uipath SDK and CLI commands and updates
+the AGENTS.md reference files with comprehensive documentation including
+- API Reference (SDK services and methods)
+- CLI Commands Reference
+"""
+
+import inspect
+import sys
+from io import StringIO
+from pathlib import Path
+from typing import Any
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import click
+
+
+def get_command_help(command: click.Command, command_name: str) -> dict[str, Any]:
+    """Extract help information from a Click command.
+
+    Args:
+        command: The Click command to extract help from
+        command_name: The name of the command
+
+    Returns:
+        Dictionary with command information
+    """
+    help_text = command.help or "No description available."
+    params = []
+    for param in command.params:
+        param_info = {
+            "name": param.name,
+            "type": type(param).__name__,
+            "help": getattr(param, "help", "") or "",
+            "required": param.required,
+        }
+
+        if isinstance(param, click.Option):
+            param_info["opts"] = param.opts
+            param_info["is_flag"] = param.is_flag
+            if param.default is not None and not param.is_flag:
+                param_info["default"] = param.default
+        elif isinstance(param, click.Argument):
+            param_info["opts"] = [param.name]
+
+        params.append(param_info)
+
+    return {
+        "name": command_name,
+        "help": help_text,
+        "params": params,
+    }
+
+
+def extract_method_signature(method: Any, include_types: bool = True) -> str:
+    """Extract a clean method signature from a method object.
+
+    Args:
+        method: The method to extract signature from
+        include_types: Whether to include type annotations
+
+    Returns:
+        String representation of the method signature
+    """
+    try:
+        sig = inspect.signature(method)
+        params = []
+        for name, param in sig.parameters.items():
+            if name in ("self", "cls"):
+                continue
+
+            param_str = name
+            if include_types and param.annotation != inspect.Parameter.empty:
+                type_str = str(param.annotation)
+                type_str = type_str.replace("<class '", "").replace("'>", "")
+                type_str = type_str.replace("typing.", "")
+                param_str = f"{name}: {type_str}"
+
+            if param.default != inspect.Parameter.empty:
+                if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                    param_str = f"*{name}"
+                elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                    param_str = f"**{name}"
+                elif param.default is None:
+                    param_str = f"{param_str}=None"
+                elif isinstance(param.default, str):
+                    param_str = f'{param_str}="{param.default}"'
+                elif isinstance(param.default, bool):
+                    param_str = f"{param_str}={param.default}"
+                else:
+                    param_str = f"{param_str}={param.default}"
+            else:
+                if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                    param_str = f"*{name}"
+                elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                    param_str = f"**{name}"
+
+            params.append(param_str)
+        return f"({', '.join(params)})"
+    except Exception:
+        return "()"
+
+
+def get_first_line(docstring: str) -> str:
+    """Get the first meaningful line from a docstring.
+
+    Args:
+        docstring: The docstring to process
+
+    Returns:
+        First line of the docstring
+    """
+    if not docstring:
+        return ""
+    lines = docstring.strip().split("\n")
+    for line in lines:
+        stripped = line.strip()
+        if (
+            stripped
+            and not stripped.startswith("Args:")
+            and not stripped.startswith("Returns:")
+        ):
+            return stripped
+    return ""
+
+
+def get_service_methods(service_class: type) -> list[tuple[str, Any]]:
+    """Extract public methods from a service class.
+
+    Args:
+        service_class: The service class to extract methods from
+
+    Returns:
+        List of tuples (method_name, method_object) for public methods
+    """
+    methods = []
+    for name in dir(service_class):
+        if name.startswith("_"):
+            continue
+        attr = getattr(service_class, name, None)
+        if callable(attr) and hasattr(attr, "__doc__") and attr.__doc__:
+            methods.append((name, attr))
+    return methods
+
+
+def generate_quick_api_docs() -> str:
+    """Generate API Reference documentation for SDK.
+
+    Returns:
+        Markdown string with SDK API documentation
+    """
+    from functools import cached_property
+
+    from uipath.platform import UiPath
+
+    output = StringIO()
+    output.write("\n## API Reference\n\n")
+    output.write(
+        "This section provides a comprehensive reference for all UiPath SDK services and methods. "
+        "Each service is documented with complete method signatures, including parameter types and return types.\n\n"
+    )
+
+    output.write("### SDK Initialization\n\n")
+    output.write("Initialize the UiPath SDK client\n\n")
+    output.write("```python\n")
+    output.write("from uipath.platform import UiPath\n\n")
+    output.write("# Initialize with environment variables\n")
+    output.write("sdk = UiPath()\n\n")
+    output.write("# Or with explicit credentials\n")
+    output.write(
+        'sdk = UiPath(base_url="https://cloud.uipath.com/...", secret="your_token")\n'
+    )
+    output.write("```\n\n")
+
+    uipath_properties = []
+    for name in dir(UiPath):
+        if name.startswith("_"):
+            continue
+        attr = getattr(UiPath, name, None)
+        if isinstance(attr, (property, cached_property)):
+            uipath_properties.append(name)
+
+    uipath_properties.sort()
+
+    for service_name in uipath_properties:
+        try:
+            service_property = getattr(UiPath, service_name)
+            if not isinstance(service_property, (property, cached_property)):
+                continue
+
+            # Get the function object (property uses .fget, cached_property uses .func)
+            if isinstance(service_property, cached_property):
+                func = service_property.func
+            else:
+                func = service_property.fget  # type: ignore[assignment]
+
+            if func is None:
+                continue
+
+            service_doc = func.__doc__
+
+            description = (
+                service_doc.strip().split("\n")[0]
+                if service_doc
+                else f"{service_name.replace('_', ' ').title()} service"
+            )
+
+            return_annotation = None
+            property_sig = inspect.signature(func)
+            return_annotation = property_sig.return_annotation
+
+            output.write(f"### {service_name.replace('_', ' ').title()}\n\n")
+            output.write(f"{description}\n\n")
+            output.write("```python\n")
+
+            if return_annotation and return_annotation != inspect.Signature.empty:
+                service_class = return_annotation
+                methods = get_service_methods(service_class)
+
+                if methods:
+                    for method_name, method in methods:
+                        try:
+                            if callable(method):
+                                method_sig = extract_method_signature(method)
+                                doc = get_first_line(inspect.getdoc(method) or "")
+
+                                return_type = ""
+                                try:
+                                    sig = inspect.signature(method)
+                                    if sig.return_annotation != inspect.Signature.empty:
+                                        return_type_str = str(sig.return_annotation)
+                                        return_type_str = return_type_str.replace(
+                                            "<class '", ""
+                                        ).replace("'>", "")
+                                        return_type = f" -> {return_type_str}"
+                                except Exception:
+                                    pass
+
+                                output.write(f"# {doc}\n" if doc else "")
+                                output.write(
+                                    f"sdk.{service_name}.{method_name}{method_sig}{return_type}\n\n"
+                                )
+                        except Exception:
+                            continue
+                else:
+                    output.write(f"# Access {service_name} service methods\n")
+                    output.write(f"service = sdk.{service_name}\n\n")
+
+            output.write("```\n\n")
+        except Exception:
+            continue
+
+    return output.getvalue()
+
+
+def generate_cli_docs() -> str:
+    """Generate CLI documentation markdown.
+
+    Returns:
+        Markdown string with CLI commands documentation
+    """
+    from uipath._cli.cli_eval import eval
+    from uipath._cli.cli_init import init
+    from uipath._cli.cli_run import run
+
+    commands = [
+        ("init", init),
+        ("run", run),
+        ("eval", eval),
+    ]
+
+    output = StringIO()
+    output.write("\n## CLI Commands Reference\n\n")
+    output.write(
+        "The UiPath Python SDK provides a comprehensive CLI for managing coded agents and automation projects. "
+        "All commands should be executed with `uv run uipath <command>`.\n\n"
+    )
+
+    output.write("### Command Overview\n\n")
+    output.write("| Command | Purpose | When to Use |\n")
+    output.write("|---------|---------|-------------|\n")
+    output.write(
+        "| `init` | Initialize agent project | Creating a new agent or updating schema |\n"
+    )
+    output.write("| `run` | Execute agent | Running agent locally or testing |\n")
+    output.write(
+        "| `eval` | Evaluate agent | Testing agent performance with evaluation sets |\n\n"
+    )
+
+    output.write("---\n\n")
+
+    for cmd_name, cmd in commands:
+        cmd_info = get_command_help(cmd, cmd_name)
+
+        output.write(f"### `uipath {cmd_name}`\n\n")
+        output.write(f"**Description:** {cmd_info['help']}\n\n")
+
+        arguments = [p for p in cmd_info["params"] if p["type"] == "Argument"]
+        options = [p for p in cmd_info["params"] if p["type"] == "Option"]
+
+        if arguments:
+            output.write("**Arguments:**\n\n")
+            output.write("| Argument | Required | Description |\n")
+            output.write("|----------|----------|-------------|\n")
+            for arg in arguments:
+                required = "Yes" if arg.get("required") else "No"
+                help_text = arg["help"] if arg["help"] else "N/A"
+                output.write(f"| `{arg['name']}` | {required} | {help_text} |\n")
+            output.write("\n")
+
+        if options:
+            output.write("**Options:**\n\n")
+            output.write("| Option | Type | Default | Description |\n")
+            output.write("|--------|------|---------|-------------|\n")
+            for opt in options:
+                opts_str = ", ".join(f"`{o}`" for o in opt.get("opts", []))
+
+                if opt.get("is_flag"):
+                    opt_type = "flag"
+                    default = "false"
+                elif opt.get("default") is not None:
+                    opt_type = "value"
+                    default_val = opt["default"]
+                    if isinstance(default_val, str):
+                        default = f'`"{default_val}"`'
+                    else:
+                        default = f"`{default_val}`"
+                else:
+                    opt_type = "value"
+                    default = "none"
+
+                help_text = opt["help"] if opt["help"] else "N/A"
+                output.write(f"| {opts_str} | {opt_type} | {default} | {help_text} |\n")
+            output.write("\n")
+
+        output.write("**Usage Examples:**\n\n")
+
+        if cmd_name == "init":
+            output.write("```bash\n")
+            output.write("# Initialize a new agent project\n")
+            output.write("uv run uipath init\n\n")
+            output.write("# Initialize with specific entrypoint\n")
+            output.write("uv run uipath init main.py\n\n")
+            output.write("# Initialize and infer bindings from code\n")
+            output.write("uv run uipath init --infer-bindings\n")
+            output.write("```\n\n")
+            output.write(
+                "**When to use:** Run this command when you've modified the Input/Output models and need to regenerate the `uipath.json` schema file.\n\n"
+            )
+
+        elif cmd_name == "run":
+            output.write("```bash\n")
+            output.write("# Run agent with inline JSON input\n")
+            output.write(
+                'uv run uipath run main.py \'{"query": "What is the weather?"}\'\n\n'
+            )
+            output.write("# Run agent with input from file\n")
+            output.write("uv run uipath run main.py --file input.json\n\n")
+            output.write("# Run agent and save output to file\n")
+            output.write(
+                'uv run uipath run agent \'{"task": "Process data"}\' --output-file result.json\n\n'
+            )
+            output.write("# Run agent with debugging enabled\n")
+            output.write(
+                'uv run uipath run main.py \'{"input": "test"}\' --debug --debug-port 5678\n\n'
+            )
+            output.write("# Resume agent execution from previous state\n")
+            output.write("uv run uipath run --resume\n")
+            output.write("```\n\n")
+            output.write(
+                "**When to use:** Run this command to execute your agent locally for development, testing, or debugging. Use `--debug` flag to attach a debugger for step-by-step debugging.\n\n"
+            )
+
+        elif cmd_name == "eval":
+            output.write("```bash\n")
+            output.write("# Run evaluation with auto-discovered files\n")
+            output.write("uv run uipath eval\n\n")
+            output.write("# Run evaluation with specific entrypoint and eval set\n")
+            output.write("uv run uipath eval main.py eval_set.json\n\n")
+            output.write("# Run evaluation without reporting results\n")
+            output.write("uv run uipath eval --no-report\n\n")
+            output.write("# Run evaluation with custom number of workers\n")
+            output.write("uv run uipath eval --workers 4\n\n")
+            output.write("# Save evaluation output to file\n")
+            output.write("uv run uipath eval --output-file eval_results.json\n")
+            output.write("```\n\n")
+            output.write(
+                "**When to use:** Run this command to test your agent's performance against a predefined evaluation set. This helps validate agent behavior and measure quality metrics.\n\n"
+            )
+
+        output.write("---\n\n")
+
+    output.write("### Common Workflows\n\n")
+    output.write("**1. Creating a New Agent:**\n")
+    output.write("```bash\n")
+    output.write("# Step 1: Initialize project\n")
+    output.write("uv run uipath init\n\n")
+    output.write("# Step 2: Run agent to test\n")
+    output.write('uv run uipath run main.py \'{"input": "test"}\'\n\n')
+    output.write("# Step 3: Evaluate agent performance\n")
+    output.write("uv run uipath eval\n")
+    output.write("```\n\n")
+
+    output.write("**2. Development & Testing:**\n")
+    output.write("```bash\n")
+    output.write("# Run with debugging\n")
+    output.write('uv run uipath run main.py \'{"input": "test"}\' --debug\n\n')
+    output.write("# Test with input file\n")
+    output.write(
+        "uv run uipath run main.py --file test_input.json --output-file test_output.json\n"
+    )
+    output.write("```\n\n")
+
+    output.write("**3. Schema Updates:**\n")
+    output.write("```bash\n")
+    output.write("# After modifying Input/Output models, regenerate schema\n")
+    output.write("uv run uipath init --infer-bindings\n")
+    output.write("```\n\n")
+
+    output.write("### Configuration File (uipath.json)\n\n")
+    output.write(
+        "The `uipath.json` file is automatically generated by `uipath init` and defines your agent's schema and bindings.\n\n"
+    )
+
+    output.write("**Structure:**\n\n")
+    output.write("```json\n")
+    output.write("{\n")
+    output.write('  "entryPoints": [\n')
+    output.write("    {\n")
+    output.write('      "filePath": "agent",\n')
+    output.write('      "uniqueId": "uuid-here",\n')
+    output.write('      "type": "agent",\n')
+    output.write('      "input": {\n')
+    output.write('        "type": "object",\n')
+    output.write('        "properties": { ... },\n')
+    output.write('        "description": "Input schema",\n')
+    output.write('        "required": [ ... ]\n')
+    output.write("      },\n")
+    output.write('      "output": {\n')
+    output.write('        "type": "object",\n')
+    output.write('        "properties": { ... },\n')
+    output.write('        "description": "Output schema",\n')
+    output.write('        "required": [ ... ]\n')
+    output.write("      }\n")
+    output.write("    }\n")
+    output.write("  ],\n")
+    output.write('  "bindings": {\n')
+    output.write('    "version": "2.0",\n')
+    output.write('    "resources": []\n')
+    output.write("  }\n")
+    output.write("}\n")
+    output.write("```\n\n")
+
+    output.write("**When to Update:**\n\n")
+    output.write(
+        "1. **After Modifying Input/Output Models**: Run `uv run uipath init --infer-bindings` to regenerate schemas\n"
+    )
+    output.write(
+        "2. **Changing Entry Point**: Update `filePath` if you rename or move your main file\n"
+    )
+    output.write(
+        "3. **Manual Schema Adjustments**: Edit `input.jsonSchema` or `output.jsonSchema` directly if needed\n"
+    )
+    output.write(
+        "4. **Bindings Updates**: The `bindings` section maps the exported graph variable - update if you rename your graph\n\n"
+    )
+
+    output.write("**Important Notes:**\n\n")
+    output.write("- The `uniqueId` should remain constant for the same agent\n")
+    output.write('- Always use `type: "agent"` for LangGraph agents\n')
+    output.write("- The `jsonSchema` must match your Pydantic models exactly\n")
+    output.write(
+        "- Re-run `uipath init --infer-bindings` instead of manual edits when possible\n\n"
+    )
+
+    return output.getvalue()
+
+
+def generate_service_cli_docs() -> str:
+    """Generate documentation for service CLI commands.
+
+    Returns:
+        Markdown string with service CLI commands documentation
+    """
+    from uipath._cli import cli
+
+    output = StringIO()
+    output.write("\n## Service Commands Reference\n\n")
+    output.write(
+        "The UiPath CLI provides commands for interacting with UiPath platform services. "
+        "These commands allow you to manage buckets, assets, jobs, and other resources.\n\n"
+    )
+
+    # With LazyGroup, we need to use list_commands() and get_command()
+    # Create a fake context for the CLI
+    ctx = click.Context(cli)
+
+    # Get all command names and filter for service groups
+    all_command_names = cli.list_commands(ctx)
+
+    service_groups = []
+    for name in sorted(all_command_names):
+        if name not in [
+            "init",
+            "run",
+            "eval",
+            "new",
+            "pack",
+            "publish",
+            "deploy",
+            "auth",
+            "invoke",
+            "push",
+            "pull",
+            "dev",
+            "add",
+            "register",
+            "debug",
+        ]:
+            cmd = cli.get_command(ctx, name)
+            if isinstance(cmd, click.Group):
+                service_groups.append((name, cmd))
+
+    if not service_groups:
+        return ""
+
+    for service_name, service_group in service_groups:
+        output.write(f"### `uipath {service_name}`\n\n")
+        output.write(f"{service_group.help or 'Manage ' + service_name}\n\n")
+
+        # Document subcommands - use list_commands/get_command for lazy groups
+        service_ctx = click.Context(service_group, parent=ctx)
+
+        if hasattr(service_group, "list_commands"):
+            subcommand_names = service_group.list_commands(service_ctx)
+        elif hasattr(service_group, "commands"):
+            subcommand_names = list(service_group.commands.keys())
+        else:
+            subcommand_names = []
+
+        if subcommand_names:
+            output.write("**Subcommands:**\n\n")
+
+            for subcmd_name in sorted(subcommand_names):
+                # Get the subcommand
+                if hasattr(service_group, "get_command"):
+                    subcmd = service_group.get_command(service_ctx, subcmd_name)
+                elif hasattr(service_group, "commands"):
+                    subcmd = service_group.commands.get(subcmd_name)
+                else:
+                    continue
+
+                if subcmd is None:
+                    continue
+
+                # Handle nested groups (e.g., buckets files)
+                if isinstance(subcmd, click.Group):
+                    output.write(f"#### `uipath {service_name} {subcmd_name}`\n\n")
+                    output.write(f"{subcmd.help or f'{subcmd_name} commands'}\n\n")
+
+                    # Get nested commands
+                    nested_ctx = click.Context(subcmd, parent=service_ctx)
+                    if hasattr(subcmd, "list_commands"):
+                        nested_cmd_names = subcmd.list_commands(nested_ctx)
+                    elif hasattr(subcmd, "commands"):
+                        nested_cmd_names = list(subcmd.commands.keys())
+                    else:
+                        nested_cmd_names = []
+
+                    for nested_name in sorted(nested_cmd_names):
+                        if hasattr(subcmd, "get_command"):
+                            nested_cmd = subcmd.get_command(nested_ctx, nested_name)
+                        elif hasattr(subcmd, "commands"):
+                            nested_cmd = subcmd.commands.get(nested_name)
+                        else:
+                            continue
+
+                        if nested_cmd is None:
+                            continue
+
+                        cmd_info = get_command_help(
+                            nested_cmd,
+                            f"{service_name} {subcmd_name} {nested_name}",
+                        )
+                        _write_command_doc(output, cmd_info, service_name, subcmd_name)
+                else:
+                    cmd_info = get_command_help(subcmd, f"{service_name} {subcmd_name}")
+                    _write_command_doc(output, cmd_info, service_name)
+
+        output.write("---\n\n")
+
+    return output.getvalue()
+
+
+def _write_command_doc(
+    output: StringIO, cmd_info: dict[str, Any], *path_parts: str
+) -> None:
+    """Write command documentation to output stream.
+
+    Args:
+        output: StringIO buffer to write to
+        cmd_info: Command information dict
+        path_parts: Command path parts (e.g., "buckets", "files")
+    """
+    full_path = " ".join(path_parts + (cmd_info["name"].split()[-1],))
+
+    output.write(f"**`uipath {full_path}`**\n\n")
+    output.write(f"{cmd_info['help']}\n\n")
+
+    arguments = [p for p in cmd_info["params"] if p["type"] == "Argument"]
+    options = [p for p in cmd_info["params"] if p["type"] == "Option"]
+
+    if arguments:
+        output.write("Arguments:\n")
+        for arg in arguments:
+            required = " (required)" if arg.get("required") else ""
+            help_text = arg["help"] if arg["help"] else "N/A"
+            output.write(f"- `{arg['name']}`{required}: {help_text}\n")
+        output.write("\n")
+
+    if options:
+        output.write("Options:\n")
+        for opt in options:
+            opts_str = ", ".join(f"`{o}`" for o in opt.get("opts", []))
+            help_text = opt["help"] if opt["help"] else ""
+
+            if opt.get("default") is not None and not opt.get("is_flag"):
+                default = opt["default"]
+                if isinstance(default, str):
+                    help_text += f" (default: `{default}`)"
+                else:
+                    help_text += f" (default: `{default}`)"
+
+            output.write(f"- {opts_str}: {help_text}\n")
+        output.write("\n")
+
+
+def generate_agents_md_reference_files() -> None:
+    """Generate separate reference files."""
+    resources_dir = Path(__file__).parent.parent / "src" / "uipath" / "_resources"
+
+    sdk_reference_path = resources_dir / "SDK_REFERENCE.md"
+    cli_reference_path = resources_dir / "CLI_REFERENCE.md"
+
+    api_docs = generate_quick_api_docs()
+    cli_docs = generate_cli_docs()
+    service_cli_docs = generate_service_cli_docs()
+
+    with open(sdk_reference_path, "w", encoding="utf-8") as f:
+        f.write(api_docs.lstrip("\n"))
+
+    with open(cli_reference_path, "w", encoding="utf-8") as f:
+        f.write(cli_docs.lstrip("\n"))
+        if service_cli_docs:
+            f.write(service_cli_docs)
+
+
+def main():
+    """Main function."""
+    try:
+        generate_agents_md_reference_files()
+    except Exception as e:
+        print(f"Error updating AGENTS.md reference files: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/specs/README.md b/packages/uipath/specs/README.md
new file mode 100644
index 000000000..99499d778
--- /dev/null
+++ b/packages/uipath/specs/README.md
@@ -0,0 +1,27 @@
+# UiPath Configuration Specifications
+
+Complete specifications and JSON schemas for UiPath configuration files.
+
+## Files
+
+### `uipath.json` - Project Configuration
+Runtime options, design settings, packaging rules, and Python function entrypoints.
+
+- [Spec](uipath.spec.md) | [Schema](uipath.schema.json)
+
+### `bindings.json` - Resource Bindings
+Asset, process, bucket, index, and connection bindings.
+
+- [Spec](bindings.spec.md) | [Schema](bindings.schema.json)
+
+### `entry-points.json` - Entry Points
+Entry point definitions with JSON Schema-based input/output contracts.
+
+- [Spec](entry-points.spec.md) | [Schema](entry-points.schema.json)
+
+### `project.uiproj` - Project Metadata
+Project-level metadata for StudioWeb integration. Auto-generated and auto-updated by `uipath init`.
+
+- [Spec](uiproj.spec.md) | [Schema](uiproj.schema.json)
+
+
diff --git a/packages/uipath/specs/bindings.schema.json b/packages/uipath/specs/bindings.schema.json
new file mode 100644
index 000000000..c373294f0
--- /dev/null
+++ b/packages/uipath/specs/bindings.schema.json
@@ -0,0 +1,160 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/bindings",
+  "title": "UiPath Resources Configuration",
+  "description": "Configuration file for UiPath resource bindings including assets, processes, buckets, indexes, and connections",
+  "type": "object",
+  "required": [
+    "version",
+    "resources"
+  ],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Reference to this JSON schema for editor support"
+    },
+    "version": {
+      "type": "string",
+      "description": "Configuration version",
+      "enum": [
+        "2.0"
+      ],
+      "default": "2.0"
+    },
+    "resources": {
+      "type": "array",
+      "description": "Array of resource bindings",
+      "items": {
+        "type": "object",
+        "required": [
+          "resource",
+          "key",
+          "value"
+        ],
+        "properties": {
+          "resource": {
+            "type": "string",
+            "description": "Type of resource",
+            "enum": [
+              "asset",
+              "process",
+              "bucket",
+              "index",
+              "app",
+              "connection"
+            ]
+          },
+          "key": {
+            "type": "string",
+            "description": "Unique key for the resource, typically in format 'name.folder_path' or 'connection_key'"
+          },
+          "value": {
+            "type": "object",
+            "description": "Resource configuration values",
+            "oneOf": [
+              {
+                "title": "Asset/Process/Bucket/App/Index Value",
+                "properties": {
+                  "name": {
+                    "$ref": "#/definitions/propertyDefinition",
+                    "description": "Resource name configuration"
+                  },
+                  "folderPath": {
+                    "$ref": "#/definitions/propertyDefinition",
+                    "description": "Folder path configuration"
+                  }
+                },
+                "required": [
+                  "name",
+                  "folderPath"
+                ],
+                "additionalProperties": false
+              },
+              {
+                "title": "Connection Value",
+                "properties": {
+                  "ConnectionId": {
+                    "$ref": "#/definitions/propertyDefinition",
+                    "description": "Connection ID configuration"
+                  }
+                },
+                "required": [
+                  "ConnectionId"
+                ],
+                "additionalProperties": false
+              }
+            ]
+          },
+          "metadata": {
+            "type": "object",
+            "description": "Additional metadata for the resource binding",
+            "properties": {
+              "ActivityName": {
+                "type": "string",
+                "description": "Name of the activity associated with this resource",
+                "examples": [
+                  "retrieve_async",
+                  "invoke_async"
+                ]
+              },
+              "BindingsVersion": {
+                "type": "string",
+                "description": "Version of the bindings schema",
+                "default": "2.2"
+              },
+              "DisplayLabel": {
+                "type": "string",
+                "description": "Display label for the resource",
+                "examples": [
+                  "FullName"
+                ]
+              },
+              "Connector": {
+                "type": "string",
+                "description": "Connector type (for connection resources)"
+              },
+              "UseConnectionService": {
+                "type": "string",
+                "description": "Whether to use connection service",
+                "enum": [
+                  "True",
+                  "False"
+                ]
+              }
+            },
+            "additionalProperties": true
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "propertyDefinition": {
+      "type": "object",
+      "description": "Property configuration with default value and expression support",
+      "required": [
+        "defaultValue",
+        "isExpression",
+        "displayName"
+      ],
+      "properties": {
+        "defaultValue": {
+          "type": "string",
+          "description": "Default value for this property"
+        },
+        "isExpression": {
+          "type": "boolean",
+          "description": "Whether the value is an expression",
+          "default": false
+        },
+        "displayName": {
+          "type": "string",
+          "description": "Display name for this property in the UI"
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}
diff --git a/packages/uipath/specs/bindings.spec.md b/packages/uipath/specs/bindings.spec.md
new file mode 100644
index 000000000..6fecf2f70
--- /dev/null
+++ b/packages/uipath/specs/bindings.spec.md
@@ -0,0 +1,529 @@
+# UiPath Resources Configuration Specification
+
+## Overview
+
+The resources configuration file defines bindings for UiPath resources including assets, processes, buckets, indexes, apps and connections. This file enables declarative configuration of resource references used throughout your UiPath project.
+
+**File Name:** `bindings.json`
+
+---
+
+## File Structure
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/bindings",
+  "version": "2.0",
+  "resources": [
+    { ... },
+    { ... }
+  ]
+}
+```
+
+---
+
+## Top-Level Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `$schema` | `string` | No | Reference to JSON schema for IDE support |
+| `version` | `string` | Yes | Configuration version (currently `"2.0"`) |
+| `resources` | `array` | Yes | Array of resource binding definitions |
+
+---
+
+## Resource Types
+
+The configuration supports multiple resource types:
+
+1. **asset** - Orchestrator assets
+2. **process** - Workflow processes
+3. **bucket** - Storage buckets
+4. **index** - Search indexes
+5. **apps** - Action center apps
+6. **connection** - External connections
+
+
+---
+
+## Resource Structure
+
+Each resource in the `resources` array has the following structure:
+
+```json
+{
+  "resource": "asset|process|bucket|index|connection",
+  "key": "unique_key",
+  "value": { ... },
+  "metadata": { ... }
+}
+```
+
+### Common Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `resource` | `string` | Yes | Resource type (one of the five types) |
+| `key` | `string` | Yes | Unique identifier for this resource |
+| `value` | `object` | Yes | Resource-specific configuration |
+| `metadata` | `object` | No | Additional metadata for the binding |
+
+---
+
+## Resource-Specific Configurations
+
+### 1. Asset
+
+Assets are configuration values stored in Orchestrator.
+
+**Key Format:** `asset_name.folder_key`
+
+**Example:**
+
+```json
+{
+  "resource": "asset",
+  "key": "DatabaseConnectionString.Production",
+  "value": {
+    "name": {
+      "defaultValue": "DatabaseConnectionString",
+      "isExpression": false,
+      "displayName": "Name"
+    },
+    "folderPath": {
+      "defaultValue": "Production",
+      "isExpression": false,
+      "displayName": "Folder Path"
+    }
+  },
+  "metadata": {
+    "ActivityName": "retrieve_async",
+    "BindingsVersion": "2.2",
+    "DisplayLabel": "FullName"
+  }
+}
+```
+
+**Common Metadata:**
+- `ActivityName`: Typically `"retrieve_async"`
+- `BindingsVersion`: `"2.2"`
+- `DisplayLabel`: `"FullName"`
+
+---
+
+### 2. Process
+
+Processes are workflow definitions that can be invoked.
+
+**Key Format:** `process_name.folder_path`
+
+**Example:**
+
+```json
+{
+  "resource": "process",
+  "key": "DataProcessingWorkflow.Shared",
+  "value": {
+    "name": {
+      "defaultValue": "DataProcessingWorkflow",
+      "isExpression": false,
+      "displayName": "Name"
+    },
+    "folderPath": {
+      "defaultValue": "Shared",
+      "isExpression": false,
+      "displayName": "Folder Path"
+    }
+  },
+  "metadata": {
+    "ActivityName": "invoke_async",
+    "BindingsVersion": "2.2",
+    "DisplayLabel": "FullName"
+  }
+}
+```
+
+**Common Metadata:**
+- `ActivityName`: Typically `"invoke_async"`
+- `BindingsVersion`: `"2.2"`
+- `DisplayLabel`: `"FullName"`
+
+---
+
+### 3. Bucket
+
+Buckets are storage containers for files and data.
+
+**Key Format:** `bucket_name.folder_path`
+
+**Example:**
+
+```json
+{
+  "resource": "bucket",
+  "key": "DocumentStorage.Finance",
+  "value": {
+    "name": {
+      "defaultValue": "DocumentStorage",
+      "isExpression": false,
+      "displayName": "Name"
+    },
+    "folderPath": {
+      "defaultValue": "Finance",
+      "isExpression": false,
+      "displayName": "Folder Path"
+    }
+  },
+  "metadata": {
+    "ActivityName": "retrieve_async",
+    "BindingsVersion": "2.2",
+    "DisplayLabel": "FullName"
+  }
+}
+```
+
+**Common Metadata:**
+- `ActivityName`: Typically `"retrieve_async"`
+- `BindingsVersion`: `"2.2"`
+- `DisplayLabel`: `"FullName"`
+
+---
+
+### 4. Index
+
+Indexes are used for search and query operations.
+
+**Key Format:** `index_name.folder_path`
+
+**Example:**
+
+```json
+{
+  "resource": "index",
+  "key": "CustomerIndex.CRM",
+  "value": {
+    "name": {
+      "defaultValue": "CustomerIndex",
+      "isExpression": false,
+      "displayName": "Name"
+    },
+    "folderPath": {
+      "defaultValue": "CRM",
+      "isExpression": false,
+      "displayName": "Folder Path"
+    }
+  },
+  "metadata": {
+    "ActivityName": "retrieve_async",
+    "BindingsVersion": "2.2",
+    "DisplayLabel": "FullName"
+  }
+}
+```
+
+**Common Metadata:**
+- `ActivityName`: Typically `"retrieve_async"`
+- `BindingsVersion`: `"2.2"`
+- `DisplayLabel`: `"FullName"`
+
+---
+### 5. App
+
+Apps are used to create Human In The Loop tasks and escalations.
+
+**Key Format:** `app_name.app_folder_path`
+
+**Example:**
+
+```json
+ {
+    "resource": "app",
+    "key": "app_name.app_folder_path",
+    "value": {
+        "name": {
+            "defaultValue": "app_name",
+            "isExpression": false,
+            "displayName": "App Name"
+        },
+        "folderPath": {
+            "defaultValue": "app_folder_path",
+            "isExpression": false,
+            "displayName": "App Folder Path"
+        }
+    },
+    "metadata": {
+        "ActivityName": "create_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "app_name"
+    }
+}
+```
+
+**Common Metadata:**
+- `ActivityName`: Typically `"retrieve_async"`
+- `BindingsVersion`: `"2.2"`
+- `DisplayLabel`: `"FullName"`
+
+---
+
+### 6. Connection
+
+Connections define external system integrations.
+
+**Key Format:** `connection_key` (no folder path)
+
+**Example:**
+
+```json
+{
+  "resource": "connection",
+  "key": "SalesforceAPI",
+  "value": {
+    "ConnectionId": {
+      "defaultValue": "SalesforceAPI",
+      "isExpression": false,
+      "displayName": "Connection"
+    }
+  },
+  "metadata": {
+    "BindingsVersion": "2.2",
+    "Connector": "Salesforce",
+    "UseConnectionService": "True"
+  }
+}
+```
+
+**Connection-Specific Metadata:**
+- `BindingsVersion`: `"2.2"`
+- `Connector`: The type of connector (e.g., `"Salesforce"`, `"SAP"`, `""` for custom)
+- `UseConnectionService`: `"True"` or `"False"`
+
+**Note:** Connections do NOT have an `ActivityName` or `DisplayLabel` in metadata.
+
+---
+
+## Value Object Structure
+
+### For Assets, Processes, Buckets, Apps and Indexes
+
+```json
+{
+  "name": {
+    "defaultValue": "resource_name",
+    "isExpression": false,
+    "displayName": "Name"
+  },
+  "folderPath": {
+    "defaultValue": "folder_path",
+    "isExpression": false,
+    "displayName": "Folder Path"
+  }
+}
+```
+
+### For Connections
+
+```json
+{
+  "ConnectionId": {
+    "defaultValue": "connection_key",
+    "isExpression": false,
+    "displayName": "Connection"
+  }
+}
+```
+
+### Property Definition Fields
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `defaultValue` | `string` | Yes | The default value for this property |
+| `isExpression` | `boolean` | Yes | Whether the value is a dynamic expression (usually `false`) |
+| `displayName` | `string` | Yes | Human-readable name shown in UI |
+
+---
+
+## Metadata Object
+
+Metadata provides additional context about the resource binding.
+
+### Common Metadata Fields
+
+| Field | Type | Description | Applicable To |
+|-------|------|-------------|---------------|
+| `ActivityName` | `string` | Activity used to access the resource | asset, process, bucket, index |
+| `BindingsVersion` | `string` | Version of the bindings schema | All resources |
+| `DisplayLabel` | `string` | Label format for display | asset, process, bucket, index |
+| `Connector` | `string` | Type of connector | connection |
+| `UseConnectionService` | `string` | Whether to use connection service | connection |
+
+---
+
+## Complete Example
+
+```json
+{
+    "$schema": "https://cloud.uipath.com/draft/2024-12/bindings",
+    "version": "2.0",
+    "resources": [
+        {
+            "resource": "asset",
+            "key": "APIKey.Production",
+            "value": {
+                "name": {
+                    "defaultValue": "APIKey",
+                    "isExpression": false,
+                    "displayName": "Name"
+                },
+                "folderPath": {
+                    "defaultValue": "Production",
+                    "isExpression": false,
+                    "displayName": "Folder Path"
+                }
+            },
+            "metadata": {
+                "ActivityName": "retrieve_async",
+                "BindingsVersion": "2.2",
+                "DisplayLabel": "FullName"
+            }
+        },
+        {
+            "resource": "process",
+            "key": "InvoiceProcessing.Finance",
+            "value": {
+                "name": {
+                    "defaultValue": "InvoiceProcessing",
+                    "isExpression": false,
+                    "displayName": "Name"
+                },
+                "folderPath": {
+                    "defaultValue": "Finance",
+                    "isExpression": false,
+                    "displayName": "Folder Path"
+                }
+            },
+            "metadata": {
+                "ActivityName": "invoke_async",
+                "BindingsVersion": "2.2",
+                "DisplayLabel": "FullName"
+            }
+        },
+        {
+            "resource": "bucket",
+            "key": "InvoiceStorage.Finance",
+            "value": {
+                "name": {
+                    "defaultValue": "InvoiceStorage",
+                    "isExpression": false,
+                    "displayName": "Name"
+                },
+                "folderPath": {
+                    "defaultValue": "Finance",
+                    "isExpression": false,
+                    "displayName": "Folder Path"
+                }
+            },
+            "metadata": {
+                "ActivityName": "retrieve_async",
+                "BindingsVersion": "2.2",
+                "DisplayLabel": "FullName"
+            }
+        },
+        {
+            "resource": "index",
+            "key": "VendorIndex.Finance",
+            "value": {
+                "name": {
+                    "defaultValue": "VendorIndex",
+                    "isExpression": false,
+                    "displayName": "Name"
+                },
+                "folderPath": {
+                    "defaultValue": "Finance",
+                    "isExpression": false,
+                    "displayName": "Folder Path"
+                }
+            },
+            "metadata": {
+                "ActivityName": "retrieve_async",
+                "BindingsVersion": "2.2",
+                "DisplayLabel": "FullName"
+            }
+        },
+        {
+            "resource": "app",
+            "key": "app_name.app_folder_path",
+            "value": {
+                "name": {
+                    "defaultValue": "app_name",
+                    "isExpression": false,
+                    "displayName": "App Name"
+                },
+                "folderPath": {
+                    "defaultValue": "app_folder_path",
+                    "isExpression": false,
+                    "displayName": "App Folder Path"
+                }
+            },
+            "metadata": {
+                "ActivityName": "create_async",
+                "BindingsVersion": "2.2",
+                "DisplayLabel": "app_name"
+            }
+        },
+        {
+            "resource": "connection",
+            "key": "SalesforceAPI",
+            "value": {
+                "ConnectionId": {
+                    "defaultValue": "SalesforceAPI",
+                    "isExpression": false,
+                    "displayName": "Connection"
+                }
+            },
+            "metadata": {
+                "BindingsVersion": "2.2",
+                "Connector": "Salesforce",
+                "UseConnectionService": "True"
+            }
+        }
+    ]
+}
+```
+---
+
+## JSON Schema Definition
+
+The complete JSON Schema is available in `resources.schema.json`:
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/bindings",
+  "title": "UiPath Resources Configuration",
+  "description": "Configuration file for UiPath resource bindings",
+  "type": "object",
+  "required": ["version", "resources"],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Reference to this JSON schema for editor support"
+    },
+    "version": {
+      "type": "string",
+      "description": "Configuration version",
+      "enum": ["2.0"],
+      "default": "2.0"
+    },
+    "resources": {
+      "type": "array",
+      "description": "Array of resource bindings",
+      "items": { ... }
+    }
+  }
+}
+```
+
+See `bindings.schema.json` for the complete definition with all nested structures.
+
diff --git a/packages/uipath/specs/entry-points.schema.json b/packages/uipath/specs/entry-points.schema.json
new file mode 100644
index 000000000..f6417ad96
--- /dev/null
+++ b/packages/uipath/specs/entry-points.schema.json
@@ -0,0 +1,67 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/entry-point",
+  "title": "UiPath Entrypoints Configuration",
+  "description": "Configuration file for UiPath entrypoints with input/output schemas",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "const": "https://cloud.uipath.com/draft/2024-12/entry-point"
+    },
+    "$id": {
+      "type": "string"
+    },
+    "entryPoints": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "uniqueId": {
+            "type": "string",
+            "format": "uuid"
+          },
+          "filePath": {
+            "type": "string"
+          },
+          "displayName": {
+            "type": "string",
+            "maxLength": 1024
+          },
+          "type": {
+            "type": "string"
+          },
+          "input": {
+            "anyOf": [
+              {
+                "$ref": "http://json-schema.org/draft-07/schema#"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "output": {
+            "anyOf": [
+              {
+                "$ref": "http://json-schema.org/draft-07/schema#"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": [
+          "uniqueId",
+          "filePath",
+          "type"
+        ]
+      }
+    }
+  },
+  "required": [
+    "$schema",
+    "entryPoints"
+  ]
+}
\ No newline at end of file
diff --git a/packages/uipath/specs/entry-points.spec.md b/packages/uipath/specs/entry-points.spec.md
new file mode 100644
index 000000000..4c4cb7560
--- /dev/null
+++ b/packages/uipath/specs/entry-points.spec.md
@@ -0,0 +1,159 @@
+# UiPath Entrypoints Configuration Specification
+
+## Overview
+
+The `entry-points.json` file defines entry points for UiPath projects with their input and output schemas. Each entry point represents a callable function, workflow or agent with a well-defined contract specified using JSON Schema.
+
+**File Name:** `entry-points.json`
+
+---
+
+## File Structure
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+  "entryPoints": [
+    { ... },
+    { ... }
+  ]
+}
+```
+
+---
+
+## Top-Level Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `$schema` | `string` | Yes | Schema URI for validation and IDE support |
+| `$id` | `string` | Yes | Identifier for this configuration file |
+| `entryPoints` | `array` | Yes | Array of entry point definitions |
+
+### Standard Values
+
+- **`$schema`**: `"https://cloud.uipath.com/draft/2024-12/entry-point"`
+
+---
+
+## Entry Point Structure
+
+Each entry point in the `entryPoints` array defines a callable endpoint with input/output contracts.
+
+### Entry Point Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `uniqueId` | `string` | Yes | UUID v4 identifier for this entry point |
+| `filePath` | `string` | Yes | Relative path to the file containing this entry point |
+| `type` | `string` | Yes | Type of entry point (e.g., `"agent"`, `"workflow"`, `"function"`) |
+| `displayName` | `string` | No | Human-readable name (max 1024 characters) |
+| `input` | `object\|null` | No | JSON Schema defining input parameters |
+| `output` | `object\|null` | No | JSON Schema defining output structure |
+
+---
+
+## Entry Point Types
+
+Common entry point types include:
+
+- **`agent`** - Agentic workflow
+- **`process`** - Standard workflow process
+- **`function`** - Pure function or utility
+
+---
+
+## Input/Output Schemas
+
+Both `input` and `output` use **JSON Schema (Draft 7)** to define their structure.
+
+### Schema Structure
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "propertyName": {
+      "type": "string|number|boolean|object|array",
+      "description": "Property description",
+      // Additional JSON Schema keywords
+    }
+  },
+  "required": ["propertyName"]
+}
+```
+
+### Supported Types
+
+- `string` - Text values
+- `number` - Numeric values (integer or float)
+- `integer` - Integer values only
+- `boolean` - True/false values
+- `object` - Nested objects
+- `array` - Lists of items
+- `null` - Null value
+
+### Common Schema Keywords
+
+| Keyword | Applicable To | Description |
+|---------|---------------|-------------|
+| `type` | All | Data type |
+| `description` | All | Human-readable description |
+| `default` | All | Default value |
+| `enum` | All | Allowed values |
+| `required` | object | Required property names |
+| `properties` | object | Object property definitions |
+| `items` | array | Array item schema |
+| `minimum` / `maximum` | number | Numeric bounds |
+| `minLength` / `maxLength` | string | String length constraints |
+| `pattern` | string | Regex pattern |
+| `format` | string | String format (e.g., `"email"`, `"date-time"`) |
+
+---
+
+## Complete Example
+
+### Simple Calculator Agent
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+  "entryPoints": [
+    {
+      "filePath": "main.py",
+      "uniqueId": "03934894-5380-46d7-950c-b4d468111125",
+      "type": "agent",
+      "displayName": "Calculator Agent",
+      "input": {
+        "type": "object",
+        "properties": {
+          "a": {
+            "type": "number",
+            "description": "First operand"
+          },
+          "b": {
+            "type": "number",
+            "description": "Second operand"
+          },
+          "operator": {
+            "type": "string",
+            "enum": ["+", "-", "*", "/", "random"],
+            "description": "Mathematical operation to perform"
+          }
+        },
+        "required": ["a", "b", "operator"]
+      },
+      "output": {
+        "type": "object",
+        "properties": {
+          "result": {
+            "type": "number",
+            "description": "Calculation result"
+          }
+        },
+        "required": ["result"]
+      }
+    }
+  ]
+}
+```
diff --git a/packages/uipath/specs/uipath.schema.json b/packages/uipath/specs/uipath.schema.json
new file mode 100644
index 000000000..2ee966e82
--- /dev/null
+++ b/packages/uipath/specs/uipath.schema.json
@@ -0,0 +1,97 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "title": "UiPath Configuration",
+  "description": "Configuration file for UiPath projects",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Reference to this JSON schema for editor support"
+    },
+    "id": {
+      "type": "string",
+      "format": "uuid",
+      "description": "Stable unique identifier for the project, minted once on the first 'uipath init' and preserved for its lifetime. Used as the package 'projectId' at pack time. Do not change it."
+    },
+    "runtimeOptions": {
+      "type": "object",
+      "description": "Runtime behavior configuration",
+      "properties": {
+        "isConversational": {
+          "type": "boolean",
+          "description": "Enable conversational mode for the runtime",
+          "default": false
+        }
+      },
+      "additionalProperties": true
+    },
+    "designOptions": {
+      "type": "object",
+      "description": "Design-time configuration and preferences",
+      "additionalProperties": true
+    },
+    "packOptions": {
+      "type": "object",
+      "description": "File inclusion and exclusion settings for packaging",
+      "properties": {
+        "fileExtensionsIncluded": {
+          "type": "array",
+          "description": "File extensions to include in the package",
+          "items": {
+            "type": "string",
+            "pattern": "^\\."
+          },
+          "default": [
+            ".py",
+            ".mermaid",
+            ".json",
+            ".yaml",
+            ".yml",
+            ".md"
+          ]
+        },
+        "filesIncluded": {
+          "type": "array",
+          "description": "Specific files to include in the package",
+          "items": {
+            "type": "string"
+          },
+          "default": [
+            "pyproject.toml"
+          ]
+        },
+        "filesExcluded": {
+          "type": "array",
+          "description": "Specific files to exclude from the package",
+          "items": {
+            "type": "string"
+          },
+          "default": []
+        },
+        "directoriesExcluded": {
+          "type": "array",
+          "description": "Directories to exclude from the package",
+          "items": {
+            "type": "string"
+          },
+          "default": []
+        },
+        "includeUvLock": {
+          "type": "boolean",
+          "description": "Whether to include uv.lock file in the package",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "functions": {
+      "type": "object",
+      "description": "Entrypoint definitions for pure Python scripts. Each key is an entrypoint name, and each value is a path in format 'file_path:function_name'",
+      "additionalProperties": {
+        "type": "string"
+      }
+    }
+  },
+  "additionalProperties": false
+}
\ No newline at end of file
diff --git a/packages/uipath/specs/uipath.spec.md b/packages/uipath/specs/uipath.spec.md
new file mode 100644
index 000000000..9679bf223
--- /dev/null
+++ b/packages/uipath/specs/uipath.spec.md
@@ -0,0 +1,322 @@
+# UiPath Configuration File Specification
+
+## Overview
+
+The `uipath.json` file is a configuration file for UiPath projects that defines runtime behavior, design preferences, packaging options, and Python function entrypoints.
+
+## File Structure
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "id": "00000000-0000-0000-0000-000000000000",
+  "runtimeOptions": { ... },
+  "designOptions": { ... },
+  "packOptions": { ... },
+  "functions": { ... }
+}
+```
+
+---
+
+## Configuration Sections
+
+### 1. `id`
+
+Stable unique identifier (GUID) for the project, minted once on the first `uipath init` and preserved for its lifetime. Used as the package `projectId` at pack time.
+
+**Properties:**
+
+| Property | Type | Required | Default | Description |
+|----------|------|----------|---------|-------------|
+| `id` | `string` (uuid) | No | minted on first `uipath init` | Stable identifier for the project. Do not change it. |
+
+> Do not change or remove `id`. It identifies your project consistently wherever it is deployed and run. Changing it makes the project look like a brand-new, unrelated one, so you lose the link to everything previously published and tracked under the old id. `uipath pack` rejects an `id` that is not a valid GUID.
+
+**Example:**
+
+```json
+{
+  "id": "00000000-0000-0000-0000-000000000001"
+}
+```
+
+---
+
+### 2. `runtimeOptions`
+
+Controls runtime behavior of your UiPath project.
+
+**Properties:**
+
+| Property | Type | Required | Default | Description |
+|----------|------|----------|---------|-------------|
+| `isConversational` | `boolean` | No | `false` | Enable conversational mode for the runtime |
+
+**Example:**
+
+```json
+{
+  "runtimeOptions": {
+    "isConversational": true
+  }
+}
+```
+
+---
+
+### 3. `designOptions`
+
+Design-time configuration and preferences.
+
+**Example:**
+
+```json
+{
+  "designOptions": {
+  }
+}
+```
+
+---
+
+### 4. `packOptions`
+
+Controls which files and directories are included or excluded when packaging your project.
+
+**Properties:**
+
+| Property | Type | Required | Default | Description |
+|----------|------|----------|---------|-------------|
+| `fileExtensionsIncluded` | `string[]` | No | `[".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]` | File extensions to include in the package |
+| `filesIncluded` | `string[]` | No | `["pyproject.toml"]` | Specific files to always include |
+| `filesExcluded` | `string[]` | No | `[]` | Specific files to exclude |
+| `directoriesExcluded` | `string[]` | No | `[]` | Directories to exclude from packaging |
+| `includeUvLock` | `boolean` | No | `false` | Whether to include `uv.lock` file |
+
+**Example:**
+
+```json
+{
+  "packOptions": {
+    "fileExtensionsIncluded": [".py", ".yaml", ".md"],
+    "filesIncluded": ["pyproject.toml"],
+    "filesExcluded": ["secret.env"],
+    "directoriesExcluded": ["tests", "venv"],
+    "includeUvLock": true
+  }
+}
+```
+
+---
+
+### 5. `functions`
+
+Defines entrypoints for pure Python scripts. Each key is a friendly name for the entrypoint, and each value specifies the file path and function name.
+
+**Format:**
+
+```
+"entrypoint_name": "path/to/file.py:function_name"
+```
+
+**Properties:**
+
+- Keys: Any string (entrypoint name)
+- Values: String in format `file_path:function_name`
+
+**Example:**
+
+```json
+{
+  "functions": {
+    "main": "src/main.py:main",
+    "process": "src/graph.py:run",
+    "generateReport": "src/reporting.py:generate_report",
+    "cleanup": "scripts/cleanup.py:cleanup_resources"
+  }
+}
+```
+
+**Rules:**
+
+- File paths are relative to the project root
+- Function names must match the actual Python function name
+- The colon (`:`) separates the file path from the function name
+
+---
+
+## Complete Example
+
+```json
+{
+  "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "id": "00000000-0000-0000-0000-000000000001",
+  "runtimeOptions": {
+    "isConversational": false
+  },
+  "designOptions": {},
+  "packOptions": {
+    "fileExtensionsIncluded": [".py", ".json", ".yaml", ".md"],
+    "filesIncluded": ["pyproject.toml", "README.md"],
+    "filesExcluded": ["secret.env", ".env.local"],
+    "directoriesExcluded": ["venv"],
+    "includeUvLock": true
+  },
+  "functions": {
+    "main": "src/main.py:main",
+    "process": "src/graph.py:run",
+    "generateReport": "src/reporting.py:generate_report"
+  }
+}
+```
+
+---
+
+## Python Integration
+
+### Loading Configuration with Defaults
+
+```python
+import json
+from pathlib import Path
+
+def load_config(config_path="uipath.json"):
+    """Load uipath.json with sensible defaults if file doesn't exist."""
+
+    # Default configuration
+    default_config = {
+        "runtimeOptions": {
+            "isConversational": False
+        },
+        "designOptions": {},
+        "packOptions": {
+            "fileExtensionsIncluded": [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"],
+            "filesIncluded": ["pyproject.toml"],
+            "filesExcluded": [],
+            "directoriesExcluded": [],
+            "includeUvLock": False
+        },
+        "functions": {}
+    }
+
+    # Try to load user's config
+    config_file = Path(config_path)
+    if not config_file.exists():
+        return default_config
+
+    try:
+        with open(config_file, 'r') as f:
+            user_config = json.load(f)
+
+        # Merge with defaults (user config takes precedence)
+        config = default_config.copy()
+        for key in user_config:
+            if key in config and isinstance(config[key], dict):
+                config[key].update(user_config[key])
+            else:
+                config[key] = user_config[key]
+
+        return config
+
+    except json.JSONDecodeError as e:
+        print(f"Warning: Invalid JSON in {config_path}: {e}")
+        return default_config
+```
+
+---
+
+## JSON Schema Definition
+
+The complete JSON Schema is available in `uipath.schema.json`:
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/uipath",
+  "title": "UiPath Configuration",
+  "description": "Configuration file for UiPath projects",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Reference to this JSON schema for editor support"
+    },
+    "id": {
+      "type": "string",
+      "format": "uuid",
+      "description": "Stable unique identifier for the project, minted once on the first 'uipath init' and preserved for its lifetime. Used as the package 'projectId' at pack time. Do not change it."
+    },
+    "runtimeOptions": {
+      "type": "object",
+      "description": "Runtime behavior configuration",
+      "properties": {
+        "isConversational": {
+          "type": "boolean",
+          "description": "Enable conversational mode for the runtime",
+          "default": false
+        }
+      },
+      "additionalProperties": true
+    },
+    "designOptions": {
+      "type": "object",
+      "description": "Design-time configuration and preferences",
+      "additionalProperties": true
+    },
+    "packOptions": {
+      "type": "object",
+      "description": "File inclusion and exclusion settings for packaging",
+      "properties": {
+        "fileExtensionsIncluded": {
+          "type": "array",
+          "description": "File extensions to include in the package",
+          "items": {
+            "type": "string",
+            "pattern": "^\\."
+          },
+          "default": [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]
+        },
+        "filesIncluded": {
+          "type": "array",
+          "description": "Specific files to include in the package",
+          "items": {
+            "type": "string"
+          },
+          "default": ["pyproject.toml"]
+        },
+        "filesExcluded": {
+          "type": "array",
+          "description": "Specific files to exclude from the package",
+          "items": {
+            "type": "string"
+          },
+          "default": []
+        },
+        "directoriesExcluded": {
+          "type": "array",
+          "description": "Directories to exclude from the package",
+          "items": {
+            "type": "string"
+          },
+          "default": []
+        },
+        "includeUvLock": {
+          "type": "boolean",
+          "description": "Whether to include uv.lock file in the package",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "functions": {
+      "type": "object",
+      "description": "Entrypoint definitions for pure Python scripts. Each key is an entrypoint name, and each value is a path in format 'file_path:function_name'",
+      "additionalProperties": {
+        "type": "string"
+      }
+    }
+  },
+  "additionalProperties": false
+}
+```
diff --git a/packages/uipath/specs/uiproj.schema.json b/packages/uipath/specs/uiproj.schema.json
new file mode 100644
index 000000000..89c28de7e
--- /dev/null
+++ b/packages/uipath/specs/uiproj.schema.json
@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://cloud.uipath.com/draft/2024-12/uiproj",
+  "title": "UiPath Project Configuration",
+  "description": "Project-level metadata for UiPath coded automation projects, used by StudioWeb",
+  "type": "object",
+  "required": ["ProjectType", "Name", "MainFile"],
+  "properties": {
+    "ProjectType": {
+      "type": "string",
+      "description": "The type of project, determined from uipath.json entrypoints",
+      "enum": ["Agent", "Function"]
+    },
+    "Name": {
+      "type": "string",
+      "description": "Project name, sourced from pyproject.toml [project].name"
+    },
+    "Description": {
+      "type": ["string", "null"],
+      "description": "Project description, sourced from pyproject.toml [project].description"
+    },
+    "MainFile": {
+      "type": ["string", "null"],
+      "description": "Main file path. Required by StudioWeb but not used for coded agents",
+      "default": null
+    }
+  },
+  "additionalProperties": false
+}
diff --git a/packages/uipath/specs/uiproj.spec.md b/packages/uipath/specs/uiproj.spec.md
new file mode 100644
index 000000000..7bf993e4e
--- /dev/null
+++ b/packages/uipath/specs/uiproj.spec.md
@@ -0,0 +1,78 @@
+# UiPath Project Configuration Specification
+
+## Overview
+
+The `project.uiproj` file defines project-level metadata for UiPath coded projects. It is used by StudioWeb to identify the project type, name, and description. This file is auto-generated and auto-updated by `uipath init`.
+
+**File Name:** `project.uiproj`
+
+---
+
+## File Structure
+
+```json
+{
+  "ProjectType": "Agent",
+  "Name": "my-project",
+  "Description": "Project description",
+  "MainFile": null
+}
+```
+
+---
+
+## Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `ProjectType` | `string` | Yes | The type of project: `"Agent"` or `"Function"` |
+| `Name` | `string` | Yes | Project name, taken from `pyproject.toml` `[project].name` |
+| `Description` | `string\|null` | No | Project description, taken from `pyproject.toml` `[project].description` |
+| `MainFile` | `string\|null` | Yes | Main file path. Required by StudioWeb but not used for coded agents; always `null` for coded projects |
+
+---
+
+## ProjectType
+
+The `ProjectType` is determined automatically from the entrypoints defined in `uipath.json`:
+
+- **`"Agent"`** — when all entrypoints are declared under the `"agents"` key
+- **`"Function"`** — when at least one entrypoint is declared under the `"functions"` key, or when no entrypoints exist
+
+If `uipath.json` contains both `"agents"` and `"functions"` (mixed types), a warning is emitted and the type defaults to the first entrypoint's type.
+
+If the project type changes between runs of `uipath init` (e.g., an existing `project.uiproj` has `"Agent"` but the current entrypoints are all functions), a warning is displayed.
+
+---
+
+## Lifecycle
+
+- **Created by:** `uipath init` (when `project.uiproj` does not exist)
+- **Updated by:** `uipath init` (when `project.uiproj` already exists)
+- **Consumed by:** StudioWeb for project integration
+
+---
+
+## Complete Examples
+
+### Agent Project
+
+```json
+{
+  "ProjectType": "Agent",
+  "Name": "invoice-processor",
+  "Description": "An agent that processes invoices using DU",
+  "MainFile": null
+}
+```
+
+### Function Project
+
+```json
+{
+  "ProjectType": "Function",
+  "Name": "calculator",
+  "Description": "A simple calculator function",
+  "MainFile": null
+}
+```
diff --git a/src/uipath/_cli/README.md b/packages/uipath/src/uipath/_cli/README.md
similarity index 100%
rename from src/uipath/_cli/README.md
rename to packages/uipath/src/uipath/_cli/README.md
diff --git a/packages/uipath/src/uipath/_cli/__init__.py b/packages/uipath/src/uipath/_cli/__init__.py
new file mode 100644
index 000000000..d8d3a8a46
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/__init__.py
@@ -0,0 +1,218 @@
+import importlib.metadata
+import os
+import sys
+
+import click
+from dotenv import load_dotenv
+
+from uipath._cli._utils._context import CliContext
+from uipath._utils._logs import setup_logging
+from uipath._utils.constants import DOTENV_FILE
+
+# Windows console uses codepages (e.g. cp1252) that can't encode Unicode
+# characters used by Rich spinners (Braille) and emoji output.
+# When piped (not a TTY), keep the system encoding so the parent process
+# can decode our output, but use errors="replace" to avoid write-side crashes.
+if sys.platform == "win32":
+    for _stream in (sys.stdout, sys.stderr):
+        if hasattr(_stream, "reconfigure"):
+            if _stream.isatty():
+                _stream.reconfigure(encoding="utf-8")
+            else:
+                _stream.reconfigure(errors="replace")
+# DO NOT ADD HEAVY IMPORTS HERE
+#
+# Every import at the top of this file runs on EVERY command.
+# Yes, even `--version`. Yes, even `--help`.
+#
+# We spent hours getting startup from 1.7s → 0.5s.
+# If you add `import pandas` here, I will find you.
+
+_LAZY_COMMANDS = {
+    "new": "cli_new",
+    "init": "cli_init",
+    "pack": "cli_pack",
+    "publish": "cli_publish",
+    "run": "cli_run",
+    "deploy": "cli_deploy",
+    "auth": "cli_auth",
+    "invoke": "cli_invoke",
+    "push": "cli_push",
+    "pull": "cli_pull",
+    "eval": "cli_eval",
+    "dev": "cli_dev",
+    "add": "cli_add",
+    "server": "cli_server",
+    "register": "cli_register",
+    "debug": "cli_debug",
+    "list-models": "cli_list_models",
+    "assets": "services.cli_assets",
+    "buckets": "services.cli_buckets",
+    "context-grounding": "services.cli_context_grounding",
+}
+
+_RUNTIME_COMMANDS = {"init", "dev", "run", "eval", "debug", "server"}
+
+_runtime_initialized = False
+
+
+def _ensure_runtime_initialized():
+    """Initialize runtime factories once, only when needed."""
+    global _runtime_initialized
+    if _runtime_initialized:
+        return
+    _runtime_initialized = True
+
+    from uipath._cli.runtimes import load_runtime_factories
+    from uipath.functions import register_default_runtime_factory
+
+    register_default_runtime_factory()
+    load_runtime_factories()
+
+
+def _load_command(name: str):
+    """Load a CLI command by name."""
+    if name not in _LAZY_COMMANDS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    if name in _RUNTIME_COMMANDS:
+        _ensure_runtime_initialized()
+
+    module_name = _LAZY_COMMANDS[name]
+    mod = __import__(f"uipath._cli.{module_name}", fromlist=[name])
+    # CLI names may use hyphens (e.g. "context-grounding") but Python
+    # attribute names use underscores; convert before getattr.
+    attr_name = name.replace("-", "_")
+    return getattr(mod, attr_name)
+
+
+def __getattr__(name: str):
+    """Lazy load CLI commands for mkdocs-click compatibility."""
+    return _load_command(name)
+
+
+def add_cwd_to_path():
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+
+def load_environment_variables():
+    load_dotenv(dotenv_path=os.path.join(os.getcwd(), DOTENV_FILE), override=True)
+
+
+load_environment_variables()
+add_cwd_to_path()
+
+
+def _get_safe_version() -> str:
+    """Get the version of the uipath package."""
+    try:
+        version = importlib.metadata.version("uipath")
+        return version
+    except importlib.metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def _get_format_from_argv() -> str | None:
+    for i, arg in enumerate(sys.argv):
+        if arg == "--format" and i + 1 < len(sys.argv):
+            return sys.argv[i + 1]
+        elif arg.startswith("--format="):
+            return arg.split("=", 1)[1]
+    return None
+
+
+class LazyGroup(click.Group):
+    """Lazy-load commands only when invoked."""
+
+    def list_commands(self, ctx):
+        return sorted(_LAZY_COMMANDS.keys())
+
+    def get_command(self, ctx, cmd_name):
+        if cmd_name in _LAZY_COMMANDS:
+            return _load_command(cmd_name)
+        return None
+
+    def format_help(self, ctx, formatter):
+        format_value = _get_format_from_argv()
+
+        if format_value == "json":
+            from uipath._cli._utils._help_json import get_help_json
+
+            json_output = get_help_json(self, ctx, _get_safe_version())
+            click.echo(json_output)
+            ctx.exit(0)
+        else:
+            super().format_help(ctx, formatter)
+
+
+@click.command(cls=LazyGroup, invoke_without_command=True)
+@click.version_option(
+    _get_safe_version(),
+    prog_name="uipath",
+    message="%(prog)s version %(version)s",
+)
+@click.option(
+    "-lv",
+    is_flag=True,
+    help="Display the current version of uipath-langchain.",
+)
+@click.option(
+    "-v",
+    is_flag=True,
+    help="Display the current version of uipath.",
+)
+@click.option(
+    "--format",
+    type=click.Choice(["json", "table", "csv"]),
+    default="table",
+    help="Output format for commands",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug logging and show stack traces",
+)
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    lv: bool,
+    v: bool,
+    format: str,
+    debug: bool,
+) -> None:
+    """UiPath CLI - Automate everything.
+
+    \b
+    Examples:
+        uipath new my-project
+        uipath dev
+        uipath deploy
+        uipath buckets list --folder-path "Shared"
+    """  # noqa: D301
+    ctx.obj = CliContext(
+        output_format=format,
+        debug=debug,
+    )
+
+    setup_logging(should_debug=debug)
+
+    if lv:
+        try:
+            version = importlib.metadata.version("uipath-langchain")
+            click.echo(f"uipath-langchain version {version}")
+        except importlib.metadata.PackageNotFoundError:
+            click.echo("uipath-langchain is not installed", err=True)
+            sys.exit(1)
+    if v:
+        try:
+            version = importlib.metadata.version("uipath")
+            click.echo(f"uipath version {version}")
+        except importlib.metadata.PackageNotFoundError:
+            click.echo("uipath is not installed", err=True)
+            sys.exit(1)
+
+    # Show help if no command was provided (matches docker, kubectl, git behavior)
+    if ctx.invoked_subcommand is None and not lv and not v:
+        click.echo(ctx.get_help())
diff --git a/src/uipath/_cli/_auth/_auth_server.py b/packages/uipath/src/uipath/_cli/_auth/_auth_server.py
similarity index 54%
rename from src/uipath/_cli/_auth/_auth_server.py
rename to packages/uipath/src/uipath/_cli/_auth/_auth_server.py
index 823ca242b..673d545b3 100644
--- a/src/uipath/_cli/_auth/_auth_server.py
+++ b/packages/uipath/src/uipath/_cli/_auth/_auth_server.py
@@ -1,30 +1,19 @@
+import asyncio
+import hmac
 import http.server
 import json
 import os
 import socketserver
+import threading
 import time
 
-import click
-from dotenv import load_dotenv
-
-from ._oidc_utils import get_auth_config
-
-load_dotenv(override=True)
-
 # Server port
 PORT = 6234
 
 
-# Custom exception for token received
-class TokenReceivedSignal(Exception):
-    """Exception raised when a token is successfully received."""
-
-    def __init__(self, token_data):
-        self.token_data = token_data
-        super().__init__("Token received successfully")
-
-
-def make_request_handler_class(state, code_verifier, token_callback, domain):
+def make_request_handler_class(
+    state, code_verifier, token_callback, domain, redirect_uri, client_id
+):
     class SimpleHTTPSRequestHandler(http.server.SimpleHTTPRequestHandler):
         """Simple HTTPS request handler that serves static files."""
 
@@ -32,12 +21,60 @@ def log_message(self, format, *args) -> None:
             # do nothing
             pass
 
+        def _is_host_allowed(self) -> bool:
+            """Reject requests whose Host header is not loopback.
+
+            Defends against DNS rebinding since the legitimate flow
+            always lands on localhost.
+            """
+            host = self.headers.get("Host", "")
+            hostname = host.rsplit(":", 1)[0]
+            return hostname in ("localhost", "127.0.0.1")
+
+        def _handle_host_error(self) -> bool:
+            """Return True if a host error was identified and handled (403)."""
+            if not self._is_host_allowed():
+                self.send_error(403, "Invalid host")
+                return True
+            return False
+
+        def _state_is_valid(self) -> bool:
+            """Validate the OAuth state supplied."""
+            received = self.headers.get("X-Auth-State", "")
+            return hmac.compare_digest(received, state)
+
+        def _handle_state_error(self) -> bool:
+            """Return True if a state error was identified and handled (403)."""
+            if not self._state_is_valid():
+                self.send_error(403, "Invalid or missing state")
+                return True
+            return False
+
+        def _read_json_body(self):
+            """Read and parse the JSON request body.
+
+            Returns the decoded object, or None if the
+            expected headers are missing or body is malformed.
+            """
+            try:
+                content_length = int(self.headers["Content-Length"])
+                post_data = self.rfile.read(content_length)
+                return json.loads(post_data.decode("utf-8"))
+            except (KeyError, TypeError, ValueError):
+                self.send_error(400, "Invalid request")
+                return None
+
         def do_POST(self):
             """Handle POST requests to /set_token."""
+            if self._handle_host_error():
+                return
             if self.path == "/set_token":
-                content_length = int(self.headers["Content-Length"])
-                post_data = self.rfile.read(content_length)
-                token_data = json.loads(post_data.decode("utf-8"))
+                if self._handle_state_error():
+                    return
+
+                token_data = self._read_json_body()
+                if token_data is None:
+                    return
 
                 self.send_response(200)
                 self.end_headers()
@@ -47,9 +84,13 @@ def do_POST(self):
 
                 token_callback(token_data)
             elif self.path == "/log":
-                content_length = int(self.headers["Content-Length"])
-                post_data = self.rfile.read(content_length)
-                logs = json.loads(post_data.decode("utf-8"))
+                if self._handle_state_error():
+                    return
+
+                logs = self._read_json_body()
+                if logs is None:
+                    return
+
                 # Write logs to .uipath/.error_log file
                 uipath_dir = os.path.join(os.getcwd(), ".uipath")
                 os.makedirs(uipath_dir, exist_ok=True)
@@ -69,22 +110,18 @@ def do_POST(self):
 
         def do_GET(self):
             """Handle GET requests by serving index.html."""
+            if self._handle_host_error():
+                return
             # Always serve index.html regardless of the path
             try:
                 index_path = os.path.join(os.path.dirname(__file__), "index.html")
                 with open(index_path, "r") as f:
                     content = f.read()
 
-                # Get the redirect URI from auth config
-                auth_config = get_auth_config()
-                redirect_uri = auth_config["redirect_uri"]
-
                 content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)
                 content = content.replace("__PY_REPLACE_CODE_VERIFIER__", code_verifier)
                 content = content.replace("__PY_REPLACE_REDIRECT_URI__", redirect_uri)
-                content = content.replace(
-                    "__PY_REPLACE_CLIENT_ID__", auth_config["client_id"]
-                )
+                content = content.replace("__PY_REPLACE_CLIENT_ID__", client_id)
                 content = content.replace("__PY_REPLACE_DOMAIN__", domain)
 
                 self.send_response(200)
@@ -95,31 +132,27 @@ def do_GET(self):
             except FileNotFoundError:
                 self.send_error(404, "File not found")
 
-        def end_headers(self):
-            self.send_header("Access-Control-Allow-Origin", "*")
-            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-            self.send_header("Access-Control-Allow-Headers", "Content-Type")
-            super().end_headers()
-
-        def do_OPTIONS(self):
-            self.send_response(200)
-            self.end_headers()
-
     return SimpleHTTPSRequestHandler
 
 
 class HTTPServer:
-    def __init__(self, port=6234):
+    def __init__(self, port=6234, redirect_uri=None, client_id=None):
         """Initialize HTTP server with configurable parameters.
 
         Args:
             port (int, optional): Port number to run the server on. Defaults to 6234.
+            redirect_uri (str, optional): OAuth redirect URI. Defaults to None.
+            client_id (str, optional): OAuth client ID. Defaults to None.
         """
         self.current_path = os.path.dirname(os.path.abspath(__file__))
         self.port = port
-        self.httpd = None
+        self.redirect_uri = redirect_uri
+        self.client_id = client_id
+        self.httpd: socketserver.TCPServer | None = None
         self.token_data = None
         self.should_shutdown = False
+        self.token_received_event: asyncio.Event | None = None
+        self.loop = None
 
     def token_received_callback(self, token_data):
         """Callback for when a token is received.
@@ -128,7 +161,8 @@ def token_received_callback(self, token_data):
             token_data (dict): The received token data.
         """
         self.token_data = token_data
-        self.should_shutdown = True
+        if self.token_received_event and self.loop:
+            self.loop.call_soon_threadsafe(self.token_received_event.set)
 
     def create_server(self, state, code_verifier, domain):
         """Create and configure the HTTP server.
@@ -144,12 +178,26 @@ def create_server(self, state, code_verifier, domain):
         # Create server with address reuse
         socketserver.TCPServer.allow_reuse_address = True
         handler = make_request_handler_class(
-            state, code_verifier, self.token_received_callback, domain
+            state,
+            code_verifier,
+            self.token_received_callback,
+            domain,
+            self.redirect_uri,
+            self.client_id,
         )
-        self.httpd = socketserver.TCPServer(("", self.port), handler)
+        self.httpd = socketserver.TCPServer(("127.0.0.1", self.port), handler)
         return self.httpd
 
-    def start(self, state, code_verifier, domain):
+    def _run_server(self):
+        """Run server loop in thread."""
+        try:
+            while not self.should_shutdown and self.httpd:
+                self.httpd.handle_request()
+        except Exception:
+            # Server might be closed, that's fine
+            pass
+
+    async def start(self, state, code_verifier, domain):
         """Start the server.
 
         Args:
@@ -163,12 +211,16 @@ def start(self, state, code_verifier, domain):
         if not self.httpd:
             self.create_server(state, code_verifier, domain)
 
+        self.token_received_event = asyncio.Event()
+        self.loop = asyncio.get_event_loop()
+
+        # Run server in daemon thread
+        server_thread = threading.Thread(target=self._run_server, daemon=True)
+        server_thread.start()
+
         try:
-            if self.httpd:
-                while not self.should_shutdown:
-                    self.httpd.handle_request()
-        except KeyboardInterrupt:
-            click.echo("Process interrupted by user")
+            # Wait indefinitely for token received event or interrupt
+            await self.token_received_event.wait()
         finally:
             self.stop()
 
@@ -176,6 +228,7 @@ def start(self, state, code_verifier, domain):
 
     def stop(self):
         """Stop the server gracefully and cleanup resources."""
+        self.should_shutdown = True
         if self.httpd:
             self.httpd.server_close()
             self.httpd = None
diff --git a/packages/uipath/src/uipath/_cli/_auth/_auth_service.py b/packages/uipath/src/uipath/_cli/_auth/_auth_service.py
new file mode 100644
index 000000000..c89968683
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_auth_service.py
@@ -0,0 +1,153 @@
+import os
+import webbrowser
+
+from uipath._cli._auth._auth_server import HTTPServer
+from uipath._cli._auth._auth_session import AuthSession
+from uipath._cli._auth._oidc_utils import OidcUtils
+from uipath._cli._auth._url_utils import extract_org_tenant, resolve_domain
+from uipath._cli._auth._utils import get_parsed_token_data
+from uipath._cli._utils._console import ConsoleLogger
+from uipath._utils._auth import update_env_file
+from uipath.platform.common import ExternalApplicationService, TokenData
+
+from ._utils import update_auth_file
+
+
+class AuthService:
+    def __init__(
+        self,
+        environment: str | None,
+        *,
+        force: bool,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        base_url: str | None = None,
+        tenant: str | None = None,
+        scope: str | None = None,
+    ):
+        self._force = force
+        self._console = ConsoleLogger()
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._base_url = base_url
+        self._tenant = tenant
+        self._domain = resolve_domain(self._base_url, environment)
+        self._scope = scope
+
+    async def authenticate(self) -> None:
+        if self._client_id and self._client_secret:
+            await self._authenticate_client_credentials()
+            return
+
+        await self._authenticate_authorization_code()
+
+    async def _authenticate_client_credentials(self):
+        if not (self._client_id and self._client_secret):
+            raise ValueError("Client ID and Client Secret must be provided.")
+        external_app_service = ExternalApplicationService(self._base_url)
+        token_data = await external_app_service.get_token_data_async(
+            self._client_id,
+            self._client_secret,
+            self._scope,
+        )
+
+        organization_name, tenant_name = extract_org_tenant(
+            external_app_service._base_url
+        )
+        if not (organization_name and tenant_name):
+            self._console.warning(
+                "--base-url should include both organization and tenant, "
+                "e.g., 'https://cloud.uipath.com/{organization}/{tenant}'."
+            )
+
+        env_vars = {
+            "UIPATH_ACCESS_TOKEN": token_data.access_token,
+            "UIPATH_URL": external_app_service._base_url,
+            "UIPATH_ORGANIZATION_ID": get_parsed_token_data(token_data).get("prt_id"),
+        }
+
+        if tenant_name:
+            self._tenant = tenant_name
+            auth_session = AuthSession(self._domain)
+            auth_session.update_token_data(token_data)
+            tenant_info = await auth_session.resolve_tenant_info(self._tenant)
+            env_vars["UIPATH_TENANT_ID"] = tenant_info["tenant_id"]
+        else:
+            self._console.warning("Could not extract tenant from --base-url.")
+        update_env_file(env_vars)
+
+    async def _authenticate_authorization_code(self) -> None:
+        auth_session = AuthSession(self._domain)
+        if not self._force and await self._can_reuse_existing_token(auth_session):
+            return
+
+        token_data = await self._perform_oauth_flow()
+        auth_session.update_token_data(token_data)
+        update_auth_file(token_data)
+
+        tenant_info = await auth_session.resolve_tenant_info(self._tenant)
+        uipath_url = await auth_session.build_tenant_url()
+
+        update_env_file(
+            {
+                "UIPATH_ACCESS_TOKEN": token_data.access_token,
+                "UIPATH_URL": uipath_url,
+                "UIPATH_TENANT_ID": tenant_info["tenant_id"],
+                "UIPATH_ORGANIZATION_ID": tenant_info["organization_id"],
+            }
+        )
+
+        try:
+            from uipath.platform import UiPath
+
+            await UiPath(
+                base_url=uipath_url, secret=token_data.access_token
+            ).orchestrator_setup.enable_first_run_async()
+        except Exception as e:
+            self._console.error(
+                f"Could not prepare the environment. Please try again. {e}"
+            )
+
+    async def _can_reuse_existing_token(self, auth_session: AuthSession) -> bool:
+        if (
+            os.getenv("UIPATH_URL")
+            and os.getenv("UIPATH_TENANT_ID")
+            and os.getenv("UIPATH_ORGANIZATION_ID")
+        ):
+            try:
+                await auth_session.ensure_valid_token()
+                return True
+            except Exception:
+                self._console.error(
+                    "Authentication token is invalid. Please reauthenticate using the '--force' flag."
+                )
+        return False
+
+    async def _perform_oauth_flow(self) -> TokenData:
+        auth_config = await OidcUtils.get_auth_config(self._domain)
+        auth_url, code_verifier, state = OidcUtils.get_auth_url(
+            self._domain, auth_config
+        )
+        self._open_browser(auth_url)
+
+        server = HTTPServer(
+            port=auth_config["port"],
+            redirect_uri=auth_config["redirect_uri"],
+            client_id=auth_config["client_id"],
+        )
+        token_data = await server.start(state, code_verifier, self._domain)
+
+        if not token_data:
+            self._console.error(
+                "Authentication failed. Please try again.",
+            )
+
+        return TokenData.model_validate(token_data)
+
+    def _open_browser(self, url: str) -> None:
+        # Try to open browser. Always print the fallback link.
+        webbrowser.open(url, new=1)
+        self._console.link(
+            "If a browser window did not open, please open the following URL in your browser:",
+            url,
+        )
diff --git a/packages/uipath/src/uipath/_cli/_auth/_auth_session.py b/packages/uipath/src/uipath/_cli/_auth/_auth_session.py
new file mode 100644
index 000000000..cd51a583b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_auth_session.py
@@ -0,0 +1,159 @@
+import time
+
+import click
+
+from uipath.platform.common import TokenData
+from uipath.platform.identity import IdentityService
+from uipath.platform.portal import (
+    PortalService as PlatformPortalService,
+)
+from uipath.platform.portal import (
+    TenantsAndOrganizationInfoResponse,
+)
+from uipath.runtime.errors import (
+    UiPathErrorCategory,
+    UiPathErrorCode,
+    UiPathRuntimeError,
+)
+
+from ..._utils._auth import update_env_file
+from .._utils._console import ConsoleLogger
+from ._oidc_utils import OidcUtils
+from ._utils import get_auth_data, get_parsed_token_data, update_auth_file
+
+
+class AuthSession:
+    """Holds auth state (tokens, tenant selection) across the CLI auth flow."""
+
+    access_token: str | None = None
+    prt_id: str | None = None
+    domain: str
+    selected_tenant: str | None = None
+
+    _tenants_and_organizations: TenantsAndOrganizationInfoResponse | None = None
+
+    def __init__(
+        self,
+        domain: str,
+        access_token: str | None = None,
+        prt_id: str | None = None,
+    ):
+        self.domain = domain
+        self.access_token = access_token
+        self.prt_id = prt_id
+        self._console = ConsoleLogger()
+        self._identity_service = IdentityService(domain)
+        self._portal_service = PlatformPortalService(domain)
+        self._tenants_and_organizations = None
+
+    def update_token_data(self, token_data: TokenData):
+        self.access_token = token_data.access_token
+        self.prt_id = get_parsed_token_data(token_data).get("prt_id")
+
+    async def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
+        if self._tenants_and_organizations is not None:
+            return self._tenants_and_organizations
+
+        if not self.prt_id or not self.access_token:
+            raise ValueError(
+                "Cannot fetch tenants: prt_id and access_token must be set."
+            )
+
+        try:
+            self._tenants_and_organizations = (
+                await self._portal_service.get_tenants_and_organizations_async(
+                    prt_id=self.prt_id,
+                    access_token=self.access_token,
+                )
+            )
+            return self._tenants_and_organizations
+        except Exception as e:
+            resp = getattr(e, "response", None)
+            if resp is not None and resp.status_code == 401:
+                self._console.error("Unauthorized")
+            self._console.error(f"Failed to get tenants and organizations: {e}")
+
+    async def refresh_access_token(self, refresh_token: str) -> TokenData:
+        client_id = (await OidcUtils.get_auth_config(self.domain))["client_id"]
+        try:
+            return await self._identity_service.refresh_access_token_async(
+                refresh_token=refresh_token,
+                client_id=client_id,
+            )
+        except Exception as e:
+            resp = getattr(e, "response", None)
+            if resp is not None and resp.status_code == 401:
+                self._console.error("Unauthorized")
+            status = resp.status_code if resp is not None else str(e)
+            self._console.error(f"Failed to refresh token: {status}")
+
+    async def ensure_valid_token(self):
+        auth_data = get_auth_data()
+        claims = get_parsed_token_data(auth_data)
+        exp = claims.get("exp")
+
+        def finalize(token_data: TokenData):
+            self.update_token_data(token_data)
+            update_auth_file(token_data)
+            update_env_file({"UIPATH_ACCESS_TOKEN": token_data.access_token})
+
+        if exp is not None and float(exp) > time.time():
+            finalize(auth_data)
+            return
+
+        refresh_token = auth_data.refresh_token
+        if not refresh_token:
+            raise UiPathRuntimeError(
+                UiPathErrorCode.EXECUTION_ERROR,
+                "No refresh token found",
+                "The refresh token could not be retrieved. Please retry authenticating.",
+                UiPathErrorCategory.SYSTEM,
+            )
+
+        token_data = await self.refresh_access_token(refresh_token)
+        finalize(token_data)
+
+    def _set_tenant(self, tenant, organization):
+        self.selected_tenant = tenant.name
+        return {"tenant_id": tenant.id, "organization_id": organization.id}
+
+    async def _select_tenant(self):
+        data = await self.get_tenants_and_organizations()
+        organization = data.organization
+        tenants = data.tenants
+
+        tenant_names = [t.name for t in tenants]
+
+        self._console.display_options(tenant_names, "Select tenant:")
+        tenant_idx = (
+            0
+            if len(tenant_names) == 1
+            else self._console.prompt("Select tenant number", type=int)
+        )
+
+        tenant = data.tenants[tenant_idx]
+
+        self._console.info(f"Selected tenant: {click.style(tenant.name, fg='cyan')}")
+        return self._set_tenant(tenant, organization)
+
+    async def _retrieve_tenant(self, tenant_name: str):
+        data = await self.get_tenants_and_organizations()
+        organization = data.organization
+        tenants = data.tenants
+
+        tenant = next((t for t in tenants if t.name == tenant_name), None)
+        if not tenant:
+            self._console.error(f"Tenant '{tenant_name}' not found.")
+            raise Exception(f"Tenant '{tenant_name}' not found.")
+
+        return self._set_tenant(tenant, organization)
+
+    async def resolve_tenant_info(self, tenant: str | None = None):
+        if tenant:
+            return await self._retrieve_tenant(tenant)
+        return await self._select_tenant()
+
+    async def build_tenant_url(self) -> str:
+        data = await self.get_tenants_and_organizations()
+        organization_name = data.organization.name
+        return f"{self.domain}/{organization_name}/{self.selected_tenant}"
diff --git a/packages/uipath/src/uipath/_cli/_auth/_models.py b/packages/uipath/src/uipath/_cli/_auth/_models.py
new file mode 100644
index 000000000..fe8581884
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_models.py
@@ -0,0 +1,19 @@
+from typing import TypedDict
+
+
+class AuthConfig(TypedDict):
+    """TypedDict for auth_config.json structure."""
+
+    client_id: str
+    port: int
+    redirect_uri: str
+    scope: str
+
+
+class AccessTokenData(TypedDict):
+    """TypedDict for access token data structure."""
+
+    sub: str
+    prt_id: str
+    client_id: str
+    exp: float
diff --git a/packages/uipath/src/uipath/_cli/_auth/_oidc_utils.py b/packages/uipath/src/uipath/_cli/_auth/_oidc_utils.py
new file mode 100644
index 000000000..bb0be816a
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_oidc_utils.py
@@ -0,0 +1,176 @@
+import base64
+import hashlib
+import json
+import os
+from urllib.parse import urlencode, urlparse
+
+from uipath.platform.orchestrator import get_server_info_async
+
+from .._utils._console import ConsoleLogger
+from ._models import AuthConfig
+from ._url_utils import build_service_url
+
+
+def generate_code_verifier_and_challenge():
+    """Generate PKCE code verifier and challenge."""
+    code_verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+    code_challenge_bytes = hashlib.sha256(code_verifier.encode("utf-8")).digest()
+    code_challenge = (
+        base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8").rstrip("=")
+    )
+
+    return code_verifier, code_challenge
+
+
+def get_state_param() -> str:
+    return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+
+def _is_cloud_domain(domain: str) -> bool:
+    """Check if the domain is a cloud domain (alpha, staging, or cloud.uipath.com).
+
+    Args:
+        domain: The domain string (e.g., 'https://alpha.uipath.com')
+
+    Returns:
+        True if it's a cloud domain, False otherwise
+    """
+    parsed = urlparse(domain)
+    netloc = parsed.netloc.lower()
+    return netloc in [
+        "alpha.uipath.com",
+        "staging.uipath.com",
+        "cloud.uipath.com",
+    ]
+
+
+async def _select_config_file(domain: str) -> str:
+    """Select the appropriate auth config file based on domain and version.
+
+    Logic:
+    1. If domain is alpha/staging/cloud.uipath.com -> use auth_config_cloud.json
+    2. Otherwise, fetch server info from API
+    3. If deployment is not 'ServiceFabric' (cloud deployment) -> use auth_config_cloud.json
+    4. If version starts with '25.10' (AS release 25.10) -> use auth_config_25_10.json
+    5. If version starts with '26.3' (AS release 25.10.2) -> use auth_config_25_10_2.json
+    6. Otherwise (unknown version) -> use auth_config_25_10_2.json
+
+    Args:
+        domain: The UiPath domain
+
+    Returns:
+        The filename of the config to use
+    """
+    # Check if it's a known cloud domain
+    if _is_cloud_domain(domain):
+        return "auth_config_cloud.json"
+
+    # Fetch full server info
+    info = await get_server_info_async(domain)
+
+    # Non-ServiceFabric deployments are cloud
+    if info is None or info.get("deployment") != "ServiceFabric":
+        return "auth_config_cloud.json"
+
+    version = info.get("version") or ""
+
+    # Check if version is 25.10.* (AS release 25.10)
+    if version.startswith("25.10"):
+        return "auth_config_25_10.json"
+
+    # Check if version is 26.3.* (AS release 25.10.2)
+    if version.startswith("26.3"):
+        return "auth_config_25_10_2.json"
+
+    # Default fallback to latest AS release config
+    return "auth_config_25_10_2.json"
+
+
+class OidcUtils:
+    _console = ConsoleLogger()
+
+    @classmethod
+    def _find_free_port(cls, candidates: list[int]):
+        from socket import AF_INET, SOCK_STREAM, error, socket
+
+        def is_free(port: int) -> bool:
+            with socket(AF_INET, SOCK_STREAM) as s:
+                try:
+                    s.bind(("localhost", port))
+                    return True
+                except error:
+                    return False
+
+        return next((p for p in candidates if is_free(p)), None)
+
+    @classmethod
+    async def get_auth_config(cls, domain: str | None = None) -> AuthConfig:
+        """Get the appropriate auth configuration based on domain.
+
+        Args:
+            domain: The UiPath domain (e.g., 'https://cloud.uipath.com').
+                   If None, uses default auth_config_cloud.json
+
+        Returns:
+            AuthConfig with the appropriate configuration
+        """
+        # Select the appropriate config file based on domain
+        if domain:
+            config_file = await _select_config_file(domain)
+        else:
+            config_file = "auth_config_cloud.json"
+
+        config_path = os.path.join(os.path.dirname(__file__), config_file)
+        with open(config_path, "r") as f:
+            auth_config = json.load(f)
+
+        custom_port = os.getenv("UIPATH_AUTH_PORT")
+        candidates = [int(custom_port)] if custom_port else [8104, 8055, 42042]
+
+        port = cls._find_free_port(candidates)
+        if port is None:
+            ports_str = ", ".join(str(p) for p in candidates)
+            cls._console.error(
+                f"All configured ports ({ports_str}) are in use. Please close applications using these ports or configure different ports."
+            )
+
+        redirect_uri = auth_config["redirect_uri"].replace(
+            "__PY_REPLACE_PORT__", str(port)
+        )
+
+        return AuthConfig(
+            client_id=auth_config["client_id"],
+            redirect_uri=redirect_uri,
+            scope=auth_config["scope"],
+            port=port,
+        )
+
+    @classmethod
+    def get_auth_url(cls, domain: str, auth_config: AuthConfig) -> tuple[str, str, str]:
+        """Get the authorization URL for OAuth2 PKCE flow.
+
+        Args:
+            domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
+            auth_config (AuthConfig): The authentication configuration to use
+
+        Returns:
+            tuple[str, str]: A tuple containing:
+                - The authorization URL with query parameters
+                - The code verifier for PKCE flow
+        """
+        code_verifier, code_challenge = generate_code_verifier_and_challenge()
+        state = get_state_param()
+        query_params = {
+            "client_id": auth_config["client_id"],
+            "redirect_uri": auth_config["redirect_uri"],
+            "response_type": "code",
+            "scope": auth_config["scope"],
+            "state": state,
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        query_string = urlencode(query_params)
+        url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
+        return url, code_verifier, state
diff --git a/packages/uipath/src/uipath/_cli/_auth/_url_utils.py b/packages/uipath/src/uipath/_cli/_auth/_url_utils.py
new file mode 100644
index 000000000..844968762
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_url_utils.py
@@ -0,0 +1,82 @@
+import os
+from typing import Tuple
+from urllib.parse import urlparse
+
+from .._utils._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+def resolve_domain(base_url: str | None, environment: str | None) -> str:
+    """Resolve the UiPath domain, giving priority to base_url when valid.
+
+    Args:
+        base_url: The base URL explicitly provided.
+        environment: The environment name (e.g., 'alpha', 'staging', 'cloud').
+        force: Whether to ignore UIPATH_URL from environment variables when base_url is set.
+
+    Returns:
+        A valid base URL for UiPath services.
+    """
+    # If base_url is a real URL, prefer it
+    if base_url and base_url.startswith("http"):
+        parsed = urlparse(base_url)
+        domain = f"{parsed.scheme}://{parsed.netloc}"
+        if domain:
+            return domain
+
+    if environment is None:
+        uipath_url = os.getenv("UIPATH_URL")
+        if uipath_url:
+            parsed = urlparse(uipath_url)
+            if parsed.scheme and parsed.netloc:
+                domain = f"{parsed.scheme}://{parsed.netloc}"
+                return domain
+            else:
+                console.error(
+                    f"Malformed UIPATH_URL: '{uipath_url}'. "
+                    "Please ensure it includes scheme and netloc (e.g., 'https://cloud.uipath.com')."
+                )
+
+    # Otherwise, fall back to environment
+    return f"https://{environment or 'cloud'}.uipath.com"
+
+
+def build_service_url(domain: str, path: str) -> str:
+    """Build a service URL by combining the base URL with a path.
+
+    Args:
+        domain: The domain name
+        path: The path to append (should start with /)
+
+    Returns:
+        The complete service URL
+    """
+    return f"{domain}{path}"
+
+
+def extract_org_tenant(uipath_url: str) -> Tuple[str | None, str | None]:
+    """Extract organization and tenant from a UiPath URL.
+
+    Accepts values like:
+      - https://cloud.uipath.com/myOrg/myTenant
+      - https://alpha.uipath.com/myOrg/myTenant/anything_else
+      - cloud.uipath.com/myOrg/myTenant  (scheme will be assumed https)
+
+    Args:
+        uipath_url: The UiPath URL to parse
+
+    Returns:
+        A tuple of (organization, tenant) where:
+          - organization: 'myOrg' or None
+          - tenant: 'myTenant' or None
+
+    Example:
+        >>> extract_org_tenant('https://cloud.uipath.com/myOrg/myTenant')
+        ('myOrg', 'myTenant')
+    """
+    parsed = urlparse(uipath_url if "://" in uipath_url else f"https://{uipath_url}")
+    parts = [p for p in parsed.path.split("/") if p]
+    org = parts[0] if len(parts) >= 1 else None
+    tenant = parts[1] if len(parts) >= 2 else None
+    return org, tenant
diff --git a/packages/uipath/src/uipath/_cli/_auth/_utils.py b/packages/uipath/src/uipath/_cli/_auth/_utils.py
new file mode 100644
index 000000000..86f0cddc0
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/_utils.py
@@ -0,0 +1,28 @@
+import json
+import os
+from pathlib import Path
+
+from uipath.platform.common import TokenData
+
+from ..._utils._auth import parse_access_token
+from ._models import AccessTokenData
+
+
+def update_auth_file(token_data: TokenData):
+    os.makedirs(Path.cwd() / ".uipath", exist_ok=True)
+    auth_file = Path.cwd() / ".uipath" / ".auth.json"
+    with open(auth_file, "w") as f:
+        json.dump(token_data.model_dump(exclude_none=True), f)
+
+
+def get_auth_data() -> TokenData:
+    auth_file = Path.cwd() / ".uipath" / ".auth.json"
+    if not auth_file.exists():
+        raise Exception("No authentication file found")
+    return TokenData.model_validate(json.load(open(auth_file)))
+
+
+def get_parsed_token_data(token_data: TokenData | None = None) -> AccessTokenData:
+    if not token_data:
+        token_data = get_auth_data()
+    return parse_access_token(token_data.access_token)
diff --git a/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10.json b/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10.json
new file mode 100644
index 000000000..0716b1ea8
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10.json
@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access ProcessMining OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DocumentUnderstanding Du.Digitization.Api Du.Classification.Api Du.Extraction.Api Du.Validation.Api EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "port": 8104
+}
diff --git a/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10_2.json b/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10_2.json
new file mode 100644
index 000000000..0716b1ea8
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/auth_config_25_10_2.json
@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access ProcessMining OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DocumentUnderstanding Du.Digitization.Api Du.Classification.Api Du.Extraction.Api Du.Validation.Api EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "port": 8104
+}
diff --git a/packages/uipath/src/uipath/_cli/_auth/auth_config_cloud.json b/packages/uipath/src/uipath/_cli/_auth/auth_config_cloud.json
new file mode 100644
index 000000000..305c37254
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/auth_config_cloud.json
@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access ProcessMining OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DataServiceApiUserAccess DocumentUnderstanding Du.Digitization.Api Du.Classification.Api Du.Extraction.Api Du.Validation.Api EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets AutomationSolutions AT.TrackOperations Docs.GPT.Search",
+  "port": 8104
+}
diff --git a/packages/uipath/src/uipath/_cli/_auth/index.html b/packages/uipath/src/uipath/_cli/_auth/index.html
new file mode 100644
index 000000000..08f81d81b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_auth/index.html
@@ -0,0 +1,622 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>UiPath CLI Authentication</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+            background-color: rgb(241, 246, 248);
+            color: #24292e;
+            line-height: 1.5;
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .header {
+            background-color: #ffffff;
+            border-bottom: 1px solid #e1e4e8;
+            padding: 16px 0;
+        }
+
+        .header-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 16px;
+            display: flex;
+            align-items: center;
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin: 32px 0;
+            font-size: 20px;
+            font-weight: 600;
+            color: #24292e;
+            text-decoration: none;
+        }
+
+        .logo-icon {
+            width: 120px;
+            height: 40px;
+            margin-right: 12px;
+        }
+
+        .container {
+            flex: 1;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 40px 16px;
+        }
+
+        .auth-card {
+            background: #ffffff;
+            border: 1px solid #e1e4e8;
+            border-radius: 6px;
+            padding: 32px;
+            max-width: 440px;
+            width: 100%;
+            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12), 0 1px 2px rgba(0, 0, 0, 0.24);
+        }
+
+        .auth-header {
+            text-align: center;
+            margin-bottom: 24px;
+        }
+
+        .auth-title {
+            font-size: 24px;
+            font-weight: 600;
+            color: #24292e;
+            margin-bottom: 8px;
+        }
+
+        .auth-subtitle {
+            font-size: 16px;
+            color: #586069;
+        }
+
+        .status-section {
+            margin: 24px 0;
+        }
+
+        .status-indicator {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-bottom: 16px;
+        }
+
+        .spinner {
+            width: 24px;
+            height: 24px;
+            border: 3px solid #e1e4e8;
+            border-top: 3px solid #fa4616;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            display: none;
+        }
+
+        @keyframes spin {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        .success-check {
+            width: 48px;
+            height: 48px;
+            background-color: #28a745;
+            border-radius: 50%;
+            display: none;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-size: 24px;
+            font-weight: bold;
+        }
+
+        .error-x {
+            width: 48px;
+            height: 48px;
+            background-color: #d73a49;
+            border-radius: 50%;
+            display: none;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-size: 20px;
+            font-weight: bold;
+        }
+
+        .status-message {
+            text-align: center;
+            font-size: 16px;
+            color: #586069;
+            margin-bottom: 16px;
+        }
+
+        .status-message.success {
+            color: #28a745;
+        }
+
+        .status-message.error {
+            color: #d73a49;
+        }
+
+        .progress-container {
+            margin: 16px 0;
+        }
+
+        .progress-bar {
+            width: 100%;
+            height: 8px;
+            background-color: #e1e4e8;
+            border-radius: 4px;
+            overflow: hidden;
+        }
+
+        .progress-fill {
+            height: 100%;
+            background-color: #fa4616;
+            border-radius: 4px;
+            width: 0%;
+            transition: width 0.3s ease;
+        }
+
+        .info-box {
+            background-color: #f6f8fa;
+            border: 1px solid #e1e4e8;
+            border-radius: 6px;
+            padding: 16px;
+            margin: 16px 0;
+            font-size: 14px;
+            color: #586069;
+            display: none;
+        }
+
+        .info-box.show {
+            display: block;
+        }
+
+        .info-box strong {
+            color: #24292e;
+        }
+
+        .action-buttons {
+            text-align: center;
+            margin-top: 24px;
+        }
+
+        .btn {
+            display: inline-block;
+            padding: 8px 16px;
+            font-size: 14px;
+            font-weight: 500;
+            line-height: 20px;
+            white-space: nowrap;
+            vertical-align: middle;
+            cursor: pointer;
+            border: 1px solid;
+            border-radius: 6px;
+            text-decoration: none;
+            transition: all 0.15s ease-in-out;
+        }
+
+        .btn-primary {
+            color: #ffffff;
+            background-color: #fa4616;
+            border-color: #fa4616;
+        }
+
+        .btn-primary:hover {
+            background-color: #e63e14;
+            border-color: #e63e14;
+        }
+
+        .btn-secondary {
+            color: #24292e;
+            background-color: #f6f8fa;
+            border-color: #e1e4e8;
+        }
+
+        .btn-secondary:hover {
+            background-color: #e1e4e8;
+            border-color: #d0d7de;
+        }
+
+        .debug-section {
+            margin-top: 24px;
+            border-top: 1px solid #e1e4e8;
+            padding-top: 16px;
+        }
+
+        .debug-toggle {
+            font-size: 12px;
+            color: #586069;
+            background: none;
+            border: none;
+            cursor: pointer;
+            text-decoration: underline;
+        }
+
+        .debug-toggle:hover {
+            color: #24292e;
+        }
+
+        .debug-log {
+            background-color: #f6f8fa;
+            border: 1px solid #e1e4e8;
+            border-radius: 6px;
+            padding: 12px;
+            margin-top: 8px;
+            font-family: 'SFMono-Regular', 'Consolas', 'Liberation Mono', 'Menlo', monospace;
+            font-size: 12px;
+            color: #24292e;
+            max-height: 200px;
+            overflow-y: auto;
+            white-space: pre-wrap;
+            display: none;
+        }
+
+        .debug-log.show {
+            display: block;
+        }
+
+        @media (max-width: 544px) {
+            .auth-card {
+                border: none;
+                box-shadow: none;
+                padding: 24px 16px;
+            }
+
+            .auth-title {
+                font-size: 20px;
+            }
+        }
+
+        /* Fade in animation */
+        .fade-in {
+            animation: fadeIn 0.3s ease-in;
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+    </style>
+</head>
+
+<body>
+
+
+    <main class="container">
+        <div class="auth-card fade-in">
+            <div class="logo">
+                <svg class="logo-icon" focusable="false" aria-hidden="false" role="img" viewBox="0 0 62 21" width="120"
+                    height="40" fill="none" xmlns="http://www.w3.org/2000/svg">
+                    <path
+                        d="M10.5847 6.01996H10.2875C9.51138 6.01996 9.0293 6.49219 9.0293 7.25215V13.3657C9.0293 16.2642 8.12889 17.4465 5.92142 17.4465C3.71394 17.4465 2.81351 16.2589 2.81351 13.3474V7.25216C2.81351 6.49219 2.33141 6.01996 1.55545 6.01996H1.2581C0.482103 6.01996 0 6.49219 0 7.25216V13.3657C0 17.7812 1.9923 20.02 5.92142 20.02C9.85054 20.02 11.8427 17.7812 11.8427 13.3657V7.25216C11.8427 6.49219 11.3606 6.01996 10.5847 6.01996Z"
+                        fill="#000000"></path>
+                    <path
+                        d="M15.3983 9.7298H15.152C14.3567 9.7298 13.8628 10.2204 13.8628 11.0098V18.74C13.8628 19.5294 14.3567 20.02 15.152 20.02H15.3983C16.1934 20.02 16.6874 19.5294 16.6874 18.74V11.0098C16.6874 10.2203 16.1934 9.7298 15.3983 9.7298Z"
+                        fill="#fa4616"></path>
+                    <path
+                        d="M18.8096 4.9445C17.0123 4.66045 15.594 3.26496 15.3053 1.49653C15.2999 1.46315 15.2559 1.46315 15.2504 1.49653C14.9618 3.26496 13.5435 4.66045 11.7462 4.9445C11.7122 4.94985 11.7122 4.99314 11.7462 4.99849C13.5435 5.28248 14.9618 6.67803 15.2504 8.44646C15.2559 8.47984 15.2999 8.47984 15.3053 8.44646C15.594 6.67803 17.0123 5.28248 18.8096 4.99849C18.8435 4.99314 18.8435 4.94985 18.8096 4.9445ZM17.0437 4.98499C16.1451 5.12699 15.4359 5.82476 15.2916 6.70898C15.2889 6.72567 15.2669 6.72567 15.2642 6.70898C15.1198 5.82476 14.4107 5.12699 13.512 4.98499C13.495 4.98231 13.495 4.96067 13.512 4.958C14.4107 4.81597 15.1198 4.11822 15.2642 3.23401C15.2669 3.21732 15.2889 3.21732 15.2916 3.23401C15.4359 4.11822 16.1451 4.81597 17.0437 4.958C17.0607 4.96067 17.0607 4.98231 17.0437 4.98499Z"
+                        fill="#fa4616"></path>
+                    <path
+                        d="M19.8865 2.18349C18.9878 2.32548 18.2787 3.02325 18.1343 3.90747C18.1316 3.92416 18.1096 3.92416 18.1069 3.90747C17.9626 3.02325 17.2534 2.32548 16.3548 2.18349C16.3378 2.18081 16.3378 2.15917 16.3548 2.15649C17.2534 2.01447 17.9626 1.31672 18.1069 0.432502C18.1096 0.41581 18.1316 0.41581 18.1343 0.432502C18.2787 1.31672 18.9878 2.01446 19.8865 2.15649C19.9035 2.15917 19.9035 2.18081 19.8865 2.18349Z"
+                        fill="#fa4616"></path>
+                    <path
+                        d="M22.8632 6.01996H20.1216C19.3373 6.01996 18.8501 6.49722 18.8501 7.26531V18.7746C18.8501 19.5427 19.3374 20.02 20.1216 20.02H20.4222C21.2064 20.02 21.6937 19.5427 21.6937 18.7746V16.0502H22.8819C27.6395 16.0502 29.5801 14.5973 29.5801 11.0351C29.5801 7.47291 27.6341 6.01996 22.8632 6.01996ZM26.6991 10.9983C26.6991 12.8309 25.8116 13.4493 23.1823 13.4493H21.6937V8.5657H23.1823C25.8116 8.5657 26.6991 9.17948 26.6991 10.9983Z"
+                        fill="#000000"></path>
+                    <path
+                        d="M40.1401 8.6104H39.9147C39.1305 8.6104 38.6433 9.08767 38.6433 9.85576V9.85735C37.8378 8.94386 36.5902 8.4082 35.1642 8.4082C33.7113 8.4082 32.3975 8.93097 31.4648 9.88042C30.4488 10.9143 29.9119 12.4066 29.9119 14.1957C29.9119 15.9926 30.452 17.4935 31.4739 18.536C32.4119 19.4929 33.7291 20.02 35.1829 20.02C36.5819 20.02 37.8388 19.4777 38.6443 18.5774C38.6443 18.5783 38.6444 18.8369 38.6444 18.8378C38.6705 19.5689 39.1522 20.02 39.9147 20.02H40.1401C40.9244 20.02 41.4117 19.5429 41.4117 18.7748V9.85576C41.4117 9.08768 40.9244 8.6104 40.1401 8.6104ZM38.6996 14.1957C38.6996 16.2973 37.5536 17.6029 35.7087 17.6029C33.8407 17.6029 32.6803 16.2973 32.6803 14.1957C32.6803 12.1053 33.8263 10.8068 35.6712 10.8068C37.5108 10.8068 38.6996 12.1371 38.6996 14.1957Z"
+                        fill="#000000"></path>
+                    <path
+                        d="M56.5101 8.41922C55.0376 8.41922 53.9872 8.99357 53.3294 9.7174V7.2661C53.3294 6.49753 52.8419 6.01996 52.0571 6.01996H51.8317C51.0469 6.01996 50.5593 6.49753 50.5593 7.2661V18.7738C50.5593 19.5424 51.0469 20.02 51.8317 20.02H52.0571C52.8419 20.02 53.3294 19.5424 53.3294 18.7738V14.1551C53.3294 11.1982 54.7693 10.8562 55.8525 10.8562C57.6713 10.8562 58.4131 11.7428 58.4131 13.916V18.7738C58.4131 19.5424 58.9007 20.02 59.6855 20.02H59.911C60.6957 20.02 61.1832 19.5424 61.1832 18.7738V13.7503C61.1832 10.163 59.6547 8.41922 56.5101 8.41922Z"
+                        fill="#000000"></path>
+                    <path
+                        d="M49.7629 18.6115C49.724 18.2411 49.4976 17.7119 48.4196 17.7119C47.1449 17.7119 46.5383 17.3228 46.5383 15.112V10.8563H48.4383C49.2218 10.8563 49.7086 10.421 49.7086 9.72061C49.7086 9.03146 49.2218 8.60325 48.4383 8.60325H46.5406V7.2661C46.5406 6.49753 46.0501 6.01996 45.2606 6.01996H45.0338C44.2443 6.01996 43.7538 6.49753 43.7538 7.2661V8.60325H43.317C42.626 8.60325 42.1968 9.03147 42.1968 9.72061C42.1968 10.421 42.6836 10.8563 43.4671 10.8563H43.7538V15.3513C43.7538 18.6237 45.0538 20.02 48.1007 20.02C48.1056 20.02 48.1106 20.0198 48.1155 20.0197C48.2927 20.0195 48.4824 20.0168 48.6757 19.9999C49.0598 19.9643 49.3503 19.8316 49.5392 19.6053C49.7274 19.38 49.8027 18.9843 49.7629 18.6115Z"
+                        fill="#000000"></path>
+                </svg>
+            </div>
+
+            <div class="auth-header">
+                <h1 class="auth-title" id="main-title">Authenticate CLI</h1>
+                <p class="auth-subtitle" id="subtitle">Completing authentication flow...</p>
+            </div>
+
+            <div class="status-section">
+                <div class="status-indicator">
+                    <div class="spinner" id="spinner"></div>
+                    <div class="success-check" id="success-check">&check;</div>
+                    <div class="error-x" id="error-x">&times;</div>
+                </div>
+
+                <div class="progress-container" id="progress-container">
+                    <div class="progress-bar">
+                        <div class="progress-fill" id="progress-fill"></div>
+                    </div>
+                </div>
+
+                <div class="status-message" id="status-message">
+                    Processing authentication request...
+                </div>
+            </div>
+
+            <div class="info-box" id="info-box">
+                <strong>Authenticating...</strong><br>
+                Securely exchanging authorization code for access tokens.
+            </div>
+
+            <div class="debug-section">
+                <button class="debug-toggle" onclick="toggleDebug()">Show debug info</button>
+                <div class="debug-log" id="debug-log"></div>
+            </div>
+        </div>
+    </main>
+
+    <script>
+        const baseUrl = '__PY_REPLACE_REDIRECT_URI__'.replace('/oidc/login', '');
+        const logs = [];
+        let debugMode = false;
+
+        // UI Helper Functions
+        function showSpinner() {
+            document.getElementById('spinner').style.display = 'block';
+            document.getElementById('progress-container').style.display = 'block';
+            updateProgress(20);
+        }
+
+        function hideSpinner() {
+            document.getElementById('spinner').style.display = 'none';
+        }
+
+        function showSuccess() {
+            hideSpinner();
+            document.getElementById('success-check').style.display = 'flex';
+            document.getElementById('progress-container').style.display = 'none';
+        }
+
+        function showError() {
+            hideSpinner();
+            document.getElementById('error-x').style.display = 'flex';
+            document.getElementById('progress-container').style.display = 'none';
+        }
+
+        function updateProgress(percent) {
+            document.getElementById('progress-fill').style.width = percent + '%';
+        }
+
+        function updateStatus(message, type = 'normal') {
+            const statusEl = document.getElementById('status-message');
+            statusEl.textContent = message;
+            statusEl.className = `status-message ${type}`;
+        }
+
+        function showInfoBox(content) {
+            const infoBox = document.getElementById('info-box');
+            infoBox.innerHTML = content;
+            infoBox.classList.add('show');
+        }
+
+        function hideInfoBox() {
+            document.getElementById('info-box').classList.remove('show');
+        }
+
+        function toggleDebug() {
+            debugMode = !debugMode;
+            const logEl = document.getElementById('debug-log');
+            const toggleBtn = document.querySelector('.debug-toggle');
+
+            if (debugMode) {
+                logEl.textContent = JSON.stringify(logs, null, 2);
+                logEl.classList.add('show');
+                toggleBtn.textContent = 'Hide debug info';
+            } else {
+                logEl.classList.remove('show');
+                toggleBtn.textContent = 'Show debug info';
+            }
+        }
+
+        function closeWindow() {
+            try {
+                window.open('', '_self', '');
+                window.close();
+            } catch (e) {
+                window.location.href = 'about:blank';
+            }
+        }
+
+        // Parse URL query parameters
+        function getQueryParams() {
+            const params = {};
+            const queryString = window.location.search;
+            const urlParams = new URLSearchParams(queryString);
+
+            for (const [key, value] of urlParams.entries()) {
+                params[key] = value;
+            }
+            return params;
+        }
+
+        // Exchange authorization code for tokens
+        async function exchangeCodeForToken(code, codeVerifier) {
+            try {
+                updateProgress(50);
+                updateStatus('Exchanging authorization code...');
+
+                const formData = new URLSearchParams();
+                formData.append('grant_type', 'authorization_code');
+                formData.append('code', code);
+                formData.append('redirect_uri', '__PY_REPLACE_REDIRECT_URI__');
+                formData.append('client_id', '__PY_REPLACE_CLIENT_ID__');
+                formData.append('code_verifier', codeVerifier);
+
+                const domainOrUrl = '__PY_REPLACE_DOMAIN__';
+                let tokenUrl;
+                if (domainOrUrl.startsWith('http')) {
+                    tokenUrl = `${domainOrUrl}/identity_/connect/token`;
+                } else {
+                    tokenUrl = `https://${domainOrUrl}.uipath.com/identity_/connect/token`;
+                }
+
+                const response = await fetch(tokenUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded'
+                    },
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Token request failed: ${response.status} ${response.statusText} - ${errorText}`);
+                }
+
+                const tokenData = await response.json();
+                updateProgress(80);
+                return tokenData;
+            } catch (error) {
+                console.error('Error exchanging code for token:', error);
+                logs.push({
+                    timestamp: new Date().toISOString(),
+                    message: 'Error exchanging code for token:',
+                    error: error.message
+                });
+                throw error;
+            }
+        }
+
+        async function delay(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+
+        async function sendLogs(logs) {
+            await fetch(`${baseUrl}/log`, {
+                method: 'POST',
+                headers: {
+                    'X-Auth-State': "__PY_REPLACE_EXPECTED_STATE__"
+                },
+                body: JSON.stringify(logs)
+            });
+        }
+
+        // Main authentication handler
+        async function handleAuthentication() {
+            const params = getQueryParams();
+            showSpinner();
+
+            logs.push({
+                timestamp: new Date().toISOString(),
+                message: 'Authentication started',
+                params: params
+            });
+
+            try {
+                if (params.code && params.state) {
+                    updateStatus('Validating authorization...');
+                    await delay(300);
+
+                    const codeVerifier = "__PY_REPLACE_CODE_VERIFIER__";
+                    const state = "__PY_REPLACE_EXPECTED_STATE__";
+
+                    if (!codeVerifier) {
+                        throw new Error('Code verifier not found');
+                    }
+
+                    if (!params.state || params.state != state) {
+                        throw new Error('Invalid state parameter');
+                    }
+
+                    updateProgress(30);
+                    const tokenData = await exchangeCodeForToken(params.code, codeVerifier);
+
+                    updateStatus('Sending credentials to CLI...');
+                    updateProgress(90);
+
+                    await sendLogs(logs);
+                    await fetch(`${baseUrl}/set_token`, {
+                        method: 'POST',
+                        headers: {
+                            'X-Auth-State': state
+                        },
+                        body: JSON.stringify(tokenData)
+                    });
+
+                    updateProgress(100);
+                    await delay(300);
+
+                    // Success state
+                    showSuccess();
+                    document.getElementById('main-title').textContent = 'Authentication Complete';
+                    document.getElementById('subtitle').textContent = 'Your CLI is now authenticated and ready to use';
+                    updateStatus('You can close this tab', 'success');
+
+                    // Auto-close after 3 seconds
+                    setTimeout(closeWindow, 3000);
+
+                    window.history.replaceState({}, document.title, window.location.pathname);
+
+                } else if (params.error) {
+                    throw new Error(`OAuth error: ${params.error} - ${params.error_description || 'Unknown error'}`);
+                } else {
+                    updateStatus('Waiting for authentication...');
+                    showInfoBox(`
+                        <strong>Waiting...</strong><br>
+                        Complete the authentication process to continue.
+                    `);
+                }
+            } catch (error) {
+                console.error('Authentication error:', error);
+                logs.push({
+                    timestamp: new Date().toISOString(),
+                    message: 'Authentication failed',
+                    error: error.message
+                });
+
+                await sendLogs(logs);
+
+                showError();
+                document.getElementById('main-title').textContent = 'Authentication Failed';
+                document.getElementById('subtitle').textContent = 'Unable to complete authentication';
+                updateStatus(error.message, 'error');
+
+                showInfoBox(`
+                    <strong>Error:</strong><br>
+                    ${error.message}<br><br>
+                    Please try running the authentication command again.
+                `);
+            }
+        }
+
+        // Start when page loads
+        document.addEventListener('DOMContentLoaded', handleAuthentication);
+    </script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/uipath/_cli/_auth/localhost.crt b/packages/uipath/src/uipath/_cli/_auth/localhost.crt
similarity index 100%
rename from src/uipath/_cli/_auth/localhost.crt
rename to packages/uipath/src/uipath/_cli/_auth/localhost.crt
diff --git a/src/uipath/_cli/_auth/localhost.key b/packages/uipath/src/uipath/_cli/_auth/localhost.key
similarity index 100%
rename from src/uipath/_cli/_auth/localhost.key
rename to packages/uipath/src/uipath/_cli/_auth/localhost.key
diff --git a/packages/uipath/src/uipath/_cli/_chat/_bridge.py b/packages/uipath/src/uipath/_cli/_chat/_bridge.py
new file mode 100644
index 000000000..442322e36
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_chat/_bridge.py
@@ -0,0 +1,558 @@
+"""Chat bridge implementations for conversational agents."""
+
+import asyncio
+import json
+import logging
+import os
+from typing import Any
+from urllib.parse import urlparse
+
+from uipath.core.chat import (
+    UiPathConversationErrorEvent,
+    UiPathConversationErrorStartEvent,
+    UiPathConversationEvent,
+    UiPathConversationExchangeEndEvent,
+    UiPathConversationExchangeEvent,
+    UiPathConversationExecutingToolCallEvent,
+    UiPathConversationMessageEvent,
+    UiPathConversationToolCallConfirmationEvent,
+    UiPathConversationToolCallEndEvent,
+    UiPathConversationToolCallEvent,
+)
+from uipath.core.triggers import UiPathResumeTrigger
+from uipath.runtime.chat import UiPathChatProtocol
+from uipath.runtime.context import UiPathRuntimeContext
+
+logger = logging.getLogger(__name__)
+
+
+class CASErrorId:
+    """Error IDs for the Conversational Agent Service (CAS), matching the Temporal backend."""
+
+    LICENSING = "AGENT_LICENSING_CONSUMPTION_VALIDATION_FAILED"
+    INCOMPLETE_RESPONSE = "AGENT_RESPONSE_IS_INCOMPLETE"
+    MAX_STEPS_REACHED = "AGENT_MAXIMUM_SEQUENTIAL_STEPS_REACHED"
+    INVALID_INPUT = "AGENT_INVALID_INPUT"
+    DEFAULT_ERROR = "AGENT_RUNTIME_ERROR"
+
+
+# User-facing messages for each CAS error ID, matching the Temporal backend.
+_CAS_ERROR_MESSAGES: dict[str, str] = {
+    CASErrorId.LICENSING: "Your action could not be completed. You've used all your units for this period. Please contact your administrator to add more units or wait until your allowance replenishes, then try again.",
+    CASErrorId.INCOMPLETE_RESPONSE: "Could not obtain a full response from the model through streamed completion call.",
+    CASErrorId.MAX_STEPS_REACHED: "Maximum number of sequential steps reached. You may send a new message to tell the agent to continue.",
+    CASErrorId.DEFAULT_ERROR: "An unexpected error has occurred.",
+}
+
+# Error code suffix mappings to CAS error IDs.
+_CAS_ERROR_ID_MAP: dict[str, str] = {
+    "LICENSE_NOT_AVAILABLE": CASErrorId.LICENSING,
+    "UNSUCCESSFUL_STOP_REASON": CASErrorId.INCOMPLETE_RESPONSE,
+    "TERMINATION_MAX_ITERATIONS": CASErrorId.MAX_STEPS_REACHED,
+    "INVALID_INPUT_FILE_EXTENSION": CASErrorId.INVALID_INPUT,
+    "MISSING_INPUT_FILE": CASErrorId.INVALID_INPUT,
+    "INPUT_INVALID_JSON": CASErrorId.INVALID_INPUT,
+}
+
+
+def _extract_error_info(error: Exception) -> tuple[str, str]:
+    """Extract an error code and a user-facing message from an exception.
+
+    For UiPathBaseRuntimeError (structured errors), extracts code and builds
+    a message from title + detail. For other exceptions, returns defaults.
+    """
+    from uipath.runtime.errors import UiPathBaseRuntimeError
+
+    if isinstance(error, UiPathBaseRuntimeError):
+        info = error.error_info
+        code = info.code or CASErrorId.DEFAULT_ERROR
+        title = info.title or ""
+        detail = info.detail.split("\n")[0] if info.detail else ""
+        if title and detail:
+            message = f"{title}. {detail}"
+        else:
+            message = title or detail or _CAS_ERROR_MESSAGES[CASErrorId.DEFAULT_ERROR]
+        return code, message
+
+    return CASErrorId.DEFAULT_ERROR, _CAS_ERROR_MESSAGES[CASErrorId.DEFAULT_ERROR]
+
+
+def _resolve_cas_error(error: Exception) -> tuple[str, str]:
+    """Map an exception to a CAS error ID and user-facing message.
+
+    Extracts the error code from the exception, then checks the code suffix
+    against known mappings. For recognized errors, uses a hardcoded message
+    matching the Temporal backend. For unrecognized errors, passes through
+    the extracted message.
+    """
+    error_code, error_message = _extract_error_info(error)
+    suffix = error_code.rsplit(".", 1)[-1] if error_code else ""
+    cas_error_id = _CAS_ERROR_ID_MAP.get(suffix, CASErrorId.DEFAULT_ERROR)
+    cas_message = _CAS_ERROR_MESSAGES.get(cas_error_id) or error_message
+    return cas_error_id, cas_message
+
+
+class SocketIOChatBridge:
+    """WebSocket-based chat bridge for streaming conversational events to CAS.
+
+    Implements UiPathChatBridgeProtocol using python-socketio library.
+    """
+
+    def __init__(
+        self,
+        websocket_url: str,
+        websocket_path: str,
+        conversation_id: str,
+        exchange_id: str,
+        headers: dict[str, str],
+        auth: dict[str, Any] | None = None,
+        end_exchange: bool = True,
+    ):
+        """Initialize the WebSocket chat bridge.
+
+        Args:
+            websocket_url: The WebSocket server URL to connect to
+            conversation_id: The conversation ID for this session
+            exchange_id: The exchange ID for this session
+            headers: HTTP headers to send during connection
+            auth: Optional authentication data to send during connection
+            end_exchange: Whether to send the exchange-end event to CAS on
+                completion.
+        """
+        self.websocket_url = websocket_url
+        self.websocket_path = websocket_path
+        self.conversation_id = conversation_id
+        self.exchange_id = exchange_id
+        self.auth = auth
+        self.headers = headers
+        self.end_exchange = end_exchange
+        self._client: Any | None = None
+        self._connected_event = asyncio.Event()
+
+        self._tool_resume_event = asyncio.Event()
+        self._tool_resume_value: (
+            UiPathConversationToolCallConfirmationEvent
+            | UiPathConversationToolCallEndEvent
+            | None
+        ) = None
+        self._current_message_id: str | None = None
+
+        # Set CAS_WEBSOCKET_DISABLED when using the debugger to prevent websocket errors from
+        # interrupting the debugging session. Events will be logged instead of being sent.
+        self._websocket_disabled = os.environ.get("CAS_WEBSOCKET_DISABLED") == "true"
+
+    async def connect(self, timeout: float = 10.0) -> None:
+        """Establish WebSocket connection to the server.
+
+        Args:
+            timeout: Connection timeout in seconds (default: 10.0)
+
+        Raises:
+            RuntimeError: If connection fails or times out
+
+        Example:
+            ```python
+            manager = WebSocketManager("http://localhost:3000")
+            await manager.connect()
+            ```
+        """
+        if self._client is not None:
+            logger.warning("WebSocket client already connected")
+            return
+
+        # Create new SocketIO client
+        # Lazy import to avoid dependency if not used, improve startup time
+        from socketio import AsyncClient  # type: ignore[import-untyped]
+
+        self._client = AsyncClient(
+            logger=logger,
+            engineio_logger=logger,
+        )
+
+        # Register connection event handlers
+        self._client.on("connect", self._handle_connect)
+        self._client.on("disconnect", self._handle_disconnect)
+        self._client.on("connect_error", self._handle_connect_error)
+        self._client.on("ConversationEvent", self._handle_conversation_event)
+
+        self._connected_event.clear()
+
+        if self._websocket_disabled:
+            logger.warning(
+                "SocketIOChatBridge is in debug mode. Not connecting websocket."
+            )
+        else:
+            try:
+                # Attempt to connect with timeout
+                await asyncio.wait_for(
+                    self._client.connect(
+                        url=self.websocket_url,
+                        socketio_path=self.websocket_path,
+                        headers=self.headers,
+                        auth=self.auth,
+                        transports=["websocket"],
+                    ),
+                    timeout=timeout,
+                )
+
+                await asyncio.wait_for(self._connected_event.wait(), timeout=timeout)
+
+            except asyncio.TimeoutError as e:
+                error_message = (
+                    f"Failed to connect to WebSocket server within {timeout}s timeout"
+                )
+                logger.error(error_message)
+                await self._cleanup_client()
+                raise RuntimeError(error_message) from e
+
+            except Exception as e:
+                error_message = f"Failed to connect to WebSocket server: {e}"
+                logger.error(error_message)
+                await self._cleanup_client()
+                raise RuntimeError(error_message) from e
+
+    async def disconnect(self) -> None:
+        """Close the WebSocket connection gracefully.
+
+        Sends an exchange end event before disconnecting to signal that the
+        exchange is complete. Uses stored conversation/exchange IDs.
+        """
+        if self._client is None:
+            logger.warning("WebSocket client not connected")
+            return
+
+        try:
+            # Wait for last event to be sent (usually endExchange). Without this, it seems that the disconnect races
+            # with the send and sometimes the last event isn't sent. Since the wait happens after the agent has
+            # completed it doesn't add latency for the user, but it does create a larger window where the job isn't
+            # suspended or terminated yet and a new input message is received from the user. CAS expects coded
+            # conversational agent jobs to suspend at the end of an exchange, and for low code agent jobs to terminate
+            # at the end of an exchange. CAS will resume or re-start jobs when a new user input message is received. To
+            # handle the race condition should an input be received before the job is actually suspended or terminated,
+            # CAS waits for running jobs to suspend or terminate before resuming or starting a new job. Note that this
+            # window exists even without this additional wait, but would usually be much smaller so is less of a
+            # concern.
+            await asyncio.sleep(1)
+            await self._client.disconnect()
+        except Exception as e:
+            logger.error(f"Error during WebSocket disconnect: {e}")
+        finally:
+            await self._cleanup_client()
+
+    async def emit_message_event(
+        self, message_event: UiPathConversationMessageEvent
+    ) -> None:
+        """Wrap and send a message event to the WebSocket server.
+
+        Args:
+            message_event: UiPathConversationMessageEvent to wrap and send
+
+        Raises:
+            RuntimeError: If client is not connected
+        """
+        if self._client is None:
+            raise RuntimeError("WebSocket client not connected. Call connect() first.")
+
+        if not self._connected_event.is_set() and not self._websocket_disabled:
+            raise RuntimeError("WebSocket client not in connected state")
+
+        try:
+            # Wrap message event with conversation/exchange IDs
+            wrapped_event = UiPathConversationEvent(
+                conversation_id=self.conversation_id,
+                exchange=UiPathConversationExchangeEvent(
+                    exchange_id=self.exchange_id,
+                    message=message_event,
+                ),
+            )
+
+            event_data = wrapped_event.model_dump(
+                mode="json", exclude_none=True, by_alias=True
+            )
+
+            if self._websocket_disabled:
+                logger.info(
+                    f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                )
+            else:
+                await self._client.emit("ConversationEvent", event_data)
+
+            # Store the current message ID, used for emitting interrupt events.
+            self._current_message_id = message_event.message_id
+
+        except Exception as e:
+            logger.error(f"Error sending conversation event to WebSocket: {e}")
+            raise RuntimeError(f"Failed to send conversation event: {e}") from e
+
+    async def emit_exchange_end_event(self) -> None:
+        """Send an exchange end event.
+
+        When end_exchange is False the exchange is left open — the event is not
+        sent to CAS so a downstream consumer can continue and end it later.
+
+        Raises:
+           RuntimeError: If client is not connected
+        """
+        if not self.end_exchange:
+            logger.info("end_exchange is False; leaving the exchange open.")
+            return
+
+        if self._client is None:
+            raise RuntimeError("WebSocket client not connected. Call connect() first.")
+
+        if not self._connected_event.is_set() and not self._websocket_disabled:
+            raise RuntimeError("WebSocket client not in connected state")
+
+        try:
+            exchange_end_event = UiPathConversationEvent(
+                conversation_id=self.conversation_id,
+                exchange=UiPathConversationExchangeEvent(
+                    exchange_id=self.exchange_id,
+                    end=UiPathConversationExchangeEndEvent(),
+                ),
+            )
+
+            event_data = exchange_end_event.model_dump(
+                mode="json", exclude_none=True, by_alias=True
+            )
+
+            if self._websocket_disabled:
+                logger.info(
+                    f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                )
+            else:
+                await self._client.emit("ConversationEvent", event_data)
+
+        except Exception as e:
+            logger.error(f"Error sending conversation event to WebSocket: {e}")
+            raise RuntimeError(f"Failed to send conversation event: {e}") from e
+
+    async def emit_exchange_error_event(self, error: Exception) -> None:
+        """Send an exchange error event to signal an error to the UI.
+
+        Extracts error information from the exception and maps it to
+        CAS-specific error IDs and messages matching the Temporal backend
+        for frontend consistency.
+
+        Args:
+            error: The exception that caused the error.
+        """
+        if self._client is None:
+            raise RuntimeError("WebSocket client not connected. Call connect() first.")
+
+        if not self._connected_event.is_set() and not self._websocket_disabled:
+            raise RuntimeError("WebSocket client not in connected state")
+
+        # Extract and map error to CAS-specific error ID and message.
+        cas_error_id, cas_message = _resolve_cas_error(error)
+
+        try:
+            exchange_error_event = UiPathConversationEvent(
+                conversation_id=self.conversation_id,
+                exchange=UiPathConversationExchangeEvent(
+                    exchange_id=self.exchange_id,
+                    error=UiPathConversationErrorEvent(
+                        error_id=cas_error_id,
+                        start=UiPathConversationErrorStartEvent(
+                            message=cas_message,
+                        ),
+                    ),
+                ),
+            )
+
+            event_data = exchange_error_event.model_dump(
+                mode="json", exclude_none=True, by_alias=True
+            )
+
+            if self._websocket_disabled:
+                logger.info(
+                    f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                )
+            else:
+                await self._client.emit("ConversationEvent", event_data)
+
+        except Exception as e:
+            logger.error(f"Error sending exchange error event to WebSocket: {e}")
+            raise RuntimeError(f"Failed to send exchange error event: {e}") from e
+
+    async def emit_interrupt_event(self, resume_trigger: UiPathResumeTrigger):
+        """No-op.
+
+        Tool confirmation is handled end-to-end via ``startToolCall`` with
+        ``requireConfirmation: true`` paired with ``wait_for_resume()``.
+        executingToolCall is emitted by the MessageMapper (non-confirmed
+        tools) and the runtime loop post-confirmation (confirmed tools).
+        """
+        return None
+
+    async def emit_executing_tool_call_event(
+        self,
+        tool_call_id: str,
+        tool_input: dict[str, Any] | None = None,
+    ) -> None:
+        """Emit an executingToolCall event.
+
+        Called by the runtime loop after a tool-call confirmation resumes
+        to signal that the tool is about to execute with the final input.
+        """
+        if not self._current_message_id:
+            return
+
+        executing_event = UiPathConversationMessageEvent(
+            message_id=self._current_message_id,
+            tool_call=UiPathConversationToolCallEvent(
+                tool_call_id=tool_call_id,
+                executing=UiPathConversationExecutingToolCallEvent(
+                    input=tool_input,
+                ),
+            ),
+        )
+        await self.emit_message_event(executing_event)
+
+    async def wait_for_resume(self) -> dict[str, Any]:
+        """Wait for a tool resume event (confirmToolCall or endToolCall) to be received."""
+        if self._tool_resume_value is None:
+            self._tool_resume_event.clear()
+            await self._tool_resume_event.wait()
+
+        value = self._tool_resume_value
+        self._tool_resume_value = None
+        self._tool_resume_event.clear()
+
+        """For the case where there's no tool confirmation and the client side tool sends endToolCall back before wait_for_resume is called.
+        Unlikely in practice, but possible in theory, since executingToolCall is emitted during the streaming.
+        """
+        if value:
+            return value.model_dump(mode="python", by_alias=False)
+        return {}
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if the WebSocket is currently connected.
+
+        Returns:
+            True if connected, False otherwise
+        """
+        return self._client is not None and self._connected_event.is_set()
+
+    async def _handle_connect(self) -> None:
+        """Handle successful connection event."""
+        logger.info("WebSocket connection established")
+        self._connected_event.set()
+
+    async def _handle_disconnect(self) -> None:
+        """Handle disconnection event."""
+        logger.info("WebSocket connection closed")
+        self._connected_event.clear()
+
+    async def _handle_connect_error(self, data: Any) -> None:
+        """Handle connection error event."""
+        logger.error(f"WebSocket connection error: {data}")
+
+    async def _handle_conversation_event(
+        self, event: dict[str, Any], _sid: str
+    ) -> None:
+
+        try:
+            parsed_event = UiPathConversationEvent(**event)
+            if (
+                parsed_event.exchange
+                and parsed_event.exchange.message
+                and (tool_call := parsed_event.exchange.message.tool_call)
+            ):
+                if confirm := tool_call.confirm:
+                    self._tool_resume_value = confirm
+                    self._tool_resume_event.set()
+                elif end := tool_call.end:
+                    self._tool_resume_value = end
+                    self._tool_resume_event.set()
+        except Exception as e:
+            logger.warning(f"Error parsing conversation event: {e}")
+
+    async def _cleanup_client(self) -> None:
+        """Clean up client resources."""
+        self._connected_event.clear()
+        self._client = None
+
+
+def get_chat_bridge(
+    context: UiPathRuntimeContext,
+) -> UiPathChatProtocol:
+    """Factory to get WebSocket chat bridge for conversational agents.
+
+    Args:
+        context: The runtime context containing environment configuration
+        conversation_id: The conversation ID for this session
+        exchange_id: The exchange ID for this session
+
+    Returns:
+        WebSocketChatBridge instance configured for CAS
+
+    Raises:
+        RuntimeError: If UIPATH_URL is not set or invalid
+
+    Example:
+        ```python
+        bridge = get_chat_bridge(context, "conv-123", "exch-456")
+        await bridge.connect()
+        await bridge.emit_message_event(message_event)
+        await bridge.disconnect(conversation_id, exchange_id)
+        ```
+    """
+    assert context.conversation_id is not None, "conversation_id must be set in context"
+    assert context.exchange_id is not None, "exchange_id must be set in context"
+
+    # Extract host from UIPATH_URL
+    base_url = os.environ.get("UIPATH_URL")
+    if not base_url:
+        raise RuntimeError(
+            "UIPATH_URL environment variable required for conversational mode"
+        )
+
+    parsed = urlparse(base_url)
+    if not parsed.netloc:
+        raise RuntimeError(f"Invalid UIPATH_URL format: {base_url}")
+
+    host = parsed.netloc
+
+    # Construct WebSocket URL for CAS
+    websocket_url = f"wss://{host}?conversationId={context.conversation_id}"
+    websocket_path = "autopilotforeveryone_/websocket_/socket.io"
+
+    if os.environ.get("CAS_WEBSOCKET_HOST"):
+        websocket_url = f"ws://{os.environ.get('CAS_WEBSOCKET_HOST')}?conversationId={context.conversation_id}"
+        websocket_path = "/socket.io"
+        logger.warning(
+            f"CAS_WEBSOCKET_HOST is set. Using websocket_url '{websocket_url}{websocket_path}'."
+        )
+
+    # Build headers from context
+    headers = {
+        "Authorization": f"Bearer {os.environ.get('UIPATH_ACCESS_TOKEN', '')}",
+        "X-UiPath-Internal-TenantId": context.tenant_id
+        or os.environ.get("UIPATH_TENANT_ID", ""),
+        "X-UiPath-Internal-AccountId": context.org_id
+        or os.environ.get("UIPATH_ORGANIZATION_ID", ""),
+        "X-UiPath-ConversationId": context.conversation_id,
+    }
+
+    # Conversation owner id (conversationalService.conversationalUserId) that CAS forwards via
+    # FpsProperties; always sent when present. It's there for RunAsMe=false, where the unattended
+    # robot's token subject is the robot account rather than the conversation owner, so CAS validates
+    # this presented id against conversation.user_id on the handshake instead of the token subject.
+    # Sent as a header (not a query param) to keep it out of access / load-balancer logs.
+    conversational_user_id = getattr(context, "conversational_user_id", None)
+    if conversational_user_id:
+        headers["X-UiPath-Internal-ConversationalUserId"] = conversational_user_id
+
+    return SocketIOChatBridge(
+        websocket_url=websocket_url,
+        websocket_path=websocket_path,
+        conversation_id=context.conversation_id,
+        exchange_id=context.exchange_id,
+        headers=headers,
+        end_exchange=getattr(context, "end_exchange", True),
+    )
+
+
+__all__ = ["get_chat_bridge"]
diff --git a/packages/uipath/src/uipath/_cli/_chat/_voice_bridge.py b/packages/uipath/src/uipath/_cli/_chat/_voice_bridge.py
new file mode 100644
index 000000000..8473c1574
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_chat/_voice_bridge.py
@@ -0,0 +1,266 @@
+"""Voice tool-call session — persistent socket.io connection to CAS."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from collections.abc import Awaitable, Callable
+from enum import Enum
+from typing import Any
+from urllib.parse import urlparse
+
+from pydantic import ValidationError
+
+from uipath.core.chat import (
+    UiPathVoiceToolCallMessage,
+    UiPathVoiceToolCallRequest,
+    UiPathVoiceToolCallResult,
+)
+from uipath.runtime.context import UiPathRuntimeContext
+
+logger = logging.getLogger(__name__)
+
+
+_ATTEMPT_CAS_SOCKET_CONNECTION_TIMEOUT_SECONDS = 15.0
+_INFLIGHT_TOOL_DRAIN_AFTER_AGENT_END_TIMEOUT_SECONDS = 30.0
+
+
+class VoiceToolCallSessionError(RuntimeError):
+    pass
+
+
+class VoiceSessionEndReason(str, Enum):
+    COMPLETED = "completed"
+    DISCONNECTED = "disconnected"
+    READY_EMIT_FAILED = "ready_emit_failed"
+
+
+class VoiceEvent(str, Enum):
+    """CAS voice-session protocol events (excludes socket.io lifecycle)."""
+
+    TOOL_CALL = "voice_tool_call"  # received
+    SESSION_ENDED = "voice_session_ended"  # received
+    TOOLS_READY = "voice_tools_ready"  # sent
+    TOOL_RESULT = "voice_tool_result"  # sent
+
+
+ToolHandler = Callable[
+    [UiPathVoiceToolCallRequest], Awaitable[UiPathVoiceToolCallResult]
+]
+
+
+class VoiceToolCallSession:
+    """Socket.io session with CAS for tool-call traffic.
+
+    Receives `voice_tool_call` batches, emits one `voice_tool_result` per
+    `callId`, exits on `voice_session_ended` or disconnect. CAS pulls
+    agent config from Orchestrator directly; this session carries only
+    tool calls.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        socketio_path: str,
+        headers: dict[str, str],
+        tool_handler: ToolHandler,
+    ) -> None:
+        self._url = url
+        self._socketio_path = socketio_path
+        self._headers = headers
+        self._tool_handler = tool_handler
+        self._client: Any = None
+        self._done = asyncio.Event()
+        self._in_flight: set[asyncio.Task[None]] = set()
+        self._end_reason: VoiceSessionEndReason | None = None
+
+    async def run(self) -> VoiceSessionEndReason:
+        """Connect, dispatch tool calls until session ends, then disconnect.
+
+        Raises:
+            VoiceToolCallSessionError: If connecting to CAS fails.
+        """
+        from socketio import AsyncClient  # type: ignore[import-untyped]
+
+        self._client = AsyncClient(logger=False, engineio_logger=False)
+        self._client.on("connect", self._handle_connect)
+        self._client.on("disconnect", self._handle_disconnect)
+        self._client.on(VoiceEvent.TOOL_CALL, self._handle_tool_call)
+        self._client.on(VoiceEvent.SESSION_ENDED, self._handle_session_ended)
+
+        try:
+            await asyncio.wait_for(
+                self._client.connect(
+                    url=self._url,
+                    socketio_path=self._socketio_path,
+                    headers=self._headers,
+                    transports=["websocket"],
+                ),
+                timeout=_ATTEMPT_CAS_SOCKET_CONNECTION_TIMEOUT_SECONDS,
+            )
+        except Exception as exc:
+            await self._safe_disconnect("after connect-failure")
+            raise VoiceToolCallSessionError(
+                f"Failed to connect to CAS voice endpoint: {exc}"
+            ) from exc
+
+        try:
+            await self._done.wait()
+            await self._drain_in_flight()
+        finally:
+            await self._safe_disconnect("on shutdown")
+
+        return self._end_reason or VoiceSessionEndReason.DISCONNECTED
+
+    async def _safe_disconnect(self, when: str) -> None:
+        try:
+            await self._client.disconnect()
+        except Exception as exc:
+            logger.debug("[Voice] disconnect %s raised: %s", when, exc)
+
+    def _end_session(self, reason: VoiceSessionEndReason) -> None:
+        # First writer wins: a late disconnect must not overwrite COMPLETED.
+        if self._end_reason is None:
+            self._end_reason = reason
+        self._done.set()
+
+    async def _drain_in_flight(self) -> None:
+        """Wait for in-flight tool tasks to finish, capped by the drain timeout."""
+        if not self._in_flight:
+            return
+        logger.info(
+            "[Voice] Session ended with %d in-flight tool task(s); draining (max %.0fs)",
+            len(self._in_flight),
+            _INFLIGHT_TOOL_DRAIN_AFTER_AGENT_END_TIMEOUT_SECONDS,
+        )
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(*self._in_flight, return_exceptions=True),
+                timeout=_INFLIGHT_TOOL_DRAIN_AFTER_AGENT_END_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            unfinished = sum(1 for t in self._in_flight if not t.done())
+            logger.warning(
+                "[Voice] %d tool task(s) did not complete within %.0fs of session end",
+                unfinished,
+                _INFLIGHT_TOOL_DRAIN_AFTER_AGENT_END_TIMEOUT_SECONDS,
+            )
+
+    async def _handle_connect(self) -> None:
+        logger.info("[Voice] Socket.io connected to CAS")
+        try:
+            await self._client.emit(VoiceEvent.TOOLS_READY, {})
+        except Exception as exc:
+            # CAS gates tool dispatch on this event; without it the session is dead.
+            logger.warning("[Voice] emit voice_tools_ready failed: %s", exc)
+            self._end_session(VoiceSessionEndReason.READY_EMIT_FAILED)
+
+    async def _handle_disconnect(self) -> None:
+        logger.info("[Voice] Socket.io disconnected from CAS")
+        self._end_session(VoiceSessionEndReason.DISCONNECTED)
+
+    async def _handle_tool_call(self, data: dict[str, Any], *_: Any) -> None:
+        """Spawn a task per call and return — the reader must stay free for `voice_session_ended`."""
+        if self._done.is_set():
+            return
+
+        try:
+            message = UiPathVoiceToolCallMessage.model_validate(data)
+        except ValidationError as exc:
+            logger.warning("[Voice] invalid voice_tool_call payload: %s", exc)
+            return
+
+        for call in message.calls:
+            task = asyncio.create_task(self._execute_tool_call(call))
+            self._in_flight.add(task)
+            task.add_done_callback(self._in_flight.discard)
+
+    async def _execute_tool_call(self, call: UiPathVoiceToolCallRequest) -> None:
+        """Run one tool call and emit its `voice_tool_result`."""
+        logger.info(
+            "[Voice] voice_tool_call dispatched: %s (%s) args=%s",
+            call.tool_name,
+            call.call_id,
+            call.args,
+        )
+        try:
+            tool_result = await self._tool_handler(call)
+        except Exception as exc:
+            logger.exception("[Voice] Tool call execution failed: %s", call.tool_name)
+            tool_result = UiPathVoiceToolCallResult(result=str(exc), is_error=True)
+
+        try:
+            await self._client.emit(
+                VoiceEvent.TOOL_RESULT,
+                {"callId": call.call_id, **tool_result.model_dump(by_alias=True)},
+            )
+        except Exception as exc:
+            logger.debug(
+                "[Voice] emit voice_tool_result failed for %s: %s", call.call_id, exc
+            )
+            return
+        logger.info(
+            "[Voice] voice_tool_result sent: %s (isError=%s)",
+            call.call_id,
+            tool_result.is_error,
+        )
+
+    async def _handle_session_ended(self, _data: Any, *_: Any) -> None:
+        logger.info("[Voice] voice_session_ended received")
+        self._end_session(VoiceSessionEndReason.COMPLETED)
+
+
+def get_voice_bridge(
+    context: UiPathRuntimeContext,
+    tool_handler: ToolHandler,
+) -> VoiceToolCallSession:
+    """Factory for a CAS voice tool-call session.
+
+    Raises:
+        RuntimeError: If UIPATH_URL is not set or invalid.
+    """
+    assert context.conversation_id is not None, "conversation_id must be set in context"
+
+    if cas_host := os.environ.get("CAS_WEBSOCKET_HOST"):
+        url = f"ws://{cas_host}?conversationId={context.conversation_id}"
+        socketio_path = "/socket.io"
+        logger.warning(
+            f"CAS_WEBSOCKET_HOST is set. Using websocket_url '{url}{socketio_path}'."
+        )
+    else:
+        base_url = os.environ.get("UIPATH_URL")
+        if not base_url:
+            raise RuntimeError(
+                "UIPATH_URL environment variable required for conversational mode"
+            )
+        parsed = urlparse(base_url)
+        if not parsed.netloc:
+            raise RuntimeError(f"Invalid UIPATH_URL format: {base_url}")
+        url = f"wss://{parsed.netloc}?conversationId={context.conversation_id}"
+        socketio_path = "autopilotforeveryone_/websocket_/socket.io"
+
+    headers = {
+        "Authorization": f"Bearer {os.environ.get('UIPATH_ACCESS_TOKEN', '')}",
+        "X-UiPath-Internal-TenantId": context.tenant_id
+        or os.environ.get("UIPATH_TENANT_ID", ""),
+        "X-UiPath-Internal-AccountId": context.org_id
+        or os.environ.get("UIPATH_ORGANIZATION_ID", ""),
+        "X-UiPath-ConversationId": context.conversation_id,
+    }
+
+    # Conversation owner id (conversationalService.conversationalUserId) that CAS forwards via
+    # FpsProperties; always sent when present. It's there for RunAsMe=false, where the unattended
+    # robot's token subject is the robot account rather than the conversation owner, so CAS validates
+    # this presented id against conversation.user_id on the handshake instead of the token subject.
+    # Sent as a header (not a query param) to keep it out of access / load-balancer logs.
+    conversational_user_id = getattr(context, "conversational_user_id", None)
+    if conversational_user_id:
+        headers["X-UiPath-Internal-ConversationalUserId"] = conversational_user_id
+
+    return VoiceToolCallSession(
+        url=url,
+        socketio_path=socketio_path,
+        headers=headers,
+        tool_handler=tool_handler,
+    )
diff --git a/packages/uipath/src/uipath/_cli/_debug/_bridge.py b/packages/uipath/src/uipath/_cli/_debug/_bridge.py
new file mode 100644
index 000000000..cfd286b5c
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_debug/_bridge.py
@@ -0,0 +1,906 @@
+import asyncio
+import json
+import logging
+import os
+import signal
+from concurrent.futures import ThreadPoolExecutor
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel
+from rich.console import Console
+from rich.tree import Tree
+
+from uipath.core.serialization import serialize_object
+from uipath.core.triggers import UiPathResumeTriggerType
+from uipath.runtime import (
+    UiPathBreakpointResult,
+    UiPathRuntimeContext,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+from uipath.runtime.debug import (
+    DetachedDebugBridge,
+    UiPathDebugProtocol,
+    UiPathDebugQuitError,
+)
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+
+DebugAttachMode = Literal["signalr", "console", "none"]
+
+logger = logging.getLogger(__name__)
+
+
+class DebugCommand(str, Enum):
+    """Available debug commands."""
+
+    CONTINUE = "continue"
+    STEP = "step"
+    BREAKPOINT = "breakpoint"
+    LIST_BREAKPOINTS = "list"
+    CLEAR_BREAKPOINT = "clear"
+    HELP = "help"
+    QUIT = "quit"
+
+
+class DebuggerState:
+    """Maintains debugger state across execution."""
+
+    def __init__(self):
+        self.breakpoints: set[str] = set()
+        self.step_mode: bool = False
+
+    def add_breakpoint(self, node_name: str) -> None:
+        """Add a breakpoint at a node."""
+        self.breakpoints.add(node_name)
+
+    def remove_breakpoint(self, node_name: str) -> None:
+        """Remove a breakpoint from a node."""
+        self.breakpoints.discard(node_name)
+
+    def clear_all_breakpoints(self) -> None:
+        """Clear all breakpoints."""
+        self.breakpoints.clear()
+
+    def should_break(self, node_name: str) -> bool:
+        """Check if execution should break at this node."""
+        if self.step_mode:
+            return True
+        return node_name in self.breakpoints
+
+
+class ConsoleDebugBridge:
+    """Console-based debug bridge for local development."""
+
+    def __init__(self, verbose: bool = True):
+        """Initialize console debug bridge.
+
+        Args:
+            verbose: If True, show state updates. If False, only show breakpoints.
+        """
+        self.console = Console(force_terminal=True)
+        self.verbose = verbose
+        self.state = DebuggerState()
+
+        self._stdin_executor = ThreadPoolExecutor(max_workers=1)
+        self._terminate_event: asyncio.Event | None = None
+        self._waiting_for_resume_data = False
+
+    async def connect(self) -> None:
+        """Initialize the console debugger."""
+        self._terminate_event = asyncio.Event()
+        signal.signal(
+            signal.SIGINT, self._handle_sigint
+        )  # We need to catch CTRL+C during polling
+        self.console.print()
+        self._print_help()
+
+    async def disconnect(self) -> None:
+        """Clean up console debugger."""
+        self.console.print()
+        self.console.print("[dim]─" * 40)
+        self.console.print("[green]Debug session completed")
+        self.console.print("[dim]─" * 40)
+
+    async def emit_execution_started(self, **kwargs) -> None:
+        """Print execution started."""
+        self.console.print("[green]▶ START[/green] [dim]")
+
+    async def emit_state_update(self, state_event: UiPathRuntimeStateEvent) -> None:
+        """Print agent state update."""
+        if not self.verbose or state_event.phase != UiPathRuntimeStatePhase.UPDATED:
+            return
+
+        self.console.print(f"[yellow]●[/yellow] [bold]{state_event.node_name}[/bold]")
+        if state_event.payload:
+            self._print_json(state_event.payload, label="state")
+
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        """Print breakpoint info."""
+        self.console.print()
+        self.console.print("[red]─" * 40)
+        self.console.print(
+            f"[red]■ BREAKPOINT[/red] [bold]{breakpoint_result.breakpoint_node}[/bold] "
+            f"[dim]({breakpoint_result.breakpoint_type})"
+        )
+
+        if breakpoint_result.next_nodes:
+            self.console.print(f"[dim]Next: {', '.join(breakpoint_result.next_nodes)}")
+
+        self.console.print("[red]─" * 40)
+
+        if breakpoint_result.current_state:
+            self._print_json(breakpoint_result.current_state, label="state")
+
+    async def emit_execution_completed(
+        self,
+        runtime_result: "UiPathRuntimeResult",
+    ) -> None:
+        """Print completion."""
+        self.console.print()
+
+        status: UiPathRuntimeStatus = runtime_result.status
+        if status == UiPathRuntimeStatus.SUCCESSFUL:
+            color = "green"
+            symbol = "●"
+        elif status == UiPathRuntimeStatus.SUSPENDED:
+            color = "yellow"
+            symbol = "■"
+        else:
+            color = "blue"
+            symbol = "●"
+
+        self.console.print(f"[{color}]{symbol} END[/{color}]")
+        output_data: dict[str, Any] | str = {}
+        if runtime_result.output:
+            if isinstance(runtime_result.output, BaseModel):
+                output_data = runtime_result.output.model_dump()
+            else:
+                output_data = runtime_result.output
+        self._print_json(output_data, label="output")
+
+    async def emit_execution_suspended(
+        self,
+        runtime_result: UiPathRuntimeResult,
+    ) -> None:
+        """Print execution suspended."""
+        self.console.print("[yellow]●[/yellow] [bold]<suspended>[/bold]")
+        if runtime_result.trigger is None:
+            return
+
+        if runtime_result.trigger.trigger_type == UiPathResumeTriggerType.API:
+            if runtime_result.output is None:
+                self._print_json({}, label="output")
+            elif isinstance(runtime_result.output, BaseModel):
+                self._print_json(runtime_result.output.model_dump(), label="output")
+            else:
+                self._print_json(runtime_result.output, label="output")
+            self.console.print("[dim]Please provide your input:[/dim]")
+
+            self._waiting_for_resume_data = True
+        else:
+            self._print_json(
+                runtime_result.trigger.model_dump() if runtime_result.trigger else {},
+                label="trigger",
+            )
+
+    async def emit_execution_resumed(self, resume_data: Any) -> None:
+        """Send execution resumed event."""
+        self.console.print("[yellow]●[/yellow] [bold]<resumed>[/bold]")
+        self._print_json(
+            resume_data.model_dump()
+            if resume_data and isinstance(resume_data, BaseModel)
+            else resume_data or {},
+            label="data",
+        )
+
+    async def emit_execution_error(
+        self,
+        error: str,
+    ) -> None:
+        """Print error."""
+        self.console.print()
+        self.console.print("[red]─" * 40)
+        self.console.print("[red]✗ Error[/red]")
+        self.console.print("[red]─" * 40)
+
+        # Truncate very long errors
+        error_display = error
+        if len(error) > 500:
+            error_display = error[:500] + "\n[dim]... (truncated)"
+
+        self.console.print(f"[red]{error_display}[/red]")
+        self.console.print("[red]─" * 40)
+
+    async def wait_for_resume(self) -> Any:
+        """Wait for user to press Enter or type commands."""
+        while True:  # Keep looping until we get a resume command
+            self.console.print()
+
+            loop = asyncio.get_running_loop()
+            future = loop.run_in_executor(
+                self._stdin_executor, self._read_input_blocking
+            )
+
+            try:
+                user_input = await future
+            except asyncio.CancelledError:
+                return {"command": DebugCommand.CONTINUE, "args": None}
+
+            if self._waiting_for_resume_data:
+                self._waiting_for_resume_data = False
+
+                stripped_input = user_input.strip()
+
+                # Try parse JSON, otherwise return raw string
+                try:
+                    return json.loads(stripped_input)
+                except Exception:
+                    return stripped_input
+
+            command_result = self._parse_command(user_input.strip())
+
+            # Handle commands that need another prompt
+
+            if command_result["command"] in {
+                DebugCommand.BREAKPOINT,
+                DebugCommand.LIST_BREAKPOINTS,
+                DebugCommand.CLEAR_BREAKPOINT,
+                DebugCommand.HELP,
+            }:
+                # These commands don't resume execution, loop again
+                continue
+
+            # Commands that resume execution: CONTINUE, STEP
+            self.console.print()
+            return command_result
+
+    async def wait_for_terminate(self) -> None:
+        """Wait until user requests termination (Ctrl+C or 'q')."""
+        assert self._terminate_event is not None, "Debugger not connected"
+        await self._terminate_event.wait()
+
+    def get_breakpoints(self) -> list[str] | Literal["*"]:
+        """Get nodes to suspend execution at."""
+        if self.state.step_mode:
+            return "*"  # Suspend at all nodes
+        return list(self.state.breakpoints)  # Only suspend at breakpoints
+
+    def _read_input_blocking(self) -> str:
+        assert self._terminate_event is not None, "Debugger not connected"
+        try:
+            return input("> ")
+        except KeyboardInterrupt as e:
+            self._terminate_event.set()
+            raise UiPathDebugQuitError("User pressed Ctrl+C") from e
+        except EOFError as e:
+            self._terminate_event.set()
+            raise UiPathDebugQuitError("STDIN closed by user") from e
+
+    def _handle_sigint(self, signum: int, frame: Any) -> None:
+        assert self._terminate_event is not None, "Debugger not connected"
+        asyncio.get_running_loop().call_soon_threadsafe(self._terminate_event.set)
+
+    def _parse_command(self, user_input: str) -> dict[str, Any]:
+        """Parse user command input.
+
+        Returns:
+            Dict with 'command' and optional 'args'
+        """
+        assert self._terminate_event is not None, "Debugger not connected"
+
+        if not user_input:
+            return {"command": DebugCommand.CONTINUE, "args": None}
+
+        parts = user_input.lower().split()
+        cmd = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
+
+        if cmd in ["c", "continue"]:
+            self.state.step_mode = False
+            return {"command": DebugCommand.CONTINUE, "args": None}
+
+        elif cmd in ["s", "step"]:
+            self.state.step_mode = True
+            return {"command": DebugCommand.STEP, "args": None}
+
+        elif cmd in ["b", "break", "breakpoint"]:
+            if not args:
+                self.console.print(
+                    "[red]Error: breakpoint command requires a node name[/red]"
+                )
+                return {"command": DebugCommand.HELP, "args": None}
+            node_name = " ".join(args)
+            self.state.add_breakpoint(node_name)
+            self.console.print(f"[green]✓ Breakpoint set at: {node_name}[/green]")
+            return {"command": DebugCommand.BREAKPOINT, "args": {"node": node_name}}
+
+        elif cmd in ["l", "list"]:
+            self._list_breakpoints()
+            return {"command": DebugCommand.LIST_BREAKPOINTS, "args": None}
+
+        elif cmd in ["r", "remove", "delete"]:
+            if not args:
+                self.console.print("[yellow]Removing all breakpoints[/yellow]")
+                self.state.clear_all_breakpoints()
+            else:
+                node_name = " ".join(args)
+                self.state.remove_breakpoint(node_name)
+                self.console.print(f"[green]✓ Breakpoint removed: {node_name}[/green]")
+            return {
+                "command": DebugCommand.CLEAR_BREAKPOINT,
+                "args": {"node": " ".join(args) if args else None},
+            }
+
+        elif cmd in ["q", "quit", "exit"]:
+            self._terminate_event.set()
+            raise UiPathDebugQuitError("User requested exit")
+
+        elif cmd in ["h", "help", "?"]:
+            self._print_help()
+            return {"command": DebugCommand.HELP, "args": None}
+
+        else:
+            self.console.print(f"[red]Unknown command: {cmd}[/red]")
+            self.console.print("[dim]Type 'help' for available commands[/dim]")
+            return {"command": DebugCommand.HELP, "args": None}
+
+    def _list_breakpoints(self) -> None:
+        """List all active breakpoints."""
+        if not self.state.breakpoints:
+            self.console.print("[dim]No breakpoints set[/dim]")
+        else:
+            self.console.print("[yellow]Active breakpoints:[/yellow]")
+            for i, bp in enumerate(sorted(self.state.breakpoints), 1):
+                self.console.print(f"  {i}. [cyan]{bp}[/cyan]")
+
+    def _print_help(self) -> None:
+        """Print available commands."""
+        self.console.print("[bold cyan]Debug Mode Commands[/bold cyan]")
+        self.console.print(
+            "  [yellow]c, continue[/yellow]     Continue until next breakpoint"
+        )
+        self.console.print("  [yellow]s, step[/yellow]         Step to next node")
+        self.console.print(
+            "  [yellow]b  <node>[/yellow]       Set breakpoint at <node>"
+        )
+        self.console.print("  [yellow]l, list[/yellow]         List all breakpoints")
+        self.console.print(
+            "  [yellow]r  <node>[/yellow]       Remove breakpoint at <node>"
+        )
+        self.console.print("  [yellow]h, help[/yellow]         Show help")
+        self.console.print("  [yellow]q, quit[/yellow]         Exit debugger")
+        self.console.print()
+
+    def _print_json(self, data: dict[str, Any] | str, label: str = "data") -> None:
+        """Print JSON data with enhanced hierarchy."""
+        try:
+            # Create a tree for nested structure
+            tree = Tree(f"[bold cyan]{label}[/bold cyan]")
+
+            def process_value(
+                node: Tree, value: Any, key_label: str, depth: int
+            ) -> None:
+                """Process a single value and add it to the tree."""
+                if isinstance(value, BaseModel):
+                    branch = node.add(
+                        f"{key_label} [dim]({type(value).__name__})[/dim]"
+                    )
+                    add_to_tree(branch, value, depth + 1)
+                elif isinstance(value, dict):
+                    branch = node.add(f"{key_label} [dim](dict)[/dim]")
+                    add_to_tree(branch, value, depth + 1)
+                elif isinstance(value, list):
+                    branch = node.add(
+                        f"{key_label} [dim](list, {len(value)} items)[/dim]"
+                    )
+                    add_to_tree(branch, value, depth + 1)
+                else:
+                    val_str = str(value)
+                    if len(val_str) > 250:
+                        val_str = val_str[:250] + "..."
+                    node.add(f"{key_label}: [green]{val_str}[/green]")
+
+            def add_to_tree(node: Tree, payload: Any, depth: int = 0):
+                if depth > 10:
+                    node.add("[dim]...[/dim]")
+                    return
+
+                if isinstance(payload, BaseModel):
+                    try:
+                        payload = payload.model_dump()  # Pydantic v2
+                    except AttributeError:
+                        payload = payload.dict()  # Pydantic v1
+                    add_to_tree(node, payload, depth)
+
+                elif isinstance(payload, dict):
+                    for key, value in payload.items():
+                        process_value(node, value, f"[yellow]{key}[/yellow]", depth)
+
+                elif isinstance(payload, list):
+                    for i, item in enumerate(payload):
+                        process_value(node, item, f"[cyan]#{i}[/cyan]", depth)
+
+                else:
+                    val_str = str(payload)
+                    if len(val_str) > 250:
+                        val_str = val_str[:250] + "..."
+                    node.add(f"[green]{val_str}[/green]")
+
+            add_to_tree(tree, data)
+
+            self.console.print()
+            self.console.print(tree)
+            self.console.print()
+
+        except Exception:
+            try:
+                json_str = json.dumps(data, indent=2, default=str)
+                if len(json_str) > 10000:
+                    json_str = json_str[:10000] + "\n..."
+                from rich.syntax import Syntax
+
+                syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+                self.console.print(f"\n[dim]{label}:")
+                self.console.print(syntax)
+                self.console.print()
+            except Exception:
+                # Fallback to simple print
+                self.console.print()
+                self.console.print(f"[dim]{label}:")
+                self.console.print(str(data))
+                self.console.print()
+
+
+class SignalRDebugBridge:
+    """SignalR-based debug bridge for remote debugging.
+
+    Communicates with a SignalR hub server.
+    """
+
+    def __init__(
+        self,
+        hub_url: str,
+        access_token: str | None = None,
+        headers: dict[str, str] | None = None,
+    ):
+        self.hub_url = hub_url
+        self.access_token = access_token
+        self.headers = headers or {}
+        self.state = DebuggerState()
+        self._connected_event = asyncio.Event()
+        self._resume_event: asyncio.Event | None = None
+        self._terminate_event = asyncio.Event()
+
+    async def connect(self) -> None:
+        """Establish SignalR connection."""
+        all_headers = {**self.headers}
+        if self.access_token:
+            all_headers["Authorization"] = f"Bearer {self.access_token}"
+
+        # Lazy import to avoid dependency if not used, improve startup time
+        from pysignalr.client import SignalRClient
+
+        self._client = SignalRClient(self.hub_url, headers=all_headers)
+
+        # Register event handlers
+        self._client.on("Start", self._handle_start)
+        self._client.on("Resume", self._handle_resume)
+        self._client.on("Step", self._handle_step)
+        self._client.on("AddBreakpoints", self._handle_add_breakpoints)
+        self._client.on("RemoveBreakpoints", self._handle_remove_breakpoints)
+        self._client.on("Quit", self._handle_quit)
+        self._client.on_open(self._handle_open)
+        self._client.on_close(self._handle_close)
+        self._client.on_error(self._handle_error)
+
+        self._run_task = asyncio.create_task(self._client.run())
+
+        async def cleanup_run_task() -> str:
+            error_message = (
+                "Failed to establish WebSocket connection within 10s timeout"
+            )
+
+            if self._run_task:
+                if not self._run_task.done():
+                    self._run_task.cancel()
+                try:
+                    await self._run_task
+                except asyncio.CancelledError:
+                    pass  # Expected on cancel
+                except Exception as task_error:
+                    error_msg = str(task_error).strip()
+                    error_detail = f": {error_msg}" if error_msg else ""
+                    return f"{error_message}: {type(task_error).__name__}{error_detail}"
+
+            return error_message
+
+        try:
+            # Wait for connection with timeout
+            await asyncio.wait_for(self._connected_event.wait(), timeout=10.0)
+        except asyncio.TimeoutError as e:
+            # Clean up on timeout
+            raise RuntimeError(await cleanup_run_task()) from e
+        except Exception:
+            # Clean up on any other error
+            await cleanup_run_task()
+            raise
+
+        # Check if run_task failed
+        if self._run_task.done():
+            exception = self._run_task.exception()
+            if exception:
+                raise exception
+
+    async def disconnect(self) -> None:
+        """Close SignalR connection."""
+        if not self._client:
+            return
+
+        # Cancel the run task first
+        if self._run_task and not self._run_task.done():
+            self._run_task.cancel()
+            try:
+                await self._run_task
+            except (Exception, asyncio.CancelledError):
+                pass
+
+        # Try to close the client cleanly
+        try:
+            if hasattr(self._client, "_transport"):
+                transport = self._client._transport
+                if transport and hasattr(transport, "_ws") and transport._ws:
+                    await transport._ws.close()
+        except Exception as e:
+            logger.warning(f"Error closing SignalR WebSocket: {e}")
+
+    async def emit_execution_started(self, **kwargs) -> None:
+        """Send execution started event."""
+        logger.info("Execution started")
+        await self._send("OnExecutionStarted", {**kwargs})
+
+    async def emit_state_update(self, state_event: UiPathRuntimeStateEvent) -> None:
+        """Send agent state update to remote debugger."""
+        logger.info(f"State update: {state_event.node_name}")
+        await self._send(
+            "OnStateUpdate",
+            {
+                "executionId": state_event.execution_id,
+                "nodeName": state_event.node_name,
+                "qualifiedNodeName": state_event.qualified_node_name,
+                "phase": state_event.phase,
+                "state": state_event.payload,
+            },
+        )
+
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        """Send breakpoint hit event."""
+        logger.info(
+            f"Breakpoint hit: {breakpoint_result.breakpoint_node} "
+            f"({breakpoint_result.breakpoint_type})"
+        )
+        await self._send(
+            "OnBreakpointHit",
+            {
+                "node": breakpoint_result.breakpoint_node,
+                "type": breakpoint_result.breakpoint_type,
+                "state": breakpoint_result.current_state,
+                "nextNodes": breakpoint_result.next_nodes,
+            },
+        )
+
+    async def emit_execution_completed(
+        self,
+        runtime_result: UiPathRuntimeResult,
+    ) -> None:
+        """Send execution completed event."""
+        logger.info(f"Execution completed: {runtime_result.status}")
+        await self._send(
+            "OnExecutionCompleted",
+            {
+                "status": runtime_result.status,
+                "output": runtime_result.output,
+            },
+        )
+
+    async def emit_execution_suspended(
+        self,
+        runtime_result: UiPathRuntimeResult,
+    ) -> None:
+        """Send execution suspended event."""
+        logger.info(f"Execution suspended: {runtime_result.status}")
+        if runtime_result.trigger is None:
+            return
+
+        if runtime_result.trigger.trigger_type == UiPathResumeTriggerType.API:
+            await self._send(
+                "OnBreakpointHit",
+                {
+                    "node": "<suspended>",
+                    "type": "before",
+                    "state": runtime_result.output.model_dump()
+                    if runtime_result.output
+                    and isinstance(runtime_result.output, BaseModel)
+                    else runtime_result.output or {},
+                    "nextNodes": [],
+                },
+            )
+        else:
+            await self._send(
+                "OnStateUpdate",
+                {
+                    "nodeName": "<suspended>",
+                    "state": runtime_result.trigger.model_dump()
+                    if runtime_result.trigger
+                    else {},
+                },
+            )
+
+    async def emit_execution_resumed(self, resume_data: Any) -> None:
+        """Send execution resumed event."""
+        logger.info("Execution resumed")
+        await self._send(
+            "OnStateUpdate",
+            {
+                "nodeName": "<resumed>",
+                "state": resume_data.model_dump()
+                if resume_data and isinstance(resume_data, BaseModel)
+                else resume_data or {},
+            },
+        )
+
+    async def emit_execution_error(
+        self,
+        error: str,
+    ) -> None:
+        """Send execution error event."""
+        if not self._connected_event.is_set():
+            return
+
+        logger.error(f"Execution error: {error}")
+        await self._send(
+            "OnExecutionError",
+            {
+                "error": error,
+            },
+        )
+
+    async def wait_for_resume(self) -> None:
+        """Wait for resume command from server.
+
+        Raises:
+            DebuggerQuitException: If quit command is received
+        """
+        logger.info("Waiting for resume command...")
+        self._resume_event = asyncio.Event()
+
+        resume_task = asyncio.create_task(self._resume_event.wait())
+        terminate_task = asyncio.create_task(self._terminate_event.wait())
+
+        done, pending = await asyncio.wait(
+            {resume_task, terminate_task}, return_when=asyncio.FIRST_COMPLETED
+        )
+
+        for task in pending:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        if terminate_task in done:
+            logger.info("Terminate command received during wait")
+            raise UiPathDebugQuitError("Terminate command received from server")
+
+        logger.info("Resume command received")
+
+    async def wait_for_terminate(self) -> None:
+        """Wait for terminate command from server."""
+        await self._terminate_event.wait()
+
+    def get_breakpoints(self) -> list[str] | Literal["*"]:
+        """Get nodes to suspend execution at."""
+        if self.state.step_mode:
+            return "*"  # Suspend at all nodes
+        return list(self.state.breakpoints)  # Only suspend at breakpoints
+
+    async def _send(self, event_name: str, data: dict[str, Any]) -> None:
+        """Send message to SignalR hub via SendCommand.
+
+        Args:
+            event_name: The event/command name (e.g., "OnExecutionStarted")
+            data: The data payload to send
+        """
+        if not self._client:
+            raise RuntimeError("SignalR client not connected")
+        try:
+            # Wrap the event in SendCommand protocol
+            # Server expects: SendCommand(event_name, json_string_of_data)
+            # Use serialize_object to recursively handle Pydantic models and nested objects
+            serialized_data = serialize_object(data)
+            data_json = json.dumps(serialized_data)
+            arguments: list[Any] = [event_name, data_json]
+            await self._client.send(method="SendCommand", arguments=arguments)
+            logger.debug(f"Sent command: {event_name}")
+        except Exception as e:
+            logger.error(f"Error sending command {event_name} to SignalR hub: {e}")
+
+    async def _handle_start(self, args: list[Any]) -> None:
+        """Handle Start command from SignalR server.
+
+        Args:
+            args: List containing command arguments as JSON string
+        """
+        if not args or len(args) == 0:
+            logger.warning("Start command received with empty args.")
+            return
+
+        command_args = json.loads(args[0])
+        self.state.breakpoints = set(command_args.get("breakpoints", []))
+        step_mode = command_args.get("enableStepMode", False)
+        self.state.step_mode = step_mode
+        logger.info(
+            f"Debug started: breakpoints={self.state.breakpoints}, step_mode={step_mode}"
+        )
+
+        # handle race conditions, runtime connected to debug bridge before the receiver
+        await self.emit_execution_started()
+
+    async def _handle_resume(self, args: list[Any]) -> None:
+        """Handle Resume command from SignalR server.
+
+        Args:
+            args: List containing command arguments as JSON string
+        """
+        if not self._resume_event:
+            logger.warning("Resume command received but no resume event is waiting.")
+            return
+
+        if args and len(args) > 0:
+            command_args = json.loads(args[0])
+            if not command_args.get("enableStepMode", False):
+                self.state.step_mode = False
+                breakpoints = command_args.get("breakpoints", [])
+                self.state.clear_all_breakpoints()
+                self._add_breakpoints(breakpoints)
+            else:
+                self.state.step_mode = True
+
+        self._resume_event.set()
+
+    def _add_breakpoints(self, breakpoints: list[dict[str, Any]]) -> None:
+        for bp in breakpoints:
+            node_name = (
+                bp.get("node", {}).get("name")
+                if isinstance(bp.get("node"), dict)
+                else None
+            )
+            if node_name:
+                self.state.add_breakpoint(node_name)
+                logger.info(f"Breakpoint added: {node_name}")
+            else:
+                logger.warning(f"Breakpoint without node name: {bp}")
+
+    async def _handle_step(self, args: list[Any]) -> None:
+        """Handle Step command from SignalR server.
+
+        Args:
+            args: List containing command arguments as JSON string
+        """
+        command_args = json.loads(args[0]) if args and len(args) > 0 else {}
+        step_mode = command_args.get("enableStepMode", True)
+        self.state.step_mode = step_mode
+
+    async def _handle_add_breakpoints(self, args: list[Any]) -> None:
+        """Handle AddBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments as JSON string with breakpoints list
+        """
+        if not args or len(args) == 0:
+            logger.warning("AddBreakpoints command received with empty args.")
+            return
+
+        command_args = json.loads(args[0])
+        breakpoints = command_args.get("breakpoints", [])
+
+        self._add_breakpoints(breakpoints)
+
+    async def _handle_remove_breakpoints(self, args: list[Any]) -> None:
+        """Handle RemoveBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments as JSON string with breakpoints list
+        """
+        if not args or len(args) == 0:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+            return
+
+        command_args = json.loads(args[0])
+        break_points = command_args.get("breakpoints", [])
+
+        if not break_points:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+        else:
+            for bp in break_points:
+                node_name = (
+                    bp.get("node", {}).get("name")
+                    if isinstance(bp.get("node"), dict)
+                    else None
+                )
+                if node_name:
+                    self.state.remove_breakpoint(node_name)
+                    logger.info(f"Breakpoint removed: {node_name}")
+
+    async def _handle_quit(self, _args: list[Any]) -> None:
+        """Handle Quit command from SignalR server."""
+        logger.info("Quit command received")
+        self._terminate_event.set()
+
+    async def _handle_open(self) -> None:
+        """Handle SignalR connection open."""
+        logger.info("SignalR connection established")
+        self._connected_event.set()
+
+    async def _handle_close(self) -> None:
+        """Handle SignalR connection close."""
+        logger.info("SignalR connection closed")
+        self._connected_event.clear()
+
+    async def _handle_error(self, error: Any) -> None:
+        """Handle SignalR error."""
+        logger.error(f"SignalR error: {error}")
+
+
+def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugProtocol:
+    """Factory to get SignalR debug bridge for remote debugging."""
+    uipath_url = os.environ.get("UIPATH_URL")
+    if not uipath_url or not context.job_id:
+        raise ValueError(
+            "UIPATH_URL and UIPATH_JOB_KEY are required for remote debugging"
+        )
+
+    signalr_url = f"{uipath_url.rstrip('/')}/orchestrator_/signalr/robotdebug?sessionId={context.job_id}"
+
+    return SignalRDebugBridge(
+        hub_url=signalr_url,
+        access_token=os.environ.get("UIPATH_ACCESS_TOKEN"),
+        headers={
+            "X-UiPath-Internal-TenantId": context.tenant_id or "",
+            "X-UiPath-Internal-AccountId": context.org_id or "",
+            "X-UiPath-FolderKey": context.folder_key or "",
+        },
+    )
+
+
+def get_debug_bridge(
+    context: UiPathRuntimeContext,
+    verbose: bool = True,
+    attach: DebugAttachMode | None = None,
+) -> UiPathDebugProtocol:
+    """Factory to get appropriate debug bridge based on context.
+
+    Args:
+        context: The runtime context containing debug configuration.
+        verbose: If True, console bridge shows all state updates. If False, only breakpoints.
+        attach: Explicit attach mode. When None, falls back to
+            ``context.job_id``-based selection.
+
+    Returns:
+        An instance of UiPathDebugBridge suitable for the context.
+    """
+    if attach == "none":
+        return DetachedDebugBridge()
+    if attach == "signalr":
+        return get_remote_debug_bridge(context)
+    if attach == "console":
+        return ConsoleDebugBridge(verbose=verbose)
+    if context.job_id:
+        return get_remote_debug_bridge(context)
+    return ConsoleDebugBridge(verbose=verbose)
diff --git a/packages/uipath/src/uipath/_cli/_errors.py b/packages/uipath/src/uipath/_cli/_errors.py
new file mode 100644
index 000000000..feb7006a4
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_errors.py
@@ -0,0 +1,20 @@
+class EntrypointDiscoveryException(Exception):
+    """Raised when entrypoint auto-discovery fails."""
+
+    def __init__(self, entrypoints: list[str]):
+        self.entrypoints = entrypoints
+
+    def get_usage_help(self) -> list[str]:
+        if self.entrypoints:
+            lines = ["Available entrypoints:"]
+            for name in self.entrypoints:
+                lines.append(f"  - {name}")
+            return lines
+        return [
+            "No entrypoints found.",
+            "",
+            "To configure entrypoints, use one of the following:",
+            "  1. Functions project (uipath.json)",
+            "  2. Framework-specific project (e.g. langgraph.json, llamaindex.json, openai_agents.json)",
+            "  3. MCP project (mcp.json)",
+        ]
diff --git a/packages/uipath/src/uipath/_cli/_evals/__init__.py b/packages/uipath/src/uipath/_cli/_evals/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/src/uipath/_cli/_evals/_console_progress_reporter.py b/packages/uipath/src/uipath/_cli/_evals/_console_progress_reporter.py
new file mode 100644
index 000000000..ebc25c0ca
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_evals/_console_progress_reporter.py
@@ -0,0 +1,248 @@
+"""Console progress reporter for evaluation runs with line-by-line output."""
+
+import logging
+from typing import Any
+
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+from uipath.core.events import EventBus
+from uipath.eval.evaluators.base_evaluator import GenericBaseEvaluator
+from uipath.eval.models import ScoreType
+from uipath.eval.runtime.events import (
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ConsoleProgressReporter:
+    """Handles displaying evaluation progress to the console with line-by-line output."""
+
+    def __init__(self):
+        self.console = Console()
+        self.evaluators: dict[str, GenericBaseEvaluator[Any, Any, Any]] = {}
+        self.display_started = False
+        self.eval_results_by_name: dict[str, list[Any]] = {}
+
+    def _convert_score_to_numeric(self, eval_result) -> float:
+        """Convert evaluation result score to numeric value."""
+        score_value = eval_result.result.score
+        if eval_result.result.score_type == ScoreType.BOOLEAN:
+            score_value = 100 if score_value else 0
+        return score_value
+
+    def _get_evaluator_name(self, evaluator_id: str) -> str:
+        """Get evaluator name from ID, with fallback."""
+        return self.evaluators.get(
+            evaluator_id,
+            type(
+                "obj",
+                (object,),
+                {"name": f"Evaluator {evaluator_id[:8]}"},
+            )(),
+        ).name
+
+    def _display_successful_evaluation(self, eval_name: str, eval_results) -> None:
+        """Display results for a successful evaluation."""
+        from rich.text import Text
+
+        if eval_results:
+            result = Text()
+            result.append("▌", style="bold green")
+            result.append(" ", style="")
+            result.append(eval_name, style="bold green")
+            self.console.print(result)
+            table = Table(show_header=False, box=None, padding=(0, 2, 0, 2))
+
+            for eval_result in eval_results:
+                evaluator_name = self._get_evaluator_name(eval_result.evaluator_id)
+                score_value = self._convert_score_to_numeric(eval_result)
+                table.add_row(
+                    f"{evaluator_name}", f"[bold cyan]{score_value:.1f}[/bold cyan]"
+                )
+
+            self.console.print(table)
+        else:
+            result = Text()
+            result.append("  ✓ ", style="bold green")
+            result.append(eval_name, style="bold white")
+            result.append(" - No evaluators", style="dim")
+            self.console.print(result)
+
+    def _extract_error_message(self, payload: EvalRunUpdatedEvent) -> str:
+        return (
+            payload.exception_details
+            and str(payload.exception_details.exception)
+            or "Execution failed"
+        )
+
+    def _display_failed_evaluation(self, eval_name: str) -> None:
+        """Display results for a failed evaluation."""
+        from rich.text import Text
+
+        result = Text()
+        result.append("  ✗ ", style="bold red")
+        result.append(eval_name, style="bold white")
+        self.console.print(result)
+
+    def start_display(self):
+        """Start the display."""
+        if not self.display_started:
+            self.console.print()
+            self.console.print("→ [bold]Running Evaluations[/bold]")
+            self.console.print()
+            self.display_started = True
+
+    async def handle_create_eval_set_run(self, payload: EvalSetRunCreatedEvent) -> None:
+        """Handle evaluation set run creation."""
+        try:
+            self.evaluators = {eval.id: eval for eval in payload.evaluators}
+        except Exception as e:
+            logger.error(f"Failed to handle create eval set run event: {e}")
+
+    async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
+        """Handle individual evaluation run creation."""
+        try:
+            if not self.display_started:
+                self.start_display()
+
+            self.console.print(f"  ○ [dim]{payload.eval_item.name}[/dim] - Running...")
+        except Exception as e:
+            logger.error(f"Failed to handle create eval run event: {e}")
+
+    def _display_logs_panel(self, eval_name: str, logs, error_msg: str = "") -> None:
+        """Display execution logs panel with optional exception at the end."""
+        self.console.print(
+            Rule(
+                f"[dim italic]Execution Logs: {eval_name}[/dim italic]",
+                style="dim",
+                align="center",
+            )
+        )
+
+        if logs:
+            for record in logs:
+                self.console.print(f"  [dim]{record.getMessage()}[/dim]")
+        elif not error_msg:
+            self.console.print("  [dim italic]No execution logs[/dim italic]")
+
+        if error_msg:
+            self.console.print(f"  [red]{error_msg}[/red]")
+
+        self.console.print(Rule(style="dim"))
+
+    async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
+        """Handle evaluation run updates."""
+        try:
+            if payload.success:
+                self.eval_results_by_name[payload.eval_item.name] = payload.eval_results
+                self._display_successful_evaluation(
+                    payload.eval_item.name, payload.eval_results
+                )
+                self._display_logs_panel(payload.eval_item.name, payload.logs)
+            else:
+                error_msg = self._extract_error_message(payload)
+                self._display_failed_evaluation(payload.eval_item.name)
+
+                if (
+                    payload.exception_details
+                    and payload.exception_details.runtime_exception
+                ):
+                    self._display_logs_panel(
+                        payload.eval_item.name, payload.logs, error_msg
+                    )
+                else:
+                    self.console.print(f"  [red]{error_msg}[/red]")
+                    self.console.print()
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
+        """Handle evaluation set run completion."""
+        try:
+            self.final_results = payload.evaluator_scores
+            self.display_final_results()
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    def display_final_results(self):
+        """Display final results summary."""
+        self.console.print()
+
+        if hasattr(self, "final_results") and self.final_results:
+            from rich.table import Table
+
+            # Group evaluators by ID to organize display
+            evaluator_ids = list(self.final_results.keys())
+
+            # Print title
+            self.console.print("[bold]Evaluation Results[/bold]")
+            self.console.print()
+
+            # Create single summary table
+            summary_table = Table(show_header=True, padding=(0, 2))
+            summary_table.add_column("Evaluation", style="cyan")
+
+            # Add column for each evaluator
+            for evaluator_id in evaluator_ids:
+                evaluator_name = self._get_evaluator_name(evaluator_id)
+                summary_table.add_column(evaluator_name, justify="right")
+
+            # Add row for each evaluation
+            for eval_name, eval_results in self.eval_results_by_name.items():
+                row_values = [eval_name]
+
+                # Get score for each evaluator
+                for evaluator_id in evaluator_ids:
+                    score_found = False
+                    for eval_result in eval_results:
+                        if eval_result.evaluator_id == evaluator_id:
+                            score_value = self._convert_score_to_numeric(eval_result)
+                            row_values.append(f"{score_value:.1f}")
+                            score_found = True
+                            break
+
+                    if not score_found:
+                        row_values.append("-")
+
+                summary_table.add_row(*row_values)
+
+            # Add separator row before average
+            summary_table.add_section()
+
+            # Add average row
+            avg_row_values = ["[bold]Average[/bold]"]
+            for evaluator_id in evaluator_ids:
+                avg_score = self.final_results[evaluator_id]
+                avg_row_values.append(f"[bold]{avg_score:.1f}[/bold]")
+
+            summary_table.add_row(*avg_row_values)
+
+            self.console.print(summary_table)
+            self.console.print()
+        else:
+            self.console.print(
+                "→ [bold green]All evaluations completed successfully![/bold green]"
+            )
+            self.console.print()
+
+    async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
+        """Subscribe to evaluation runtime events."""
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_SET_RUN, self.handle_create_eval_set_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_RUN, self.handle_create_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_RUN, self.handle_update_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
+        )
diff --git a/packages/uipath/src/uipath/_cli/_evals/_progress_reporter.py b/packages/uipath/src/uipath/_cli/_evals/_progress_reporter.py
new file mode 100644
index 000000000..fd4849076
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_evals/_progress_reporter.py
@@ -0,0 +1,1475 @@
+"""Progress reporter for sending evaluation updates to StudioWeb."""
+
+import functools
+import json
+import logging
+import os
+import uuid
+from enum import IntEnum
+from typing import Any
+from urllib.parse import urlparse
+
+from opentelemetry import trace
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+from rich.console import Console
+
+from uipath._cli._utils._console import ConsoleLogger
+from uipath._utils import Endpoint, RequestSpec
+from uipath._utils.constants import (
+    ENV_EVAL_BACKEND_URL,
+    ENV_TENANT_ID,
+    HEADER_INTERNAL_TENANT_ID,
+)
+from uipath.core.events import EventBus
+from uipath.eval.evaluators import (
+    BaseEvaluator,
+    BaseLegacyEvaluator,
+)
+from uipath.eval.evaluators.base_evaluator import GenericBaseEvaluator
+from uipath.eval.models import EvalItemResult, ScoreType
+from uipath.eval.models.evaluation_set import EvaluationItem
+from uipath.eval.runtime.events import (
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+from uipath.platform import UiPath
+from uipath.platform.common import UiPathConfig
+
+logger = logging.getLogger(__name__)
+
+
+class EvaluationStatus(IntEnum):
+    PENDING = 0
+    IN_PROGRESS = 1
+    COMPLETED = 2
+    FAILED = 3
+
+
+class StudioWebProgressItem(BaseModel):
+    eval_run_id: str
+    eval_results: list[EvalItemResult]
+    success: bool
+    agent_output: dict[str, Any]
+    agent_execution_time: float
+
+
+class StudioWebAgentSnapshot(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    input_schema: dict[str, Any]
+    output_schema: dict[str, Any]
+
+
+def gracefully_handle_errors(func):
+    """Decorator to catch and log errors without stopping execution."""
+
+    @functools.wraps(func)
+    async def wrapper(self, *args, **kwargs):
+        try:
+            return await func(self, *args, **kwargs)
+        except Exception as e:
+            if hasattr(self, "_console"):
+                error_type = type(e).__name__
+                # Log the full error message for debugging
+                logger.debug(f"Full error details: {e}")
+                logger.warning(
+                    f"Cannot report progress to SW. "
+                    f"Function: {func.__name__}, "
+                    f"Error type: {error_type}, "
+                    f"Details: {e}"
+                )
+            return None
+
+    return wrapper
+
+
+class StudioWebProgressReporter:
+    """Handles reporting evaluation progress to StudioWeb."""
+
+    def __init__(self):
+        logging.getLogger("uipath._cli.middlewares").setLevel(logging.CRITICAL)
+        console_logger = ConsoleLogger.get_instance()
+
+        # Use UIPATH_EVAL_BACKEND_URL for eval-specific routing if set
+        eval_backend_url = os.getenv(ENV_EVAL_BACKEND_URL)
+        uipath = UiPath(base_url=eval_backend_url) if eval_backend_url else UiPath()
+
+        self._client = uipath.api_client
+        self._console = console_logger
+        self._rich_console = Console()
+        self._project_id = os.getenv("UIPATH_PROJECT_ID", None)
+        self._agent_id = os.getenv("UIPATH_AGENT_ID") or self._project_id
+        if not self._agent_id:
+            logger.warning(
+                "Cannot report data to StudioWeb. Please set UIPATH_PROJECT_ID."
+            )
+
+        # Map UIPATH_PROJECT_FILES_SOURCE (Local/Cloud) to the backend's
+        # ProjectFilesSource enum integer. Without this every row the worker
+        # creates lands as Cloud, and the UI's `?projectFilesSource=1` filter
+        # never matches local-workspace runs.
+        self._project_files_source = self._resolve_project_files_source()
+
+        self.eval_set_ids: dict[str, str] = {}  # Track eval_set_id per execution
+        self.eval_set_run_ids: dict[str, str] = {}
+        self.evaluators: dict[str, Any] = {}
+        self.evaluator_scores: dict[str, list[float]] = {}
+        self.eval_run_ids: dict[str, str] = {}
+        self.is_coded_eval: dict[str, bool] = {}  # Track coded vs legacy per execution
+        self.is_resume_mode: dict[str, bool] = {}  # Track resume mode per execution
+        self.eval_spans: dict[
+            str, list[Any]
+        ] = {}  # Store spans per execution for usage metrics
+        self.eval_set_execution_id: str | None = (
+            None  # Track current eval set execution ID
+        )
+        self.user_provided_eval_set_run_ids: set[str] = (
+            set()
+        )  # Track user-provided eval_set_run_ids
+
+    @gracefully_handle_errors
+    async def get_eval_run_for_evaluation(
+        self,
+        eval_set_id: str,
+        eval_set_run_id: str,
+        evaluation_id: str,
+        is_coded: bool = False,
+    ) -> str | None:
+        """Get the eval_run_id for a specific evaluation from the backend.
+
+        This is used during resume to fetch the eval_run_id for the specific
+        evaluation being executed, using the backend database as the source of truth.
+
+        Args:
+            eval_set_id: The eval set ID
+            eval_set_run_id: The eval set run ID
+            evaluation_id: The specific evaluation ID being executed
+            is_coded: Whether this is a coded evaluation (vs legacy)
+
+        Returns:
+            The eval_run_id if found, None otherwise
+        """
+        logger.info(
+            f"Fetching eval runs from backend: eval_set_id={eval_set_id}, "
+            f"eval_set_run_id={eval_set_run_id}, evaluation_id={evaluation_id}, coded={is_coded}"
+        )
+
+        spec = self._get_eval_runs_spec(
+            eval_set_id, eval_set_run_id, evaluation_id, is_coded
+        )
+
+        logger.debug(f"GET request endpoint: {spec.endpoint}")
+
+        response = await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+
+        logger.info(
+            f"GET eval runs response: status_code={response.status_code}, "
+            f"content_length={len(response.content)} bytes"
+        )
+
+        # Parse response to find the eval run matching this evaluation_id
+        response_data = json.loads(response.content)
+        logger.debug(
+            f"GET eval run response data for evaluation_id={evaluation_id}: {json.dumps(response_data, indent=2)}"
+        )
+
+        # Extract eval runs from response
+        # Response format may vary between coded and legacy APIs
+        eval_runs = (
+            response_data
+            if isinstance(response_data, list)
+            else response_data.get("value", [])
+        )
+
+        logger.info(
+            f"Backend returned {len(eval_runs)} eval run(s) for eval_set_run_id={eval_set_run_id}"
+        )
+
+        # Find the eval run that matches our evaluation_id
+        for idx, eval_run in enumerate(eval_runs):
+            eval_snapshot = eval_run.get("evalSnapshot", {})
+            snapshot_eval_id = str(eval_snapshot.get("id", ""))
+            eval_run_id_in_response = eval_run.get("id")
+
+            logger.debug(
+                f"Checking eval run [{idx}]: eval_run_id={eval_run_id_in_response}, "
+                f"snapshot_eval_id={snapshot_eval_id}, target_evaluation_id={evaluation_id}"
+            )
+
+            if snapshot_eval_id == evaluation_id:
+                eval_run_id = eval_run.get("id")
+                if eval_run_id:
+                    logger.info(
+                        f"✓ MATCH FOUND: eval_run_id={eval_run_id} matches evaluation_id={evaluation_id} (resume scenario)"
+                    )
+                    return eval_run_id
+                else:
+                    logger.warning(
+                        f"Found matching eval snapshot with evaluation_id={evaluation_id} but eval_run_id is missing in response"
+                    )
+
+        logger.warning(
+            f"✗ NO MATCH: No eval run found in backend for evaluation_id={evaluation_id}. "
+            f"Searched {len(eval_runs)} eval run(s) in eval_set_run_id={eval_set_run_id}. "
+            f"Available evaluation IDs: {[str(er.get('evalSnapshot', {}).get('id', '')) for er in eval_runs]}"
+        )
+        return None
+
+    async def fetch_and_cache_eval_runs(
+        self,
+        eval_set_id: str,
+        eval_set_run_id: str,
+        is_coded: bool = False,
+    ) -> None:
+        """Fetch all eval runs from backend and populate cache.
+
+        This is used during resume to pre-populate the eval_run_id cache with
+        all existing eval runs from the backend database.
+
+        Args:
+            eval_set_id: The eval set ID
+            eval_set_run_id: The eval set run ID
+            is_coded: Whether this is a coded evaluation (vs legacy)
+        """
+        logger.info(
+            f"🔄 RESUME FLOW: Fetching all eval runs from backend to populate cache: "
+            f"eval_set_id={eval_set_id}, eval_set_run_id={eval_set_run_id}, coded={is_coded}"
+        )
+
+        # Use empty evaluation_id to fetch all eval runs (not filtering by specific evaluation)
+        spec = self._get_eval_runs_spec(
+            eval_set_id, eval_set_run_id, evaluation_id="", is_coded=is_coded
+        )
+
+        logger.debug(f"GET all eval runs endpoint: {spec.endpoint}")
+
+        response = await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+
+        logger.info(
+            f"GET all eval runs response: status_code={response.status_code}, "
+            f"content_length={len(response.content)} bytes"
+        )
+
+        # Parse response to extract all eval runs
+        response_data = json.loads(response.content)
+
+        # Extract eval runs from response
+        # Response format may vary between coded and legacy APIs
+        eval_runs = (
+            response_data
+            if isinstance(response_data, list)
+            else response_data.get("value", [])
+        )
+
+        logger.info(
+            f"✓ Backend returned {len(eval_runs)} eval run(s) for eval_set_run_id={eval_set_run_id}"
+        )
+
+        # Populate cache with all eval runs
+        cached_count = 0
+        for eval_run in eval_runs:
+            eval_snapshot = eval_run.get("evalSnapshot", {})
+            evaluation_id = str(eval_snapshot.get("id", ""))
+            eval_run_id = eval_run.get("id")
+
+            if evaluation_id and eval_run_id:
+                # Cache using evaluation_id as the key
+                # Since we don't have execution_id yet, we'll need to map by evaluation_id
+                # Store in a temporary mapping that will be used when CREATE_EVAL_RUN would have fired
+                self.eval_run_ids[evaluation_id] = eval_run_id
+                cached_count += 1
+                logger.debug(
+                    f"✓ Cached eval_run_id={eval_run_id} for evaluation_id={evaluation_id}"
+                )
+
+        logger.info(
+            f"✓ RESUME FLOW: Successfully cached {cached_count}/{len(eval_runs)} eval runs"
+        )
+
+    def _format_error_message(self, error: Exception, context: str) -> None:
+        """Helper method to format and display error messages consistently."""
+        self._rich_console.print(f"    • \u26a0  [dim]{context}: {error}[/dim]")
+
+    def _is_localhost(self) -> bool:
+        """Check if the eval backend URL is localhost.
+
+        Returns:
+            True if using localhost, False otherwise.
+        """
+        eval_backend_url = os.getenv(ENV_EVAL_BACKEND_URL, "")
+        if eval_backend_url:
+            try:
+                parsed = urlparse(eval_backend_url)
+                hostname = parsed.hostname or parsed.netloc.split(":")[0]
+                return hostname.lower() in ("localhost", "127.0.0.1")
+            except Exception:
+                pass
+        return False
+
+    def _get_endpoint_prefix(self) -> str:
+        """Determine the endpoint prefix based on environment.
+
+        Checks UIPATH_EVAL_BACKEND_URL environment variable:
+        - If set to localhost/127.0.0.1: returns "api/" (direct API access)
+        - Otherwise: returns "agentsruntime_/api/" (service routing for alpha/prod)
+
+        Returns:
+            "api/" for localhost environments, "agentsruntime_/api/" for alpha/production.
+        """
+        if self._is_localhost():
+            return "api/"
+        return "agentsruntime_/api/"
+
+    def _is_coded_evaluator(
+        self, evaluators: list[GenericBaseEvaluator[Any, Any, Any]]
+    ) -> bool:
+        """Check if evaluators are coded (BaseEvaluator) vs legacy (LegacyBaseEvaluator).
+
+        Args:
+            evaluators: List of evaluators to check
+
+        Returns:
+            True if using coded evaluators, False for legacy evaluators
+        """
+        if not evaluators:
+            return False
+        # Check the first evaluator type
+        return not isinstance(evaluators[0], BaseLegacyEvaluator)
+
+    def _extract_usage_from_spans(
+        self, spans: list[Any]
+    ) -> dict[str, int | float | None]:
+        """Extract token usage and cost from OpenTelemetry spans.
+
+        Args:
+            spans: List of ReadableSpan objects from agent execution
+
+        Returns:
+            Dictionary with tokens, completionTokens, promptTokens, and cost
+        """
+        total_tokens = 0
+        completion_tokens = 0
+        prompt_tokens = 0
+        total_cost = 0.0
+
+        for span in spans:
+            try:
+                # Handle both dictionary attributes and string Attributes field
+                attrs = None
+                if hasattr(span, "attributes") and span.attributes:
+                    if isinstance(span.attributes, dict):
+                        attrs = span.attributes
+                    elif isinstance(span.attributes, str):
+                        # Parse JSON string attributes
+                        attrs = json.loads(span.attributes)
+
+                # Also check for Attributes field (capitalized) from backend spans
+                if not attrs and hasattr(span, "Attributes") and span.Attributes:
+                    if isinstance(span.Attributes, str):
+                        attrs = json.loads(span.Attributes)
+                    elif isinstance(span.Attributes, dict):
+                        attrs = span.Attributes
+
+                if attrs:
+                    # Try to get usage from nested usage object (backend format)
+                    if "usage" in attrs and isinstance(attrs["usage"], dict):
+                        usage = attrs["usage"]
+                        prompt_tokens += usage.get("promptTokens", 0)
+                        completion_tokens += usage.get("completionTokens", 0)
+                        total_tokens += usage.get("totalTokens", 0)
+                        # Cost might be in usage or at root level
+                        total_cost += usage.get("cost", 0.0)
+
+                    # Also try OpenTelemetry semantic conventions (SDK format)
+                    prompt_tokens += attrs.get("gen_ai.usage.prompt_tokens", 0)
+                    completion_tokens += attrs.get("gen_ai.usage.completion_tokens", 0)
+                    total_tokens += attrs.get("gen_ai.usage.total_tokens", 0)
+                    total_cost += attrs.get("gen_ai.usage.cost", 0.0)
+                    total_cost += attrs.get("llm.usage.cost", 0.0)
+
+            except (json.JSONDecodeError, AttributeError, TypeError) as e:
+                logger.debug(f"Failed to parse span attributes: {e}")
+                continue
+
+        return {
+            "tokens": total_tokens if total_tokens > 0 else None,
+            "completionTokens": completion_tokens if completion_tokens > 0 else None,
+            "promptTokens": prompt_tokens if prompt_tokens > 0 else None,
+            "cost": total_cost if total_cost > 0 else None,
+        }
+
+    @gracefully_handle_errors
+    async def create_eval_set_run_sw(
+        self,
+        eval_set_id: str,
+        agent_snapshot: StudioWebAgentSnapshot,
+        no_of_evals: int,
+        evaluators: list[BaseLegacyEvaluator[Any]],
+        is_coded: bool = False,
+    ) -> str:
+        """Create a new evaluation set run in StudioWeb."""
+        spec = self._create_eval_set_run_spec(
+            eval_set_id, agent_snapshot, no_of_evals, is_coded
+        )
+        response = await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+        eval_set_run_id = json.loads(response.content)["id"]
+        return eval_set_run_id
+
+    @gracefully_handle_errors
+    async def create_eval_run(
+        self, eval_item: EvaluationItem, eval_set_run_id: str, is_coded: bool = False
+    ) -> str | None:
+        """Create a new evaluation run in StudioWeb.
+
+        Args:
+            eval_item: Dictionary containing evaluation data
+            eval_set_run_id: The ID of the evaluation set run
+            is_coded: Whether this is a coded evaluation (vs legacy)
+
+        Returns:
+            The ID of the created evaluation run
+        """
+        spec = self._create_eval_run_spec(eval_item, eval_set_run_id, is_coded)
+        response = await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+
+        # Parse response and extract eval_run_id
+        response_data = json.loads(response.content)
+        logger.debug(f"CREATE_EVAL_RUN response: {response_data}")
+
+        eval_run_id = response_data.get("id")
+        if not eval_run_id:
+            logger.error(f"No 'id' field in CREATE_EVAL_RUN response: {response_data}")
+            return None
+
+        return eval_run_id
+
+    @gracefully_handle_errors
+    async def update_eval_run(
+        self,
+        sw_progress_item: StudioWebProgressItem,
+        evaluators: dict[str, BaseEvaluator[Any, Any, Any]],
+        is_coded: bool = False,
+        spans: list[Any] | None = None,
+    ):
+        """Update an evaluation run with results."""
+        coded_evaluators: dict[str, BaseEvaluator[Any, Any, Any]] = {}
+        legacy_evaluators: dict[str, BaseLegacyEvaluator[Any]] = {}
+        evaluator_runs: list[dict[str, Any]] = []
+        evaluator_scores: list[dict[str, Any]] = []
+
+        for k, v in evaluators.items():
+            if isinstance(v, BaseLegacyEvaluator):
+                legacy_evaluators[k] = v
+            elif isinstance(v, BaseEvaluator):
+                coded_evaluators[k] = v
+
+        # Use coded evaluator format
+        runs, scores = self._collect_coded_results(
+            sw_progress_item.eval_results, coded_evaluators, spans or []
+        )
+        evaluator_runs.extend(runs)
+        evaluator_scores.extend(scores)
+
+        # Use legacy evaluator format
+        runs, scores = self._collect_results(
+            sw_progress_item.eval_results,
+            legacy_evaluators,
+            spans or [],
+        )
+        evaluator_runs.extend(runs)
+        evaluator_scores.extend(scores)
+
+        # Use the appropriate spec method based on evaluation type
+        if is_coded:
+            spec = self._update_coded_eval_run_spec(
+                evaluator_runs=evaluator_runs,
+                evaluator_scores=evaluator_scores,
+                eval_run_id=sw_progress_item.eval_run_id,
+                execution_time=sw_progress_item.agent_execution_time,
+                actual_output=sw_progress_item.agent_output,
+                success=sw_progress_item.success,
+                is_coded=is_coded,
+            )
+        else:
+            spec = self._update_eval_run_spec(
+                assertion_runs=evaluator_runs,
+                evaluator_scores=evaluator_scores,
+                eval_run_id=sw_progress_item.eval_run_id,
+                execution_time=sw_progress_item.agent_execution_time,
+                actual_output=sw_progress_item.agent_output,
+                success=sw_progress_item.success,
+                is_coded=is_coded,
+            )
+
+        await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+
+    @gracefully_handle_errors
+    async def update_eval_set_run(
+        self,
+        eval_set_run_id: str,
+        evaluator_scores: dict[str, float],
+        is_coded: bool = False,
+        success: bool = True,
+    ):
+        """Update the evaluation set run status to complete."""
+        spec = self._update_eval_set_run_spec(
+            eval_set_run_id, evaluator_scores, is_coded, success
+        )
+        await self._client.request_async(
+            method=spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            json=spec.json,
+            headers=spec.headers,
+            scoped="org" if self._is_localhost() else "tenant",
+        )
+
+    async def handle_create_eval_set_run(self, payload: EvalSetRunCreatedEvent) -> None:
+        try:
+            self.evaluators = {eval.id: eval for eval in payload.evaluators}
+            self.evaluator_scores = {eval.id: [] for eval in payload.evaluators}
+
+            # Store the eval set execution ID for mapping eval runs to eval set
+            self.eval_set_execution_id = payload.execution_id
+
+            # Store the eval_set_id for this execution (needed for backend API calls)
+            self.eval_set_ids[payload.execution_id] = payload.eval_set_id
+
+            # Detect if using coded evaluators and store for this execution
+            is_coded = self._is_coded_evaluator(payload.evaluators)
+            self.is_coded_eval[payload.execution_id] = is_coded
+
+            # Check if eval_set_run_id is provided (resume scenario)
+            eval_set_run_id = payload.eval_set_run_id
+            if eval_set_run_id:
+                self.user_provided_eval_set_run_ids.add(eval_set_run_id)
+                # Resume scenario: Use the provided eval_set_run_id
+                # Fetch all existing eval runs from backend to populate cache
+                self.is_resume_mode[payload.execution_id] = True
+                logger.info(
+                    f"Resume scenario: Using provided eval_set_run_id={eval_set_run_id}"
+                )
+
+                # Fetch all eval runs for this eval_set_run_id to populate cache
+                # Gracefully handle errors so we don't block the resume flow
+                try:
+                    await self.fetch_and_cache_eval_runs(
+                        eval_set_id=payload.eval_set_id,
+                        eval_set_run_id=eval_set_run_id,
+                        is_coded=is_coded,
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to fetch eval runs from backend during resume: {e}. "
+                        "Will continue with empty cache."
+                    )
+            else:
+                # Normal scenario: Create a new eval set run in the backend
+                self.is_resume_mode[payload.execution_id] = False
+                eval_set_run_id = await self.create_eval_set_run_sw(
+                    eval_set_id=payload.eval_set_id,
+                    agent_snapshot=self._extract_agent_snapshot(payload.entrypoint),
+                    no_of_evals=payload.no_of_evals,
+                    evaluators=payload.evaluators,
+                    is_coded=is_coded,
+                )
+                logger.info(f"Created new eval_set_run_id: {eval_set_run_id}")
+
+            self.eval_set_run_ids[payload.execution_id] = eval_set_run_id
+
+            current_span = trace.get_current_span()
+            if current_span.is_recording():
+                current_span.set_attribute("eval_set_run_id", eval_set_run_id)
+
+            # Do NOT set global trace_id override here
+            # Trace IDs are set per-evaluation in handle_update_eval_run()
+
+            logger.debug(
+                f"Created eval set run with ID: {eval_set_run_id} (coded={is_coded})"
+            )
+
+        except Exception as e:
+            self._format_error_message(e, "StudioWeb create eval set run error")
+
+    async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
+        try:
+            logger.info(
+                f"Processing CREATE_EVAL_RUN event: execution_id={payload.execution_id}, "
+                f"evaluation_id={payload.eval_item.id}"
+            )
+
+            # Check if we already have an eval_run_id cached
+            existing_eval_run_id = self.eval_run_ids.get(payload.execution_id)
+
+            if existing_eval_run_id:
+                # Already have eval_run_id (from previous fetch or creation)
+                logger.info(
+                    f"Using cached eval_run_id={existing_eval_run_id} for execution_id={payload.execution_id} "
+                    f"(skipping backend fetch/create)"
+                )
+                return
+
+            # Get eval_set_id, eval_set_run_id and is_coded flag
+            if not self.eval_set_execution_id:
+                logger.warning("Cannot process eval run: eval_set_execution_id not set")
+                return
+
+            eval_set_id = self.eval_set_ids.get(self.eval_set_execution_id)
+            if not eval_set_id:
+                logger.warning(
+                    f"Cannot process eval run: eval_set_id not available for eval_set_execution_id={self.eval_set_execution_id}"
+                )
+                return
+
+            eval_set_run_id = self.eval_set_run_ids.get(self.eval_set_execution_id)
+            if not eval_set_run_id:
+                logger.warning(
+                    f"Cannot process eval run: eval_set_run_id not available for eval_set_execution_id={self.eval_set_execution_id}"
+                )
+                return
+
+            is_coded = self.is_coded_eval.get(self.eval_set_execution_id, False)
+
+            # Check if we're in resume mode (eval_set_run_id was provided vs created)
+            is_resume = self.is_resume_mode.get(self.eval_set_execution_id, False)
+
+            logger.info(
+                f"Retrieved context: eval_set_id={eval_set_id}, eval_set_run_id={eval_set_run_id}, "
+                f"is_coded={is_coded}, is_resume={is_resume}, eval_set_execution_id={self.eval_set_execution_id}"
+            )
+
+            evaluation_id = payload.eval_item.id
+            eval_run_id = None
+
+            # Only fetch from backend if we're in resume mode
+            # In normal mode, we know eval runs don't exist yet (we just created eval_set_run)
+            if is_resume:
+                logger.info(
+                    f"Resume mode: Attempting to fetch existing eval_run_id from backend for evaluation_id={evaluation_id}"
+                )
+
+                # Try to fetch existing eval run from backend (resume scenario)
+                eval_run_id = await self.get_eval_run_for_evaluation(
+                    eval_set_id, eval_set_run_id, evaluation_id, is_coded
+                )
+
+                if eval_run_id:
+                    # Resume scenario: Found existing eval run in backend
+                    self.eval_run_ids[payload.execution_id] = eval_run_id
+                    logger.info(
+                        f"✓ RESUME FLOW: Successfully cached eval_run_id={eval_run_id} for "
+                        f"execution_id={payload.execution_id}, evaluation_id={evaluation_id}. "
+                        f"Loaded from backend database."
+                    )
+                else:
+                    logger.warning(
+                        f"Resume mode but no eval_run_id found in backend for evaluation_id={evaluation_id}. "
+                        f"Will create new eval run."
+                    )
+
+            # Create new eval run if not in resume mode OR if backend fetch didn't find one
+            if not eval_run_id:
+                logger.info(
+                    f"{'Normal mode' if not is_resume else 'Resume mode (no existing run found)'}: "
+                    f"Creating new eval run for evaluation_id={evaluation_id}, eval_set_run_id={eval_set_run_id}"
+                )
+
+                eval_run_id = await self.create_eval_run(
+                    payload.eval_item, eval_set_run_id, is_coded
+                )
+                if eval_run_id:
+                    # Store eval_run_id with the individual eval run's execution_id
+                    self.eval_run_ids[payload.execution_id] = eval_run_id
+
+                    logger.info(
+                        f"✓ NORMAL FLOW: Successfully created and cached eval_run_id={eval_run_id} for "
+                        f"execution_id={payload.execution_id}, evaluation_id={evaluation_id}, "
+                        f"eval_set_run_id={eval_set_run_id} (coded={is_coded})"
+                    )
+                else:
+                    logger.error(
+                        f"✗ ERROR: create_eval_run returned None for execution_id={payload.execution_id}, "
+                        f"evaluation_id={evaluation_id}, eval_set_run_id={eval_set_run_id}, is_coded={is_coded}"
+                    )
+
+        except Exception as e:
+            self._format_error_message(e, "StudioWeb create eval run error")
+
+    async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
+        try:
+            logger.info(
+                f"Processing UPDATE_EVAL_RUN event: execution_id={payload.execution_id}, "
+                f"success={payload.success}"
+            )
+
+            eval_run_id = self.eval_run_ids.get(payload.execution_id)
+
+            if not eval_run_id:
+                logger.warning(
+                    f"Cannot update eval run: eval_run_id not found in cache for "
+                    f"execution_id={payload.execution_id}. Available keys: {list(self.eval_run_ids.keys())}"
+                )
+            else:
+                logger.info(
+                    f"Found eval_run_id={eval_run_id} for execution_id={payload.execution_id} in cache"
+                )
+
+            for eval_result in payload.eval_results:
+                evaluator_id = eval_result.evaluator_id
+                if evaluator_id in self.evaluator_scores:
+                    match eval_result.result.score_type:
+                        case ScoreType.NUMERICAL:
+                            self.evaluator_scores[evaluator_id].append(
+                                eval_result.result.score
+                            )
+                        case ScoreType.BOOLEAN:
+                            self.evaluator_scores[evaluator_id].append(
+                                100 if eval_result.result.score else 0
+                            )
+                        case ScoreType.ERROR:
+                            self.evaluator_scores[evaluator_id].append(0)
+
+            if eval_run_id and self.eval_set_execution_id:
+                # Get the is_coded flag for this execution
+                is_coded = self.is_coded_eval.get(self.eval_set_execution_id, False)
+
+                logger.info(
+                    f"Sending UPDATE to backend: eval_run_id={eval_run_id}, "
+                    f"is_coded={is_coded}, success={payload.success}"
+                )
+
+                # Extract usage metrics from spans
+                self._extract_usage_from_spans(payload.spans)
+
+                await self.update_eval_run(
+                    StudioWebProgressItem(
+                        eval_run_id=eval_run_id,
+                        eval_results=payload.eval_results,
+                        success=payload.success,
+                        agent_output=payload.agent_output,
+                        agent_execution_time=payload.agent_execution_time,
+                    ),
+                    self.evaluators,
+                    is_coded=is_coded,
+                    spans=payload.spans,
+                )
+
+                logger.info(
+                    f"✓ Successfully updated eval_run_id={eval_run_id} in backend (coded={is_coded})"
+                )
+
+        except Exception as e:
+            self._format_error_message(e, "StudioWeb reporting error")
+
+    async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
+        try:
+            if eval_set_run_id := self.eval_set_run_ids.get(payload.execution_id):
+                # Skip update if eval_set_run_id was provided by user
+                if eval_set_run_id in self.user_provided_eval_set_run_ids:
+                    logger.debug(
+                        f"Skipping eval set run update for user-provided eval_set_run_id (eval_set_run_id={eval_set_run_id})"
+                    )
+                    return
+                # Get the is_coded flag for this execution
+                is_coded = self.is_coded_eval.get(payload.execution_id, False)
+                await self.update_eval_set_run(
+                    eval_set_run_id,
+                    payload.evaluator_scores,
+                    is_coded=is_coded,
+                    success=payload.success,
+                )
+                status_str = "completed" if payload.success else "failed"
+                logger.debug(
+                    f"Updated eval set run with ID: {eval_set_run_id} (coded={is_coded}, status={status_str})"
+                )
+            else:
+                logger.warning(
+                    "Cannot update eval set run: eval_set_run_id not available"
+                )
+
+        except Exception as e:
+            self._format_error_message(e, "StudioWeb update eval set run error")
+
+    async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_SET_RUN, self.handle_create_eval_set_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_RUN, self.handle_create_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_RUN, self.handle_update_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
+        )
+
+        logger.debug("StudioWeb progress reporter subscribed to evaluation events")
+
+    def _serialize_justification(
+        self, justification: BaseModel | str | None
+    ) -> str | None:
+        """Serialize justification to JSON string for API compatibility.
+
+        Args:
+            justification: The justification object which could be None, a BaseModel,
+                          a string, or any other JSON-serializable object
+
+        Returns:
+            JSON string representation or None if justification is None
+        """
+        if isinstance(justification, BaseModel):
+            justification = json.dumps(justification.model_dump())
+
+        return justification
+
+    def _extract_agent_snapshot(self, entrypoint: str | None) -> StudioWebAgentSnapshot:
+        """Extract agent snapshot from entry points configuration or low-code agent file.
+
+        For coded agents, reads from entry-points.json configuration file.
+        For low-code agents (*.json files like agent.json), reads inputSchema
+        and outputSchema directly from the agent file.
+
+        Args:
+            entrypoint: The entrypoint file path to look up
+
+        Returns:
+            StudioWebAgentSnapshot with input and output schemas
+        """
+        if not entrypoint:
+            logger.warning(
+                "Entrypoint not provided - falling back to empty inputSchema "
+                "and outputSchema"
+            )
+            return StudioWebAgentSnapshot(input_schema={}, output_schema={})
+
+        try:
+            # Check if entrypoint is a low-code agent JSON file (e.g., agent.json)
+            if entrypoint.endswith(".json"):
+                agent_file_path = os.path.join(os.getcwd(), entrypoint)
+                if os.path.exists(agent_file_path):
+                    with open(agent_file_path, "r") as f:
+                        agent_data = json.load(f)
+
+                    # Low-code agent files have inputSchema and outputSchema at root
+                    input_schema = agent_data.get("inputSchema", {})
+                    output_schema = agent_data.get("outputSchema", {})
+
+                    logger.debug(
+                        f"Extracted agent snapshot from low-code agent '{entrypoint}': "
+                        f"inputSchema={json.dumps(input_schema)}, "
+                        f"outputSchema={json.dumps(output_schema)}"
+                    )
+
+                    return StudioWebAgentSnapshot(
+                        input_schema=input_schema, output_schema=output_schema
+                    )
+
+            # Fall back to entry-points.json for coded agents
+            entry_points_file_path = os.path.join(
+                os.getcwd(), str(UiPathConfig.entry_points_file_path)
+            )
+            if not os.path.exists(entry_points_file_path):
+                logger.debug(
+                    f"Entry points file not found at {entry_points_file_path}, "
+                    "using empty schemas"
+                )
+                return StudioWebAgentSnapshot(input_schema={}, output_schema={})
+
+            with open(entry_points_file_path, "r") as f:
+                entry_points = json.load(f).get("entryPoints", [])
+
+            ep = None
+            for entry_point in entry_points:
+                if entry_point.get("filePath") == entrypoint:
+                    ep = entry_point
+                    break
+
+            if not ep:
+                logger.warning(
+                    f"Entrypoint {entrypoint} not found in configuration file"
+                )
+                return StudioWebAgentSnapshot(input_schema={}, output_schema={})
+
+            input_schema = ep.get("input", {})
+            output_schema = ep.get("output", {})
+
+            logger.debug(
+                f"Extracted agent snapshot for entrypoint '{entrypoint}': "
+                f"inputSchema={json.dumps(input_schema)}, "
+                f"outputSchema={json.dumps(output_schema)}"
+            )
+
+            return StudioWebAgentSnapshot(
+                input_schema=input_schema, output_schema=output_schema
+            )
+        except Exception as e:
+            logger.warning(f"Failed to extract agent snapshot: {e}")
+            return StudioWebAgentSnapshot(input_schema={}, output_schema={})
+
+    @staticmethod
+    def _build_assertion_properties(
+        evaluator: BaseLegacyEvaluator[Any],
+    ) -> dict[str, Any]:
+        """Build assertionProperties dict with prompt and model if available."""
+        properties: dict[str, Any] = {}
+        if hasattr(evaluator, "prompt") and isinstance(evaluator.prompt, str):
+            properties["prompt"] = evaluator.prompt
+        if hasattr(evaluator, "model") and isinstance(evaluator.model, str):
+            properties["model"] = evaluator.model
+        return properties
+
+    @staticmethod
+    def _build_evaluator_snapshot(
+        evaluator: BaseEvaluator[Any, Any, Any],
+    ) -> dict[str, Any]:
+        """Build evaluatorSnapshot dict with prompt and model if available."""
+        snapshot: dict[str, Any] = {}
+        config = getattr(evaluator, "evaluator_config", None)
+        if config is not None:
+            if hasattr(config, "prompt") and isinstance(config.prompt, str):
+                snapshot["prompt"] = config.prompt
+            if hasattr(config, "model") and isinstance(config.model, str):
+                snapshot["model"] = config.model
+        return snapshot
+
+    def _collect_results(
+        self,
+        eval_results: list[EvalItemResult],
+        evaluators: dict[str, BaseLegacyEvaluator[Any]],
+        spans: list[Any],
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        assertion_runs: list[dict[str, Any]] = []
+        evaluator_scores_list: list[dict[str, Any]] = []
+
+        # Extract usage metrics from spans
+        usage_metrics = self._extract_usage_from_spans(spans)
+
+        for eval_result in eval_results:
+            # Skip results for evaluators not in the provided dict
+            # (happens when processing mixed coded/legacy eval sets)
+            if eval_result.evaluator_id not in evaluators:
+                continue
+
+            # Legacy API expects evaluatorId as GUID, convert string to GUID
+            try:
+                uuid.UUID(eval_result.evaluator_id)
+                evaluator_id_value = eval_result.evaluator_id
+            except ValueError:
+                # Generate deterministic UUID5 from string
+                evaluator_id_value = str(
+                    uuid.uuid5(uuid.NAMESPACE_DNS, eval_result.evaluator_id)
+                )
+
+            # Convert BaseModel justification to JSON string for API compatibility
+            justification = self._serialize_justification(eval_result.result.details)
+
+            evaluator_scores_list.append(
+                {
+                    "type": eval_result.result.score_type.value,
+                    "value": eval_result.result.score,
+                    "justification": justification,
+                    "evaluatorId": evaluator_id_value,
+                }
+            )
+            assertion_runs.append(
+                {
+                    "status": EvaluationStatus.COMPLETED.value,
+                    "evaluatorId": evaluator_id_value,
+                    "completionMetrics": {
+                        "duration": int(eval_result.result.evaluation_time * 1000)
+                        if eval_result.result.evaluation_time
+                        else 0,
+                        "cost": usage_metrics["cost"],
+                        "tokens": usage_metrics["tokens"] or 0,
+                        "completionTokens": usage_metrics["completionTokens"] or 0,
+                        "promptTokens": usage_metrics["promptTokens"] or 0,
+                    },
+                    "assertionSnapshot": {
+                        "assertionType": evaluators[eval_result.evaluator_id].type.name,
+                        "outputKey": evaluators[
+                            eval_result.evaluator_id
+                        ].target_output_key,
+                        "assertionProperties": self._build_assertion_properties(
+                            evaluators[eval_result.evaluator_id]
+                        ),
+                    },
+                }
+            )
+        return assertion_runs, evaluator_scores_list
+
+    def _collect_coded_results(
+        self,
+        eval_results: list[EvalItemResult],
+        evaluators: dict[str, BaseEvaluator[Any, Any, Any]],
+        spans: list[Any],
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        """Collect results for coded evaluators.
+
+        Returns evaluatorRuns and scores in the format expected by coded eval endpoints.
+        """
+        evaluator_runs: list[dict[str, Any]] = []
+        evaluator_scores_list: list[dict[str, Any]] = []
+
+        # Extract usage metrics from spans
+        usage_metrics = self._extract_usage_from_spans(spans)
+
+        for eval_result in eval_results:
+            # Skip results for evaluators not in the provided dict
+            # (happens when processing mixed coded/legacy eval sets)
+            if eval_result.evaluator_id not in evaluators:
+                continue
+
+            # Convert BaseModel justification to JSON string for API compatibility
+            justification = self._serialize_justification(eval_result.result.details)
+
+            evaluator_scores_list.append(
+                {
+                    "type": eval_result.result.score_type.value,
+                    "value": eval_result.result.score,
+                    "justification": justification,
+                    "evaluatorId": eval_result.evaluator_id,
+                }
+            )
+            evaluator_run: dict[str, Any] = {
+                "status": EvaluationStatus.COMPLETED.value,
+                "evaluatorId": eval_result.evaluator_id,
+                "result": {
+                    "score": {
+                        "type": eval_result.result.score_type.value,
+                        "value": eval_result.result.score,
+                    },
+                    "justification": justification,
+                },
+                "completionMetrics": {
+                    "duration": int(eval_result.result.evaluation_time * 1000)
+                    if eval_result.result.evaluation_time
+                    else 0,
+                    "cost": usage_metrics["cost"],
+                    "tokens": usage_metrics["tokens"] or 0,
+                    "completionTokens": usage_metrics["completionTokens"] or 0,
+                    "promptTokens": usage_metrics["promptTokens"] or 0,
+                },
+            }
+            snapshot = self._build_evaluator_snapshot(
+                evaluators[eval_result.evaluator_id]
+            )
+            if snapshot:
+                evaluator_run["evaluatorSnapshot"] = snapshot
+            evaluator_runs.append(evaluator_run)
+        return evaluator_runs, evaluator_scores_list
+
+    @staticmethod
+    def _resolve_project_files_source() -> int | None:
+        raw = os.getenv("UIPATH_PROJECT_FILES_SOURCE")
+        if not raw:
+            return None
+        normalized = raw.strip().lower()
+        if normalized == "local":
+            return 1
+        if normalized == "cloud":
+            return 0
+        try:
+            return int(normalized)
+        except ValueError:
+            logger.warning(
+                f"Unrecognized UIPATH_PROJECT_FILES_SOURCE value: {raw!r}; ignoring."
+            )
+            return None
+
+    def _project_files_source_field(self) -> dict[str, int]:
+        if self._project_files_source is None:
+            return {}
+        return {"projectFilesSource": self._project_files_source}
+
+    def _update_eval_run_spec(
+        self,
+        assertion_runs: list[dict[str, Any]],
+        evaluator_scores: list[dict[str, Any]],
+        eval_run_id: str,
+        actual_output: dict[str, Any],
+        execution_time: float,
+        success: bool,
+        is_coded: bool = False,
+    ) -> RequestSpec:
+        # For legacy evaluations, endpoint is without /coded
+        endpoint_suffix = "coded/" if is_coded else ""
+
+        # Determine status based on success
+        status = EvaluationStatus.COMPLETED if success else EvaluationStatus.FAILED
+
+        inner_payload: dict[str, Any] = {
+            "evalRunId": eval_run_id,
+            # Backend expects integer status
+            "status": status.value,
+            "result": {
+                "output": dict(actual_output),
+                "evaluatorScores": evaluator_scores,
+            },
+            "completionMetrics": {"duration": int(execution_time * 1000)},
+            "assertionRuns": assertion_runs,
+            **self._project_files_source_field(),
+        }
+
+        # Legacy backend expects payload wrapped in "request" field
+        # Coded backend accepts payload directly
+        # Both coded and legacy send payload directly at root level
+        payload = inner_payload
+
+        # Log the payload for debugging eval run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Updating eval run (type={agent_type}): "
+            f"evalRunId={eval_run_id}, success={success}"
+        )
+        logger.debug(f"Full eval run update payload: {json.dumps(payload, indent=2)}")
+
+        return RequestSpec(
+            method="PUT",
+            endpoint=Endpoint(
+                f"{self._get_endpoint_prefix()}execution/agents/{self._agent_id}/{endpoint_suffix}evalRun"
+            ),
+            json=payload,
+            headers=self._tenant_header(),
+        )
+
+    def _update_coded_eval_run_spec(
+        self,
+        evaluator_runs: list[dict[str, Any]],
+        evaluator_scores: list[dict[str, Any]],
+        eval_run_id: str,
+        actual_output: dict[str, Any],
+        execution_time: float,
+        success: bool,
+        is_coded: bool = False,
+    ) -> RequestSpec:
+        """Create update spec for coded evaluators."""
+        # For coded evaluations, endpoint has /coded
+        endpoint_suffix = "coded/" if is_coded else ""
+
+        # Determine status based on success
+        status = EvaluationStatus.COMPLETED if success else EvaluationStatus.FAILED
+
+        payload: dict[str, Any] = {
+            "evalRunId": eval_run_id,
+            # For coded evaluations, use integer status; for legacy, use string
+            "status": status.value,
+            "result": {
+                "output": dict(actual_output),
+                "scores": evaluator_scores,
+            },
+            "completionMetrics": {"duration": int(execution_time * 1000)},
+            "evaluatorRuns": evaluator_runs,
+            **self._project_files_source_field(),
+        }
+
+        # Log the payload for debugging coded eval run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Updating coded eval run (type={agent_type}): "
+            f"evalRunId={eval_run_id}, success={success}"
+        )
+        logger.debug(
+            f"Full coded eval run update payload: {json.dumps(payload, indent=2)}"
+        )
+
+        return RequestSpec(
+            method="PUT",
+            endpoint=Endpoint(
+                f"{self._get_endpoint_prefix()}execution/agents/{self._agent_id}/{endpoint_suffix}evalRun"
+            ),
+            json=payload,
+            headers=self._tenant_header(),
+        )
+
+    def _create_eval_run_spec(
+        self, eval_item: EvaluationItem, eval_set_run_id: str, is_coded: bool = False
+    ) -> RequestSpec:
+        # Legacy API expects eval IDs as GUIDs, coded accepts strings
+        # Convert string IDs to deterministic GUIDs for legacy
+        if is_coded:
+            eval_item_id = eval_item.id
+        else:
+            # Try to parse as GUID, if it fails, generate deterministic GUID from string
+            try:
+                uuid.UUID(eval_item.id)
+                eval_item_id = eval_item.id
+            except ValueError:
+                # Generate deterministic UUID5 from string
+                eval_item_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, eval_item.id))
+
+        # Build eval snapshot based on evaluation item type
+        eval_snapshot = {
+            "id": eval_item_id,
+            "name": eval_item.name,
+            "inputs": eval_item.inputs,
+        }
+
+        # For coded evaluators, use evaluationCriterias directly
+        # For legacy evaluators, extract expectedOutput from the migrated evaluationCriterias
+        # (Legacy evals are migrated to EvaluationItem format with expectedOutput inside evaluationCriterias)
+        if is_coded:
+            eval_snapshot["evaluationCriterias"] = eval_item.evaluation_criterias
+        else:
+            # Legacy backend endpoint expects expectedOutput directly in evalSnapshot
+            # Extract it from the first evaluator criteria (all criteria have the same expectedOutput)
+            expected_output = {}
+            if eval_item.evaluation_criterias:
+                first_criteria = next(
+                    iter(eval_item.evaluation_criterias.values()), None
+                )
+                if first_criteria and isinstance(first_criteria, dict):
+                    expected_output = first_criteria.get("expectedOutput", {})
+            eval_snapshot["expectedOutput"] = expected_output
+
+        # For legacy evaluations, endpoint is without /coded
+        endpoint_suffix = "coded/" if is_coded else ""
+
+        inner_payload: dict[str, Any] = {
+            "evalSetRunId": eval_set_run_id,
+            "evalSnapshot": eval_snapshot,
+            # Backend expects integer status
+            "status": EvaluationStatus.IN_PROGRESS.value,
+            **self._project_files_source_field(),
+        }
+
+        # Legacy backend expects payload wrapped in "request" field
+        # Coded backend accepts payload directly
+        # Both coded and legacy send payload directly at root level
+        payload = inner_payload
+
+        # Log the payload for debugging eval run reporting
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Creating eval run (type={agent_type}): "
+            f"evalSetRunId={eval_set_run_id}, evalItemId={eval_item.id}"
+        )
+        logger.debug(f"Full eval run payload: {json.dumps(payload, indent=2)}")
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"{self._get_endpoint_prefix()}execution/agents/{self._agent_id}/{endpoint_suffix}evalRun"
+            ),
+            json=payload,
+            headers=self._tenant_header(),
+        )
+
+    def _create_eval_set_run_spec(
+        self,
+        eval_set_id: str,
+        agent_snapshot: StudioWebAgentSnapshot,
+        no_of_evals: int,
+        is_coded: bool = False,
+    ) -> RequestSpec:
+        # For legacy evaluations, endpoint is without /coded
+        endpoint_suffix = "coded/" if is_coded else ""
+
+        # Legacy API expects evalSetId as GUID, coded accepts string
+        # Convert string IDs to deterministic GUIDs for legacy
+        if is_coded:
+            eval_set_id_value = eval_set_id
+        else:
+            # Try to parse as GUID, if it fails, generate deterministic GUID from string
+            try:
+                uuid.UUID(eval_set_id)
+                eval_set_id_value = eval_set_id
+            except ValueError:
+                # Generate deterministic UUID5 from string
+                eval_set_id_value = str(uuid.uuid5(uuid.NAMESPACE_DNS, eval_set_id))
+
+        inner_payload: dict[str, Any] = {
+            "agentId": self._agent_id,
+            "evalSetId": eval_set_id_value,
+            "agentSnapshot": agent_snapshot.model_dump(by_alias=True),
+            # Backend expects integer status
+            "status": EvaluationStatus.IN_PROGRESS.value,
+            "numberOfEvalsExecuted": no_of_evals,
+            # Source is required by the backend (0 = coded SDK)
+            "source": 0,
+            **self._project_files_source_field(),
+        }
+
+        # Both coded and legacy send payload directly at root level
+        payload = inner_payload
+
+        # Log the payload for debugging eval set run reporting
+        agent_type = "coded" if is_coded else "low-code"
+        logger.info(
+            f"Creating eval set run (type={agent_type}): "
+            f"evalSetId={eval_set_id}, "
+            f"inputSchema={json.dumps(payload.get('agentSnapshot', {}).get('inputSchema', {}))}, "
+            f"outputSchema={json.dumps(payload.get('agentSnapshot', {}).get('outputSchema', {}))}"
+        )
+        logger.debug(f"Full eval set run payload: {json.dumps(payload, indent=2)}")
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"{self._get_endpoint_prefix()}execution/agents/{self._agent_id}/{endpoint_suffix}evalSetRun"
+            ),
+            json=payload,
+            headers=self._tenant_header(),
+        )
+
+    def _update_eval_set_run_spec(
+        self,
+        eval_set_run_id: str,
+        evaluator_scores: dict[str, float],
+        is_coded: bool = False,
+        success: bool = True,
+    ) -> RequestSpec:
+        # Legacy API expects evaluatorId as GUID, coded accepts string
+        evaluator_scores_list = []
+        for evaluator_id, avg_score in evaluator_scores.items():
+            if is_coded:
+                evaluator_id_value = evaluator_id
+            else:
+                # Convert string to GUID for legacy
+                try:
+                    uuid.UUID(evaluator_id)
+                    evaluator_id_value = evaluator_id
+                except ValueError:
+                    # Generate deterministic UUID5 from string
+                    evaluator_id_value = str(
+                        uuid.uuid5(uuid.NAMESPACE_DNS, evaluator_id)
+                    )
+
+            evaluator_scores_list.append(
+                {"value": avg_score, "evaluatorId": evaluator_id_value}
+            )
+
+        # For legacy evaluations, endpoint is without /coded
+        endpoint_suffix = "coded/" if is_coded else ""
+
+        # Determine status based on success
+        status = EvaluationStatus.COMPLETED if success else EvaluationStatus.FAILED
+
+        inner_payload: dict[str, Any] = {
+            "evalSetRunId": eval_set_run_id,
+            # Backend expects integer status
+            "status": status.value,
+            "evaluatorScores": evaluator_scores_list,
+            **self._project_files_source_field(),
+        }
+
+        # Legacy backend expects payload wrapped in "request" field
+        # Coded backend accepts payload directly
+        # Both coded and legacy send payload directly at root level
+        payload = inner_payload
+
+        # Log the payload for debugging eval set run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.info(
+            f"Updating eval set run (type={agent_type}): "
+            f"evalSetRunId={eval_set_run_id}, success={success}, "
+            f"evaluatorScores={json.dumps(payload.get('evaluatorScores', []))}"
+        )
+        logger.debug(
+            f"Full eval set run update payload: {json.dumps(payload, indent=2)}"
+        )
+
+        return RequestSpec(
+            method="PUT",
+            endpoint=Endpoint(
+                f"{self._get_endpoint_prefix()}execution/agents/{self._agent_id}/{endpoint_suffix}evalSetRun"
+            ),
+            json=payload,
+            headers=self._tenant_header(),
+        )
+
+    def _get_eval_runs_spec(
+        self,
+        eval_set_id: str,
+        eval_set_run_id: str,
+        evaluation_id: str | None = None,
+        is_coded: bool = False,
+    ) -> RequestSpec:
+        """Create request spec to GET eval runs for a given eval_set_run_id.
+
+        Args:
+            eval_set_id: The ID of the eval set
+            eval_set_run_id: The ID of the eval set run
+            evaluation_id: Optional evaluation ID to filter for a specific eval run
+            is_coded: Whether this is a coded evaluation (vs legacy)
+
+        Returns:
+            RequestSpec for the GET request
+        """
+        # Build endpoint path matching backend structure:
+        # Legacy: api/execution/agents/{agentId}/evalSets/{evalSetId}/evalSetRuns/{evalSetRunId}/evalRuns
+        # Coded: api/execution/agents/{agentId}/coded/evalSets/{evalSetId}/evalSetRuns/{evalSetRunId}/evalRuns
+
+        prefix = self._get_endpoint_prefix()
+
+        if is_coded:
+            endpoint_path = (
+                f"{prefix}execution/agents/{self._agent_id}/coded/"
+                f"evalSets/{eval_set_id}/evalSetRuns/{eval_set_run_id}/evalRuns"
+            )
+        else:
+            endpoint_path = (
+                f"{prefix}execution/agents/{self._agent_id}/"
+                f"evalSets/{eval_set_id}/evalSetRuns/{eval_set_run_id}/evalRuns"
+            )
+
+        logger.debug(
+            f"Creating GET eval runs spec: eval_set_id={eval_set_id}, "
+            f"eval_set_run_id={eval_set_run_id}, evaluation_id={evaluation_id}, coded={is_coded}"
+        )
+
+        # The backend's listing endpoint filters by projectFilesSource +
+        # cloudUserId so the UI only shows the caller's local rows. Mirror
+        # that here so resume lookups match the row written by the same
+        # worker session.
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(endpoint_path),
+            params=self._project_files_source_field(),
+            headers=self._tenant_header(),
+        )
+
+    def _tenant_header(self) -> dict[str, str | None]:
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+        if not tenant_id:
+            self._console.error(
+                f"{ENV_TENANT_ID} env var is not set. Please run 'uipath auth'."
+            )
+        return {HEADER_INTERNAL_TENANT_ID: tenant_id}
diff --git a/packages/uipath/src/uipath/_cli/_evals/_telemetry.py b/packages/uipath/src/uipath/_cli/_evals/_telemetry.py
new file mode 100644
index 000000000..bdbdc67f7
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_evals/_telemetry.py
@@ -0,0 +1,345 @@
+"""Telemetry subscriber for sending evaluation events to Application Insights.
+
+This subscriber listens to evaluation lifecycle events and sends custom telemetry
+events to Application Insights for monitoring and analytics.
+"""
+
+import logging
+import os
+import time
+from typing import Any
+
+from uipath._cli._utils._common import get_claim_from_token
+from uipath.core.events import EventBus
+from uipath.eval.runtime.events import (
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+from uipath.platform.common import UiPathConfig
+from uipath.telemetry._track import is_telemetry_enabled, track_event
+
+logger = logging.getLogger(__name__)
+
+# Telemetry event names for Application Insights
+EVAL_SET_RUN_STARTED = "EvalSetRun.Start"
+EVAL_SET_RUN_COMPLETED = "EvalSetRun.End"
+EVAL_SET_RUN_FAILED = "EvalSetRun.Failed"
+EVAL_RUN_STARTED = "EvalRun.Start"
+EVAL_RUN_COMPLETED = "EvalRun.End"
+EVAL_RUN_FAILED = "EvalRun.Failed"
+
+
+class EvalTelemetrySubscriber:
+    """Subscribes to evaluation events and sends telemetry to Application Insights.
+
+    This subscriber listens to the evaluation event bus and tracks:
+    - Eval set run start/complete/fail events
+    - Eval run start/complete/fail events
+
+    Telemetry is sent asynchronously and failures are silently ignored to ensure
+    evaluation execution is never blocked by telemetry issues.
+
+    Usage:
+        event_bus = EventBus()
+        telemetry_subscriber = EvalTelemetrySubscriber()
+        await telemetry_subscriber.subscribe_to_eval_runtime_events(event_bus)
+    """
+
+    def __init__(self) -> None:
+        """Initialize the telemetry subscriber."""
+        self._eval_set_start_times: dict[str, float] = {}
+        self._eval_run_start_times: dict[str, float] = {}
+        self._eval_set_info: dict[str, dict[str, Any]] = {}
+        self._eval_run_info: dict[str, dict[str, Any]] = {}
+        self._current_eval_set_run_id: str | None = None
+        self._current_entrypoint: str | None = None
+
+    @staticmethod
+    def _get_agent_type(entrypoint: str) -> str:
+        """Determine agent type from entrypoint.
+
+        Args:
+            entrypoint: The entrypoint path.
+
+        Returns:
+            "LowCode" if entrypoint is "agent.json", "Coded" otherwise.
+        """
+        if entrypoint == "agent.json":
+            return "LowCode"
+        return "Coded"
+
+    async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
+        """Subscribe to evaluation runtime events.
+
+        Args:
+            event_bus: The event bus to subscribe to.
+        """
+        if not is_telemetry_enabled():
+            return
+
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_SET_RUN, self._on_eval_set_run_created
+        )
+        event_bus.subscribe(EvaluationEvents.CREATE_EVAL_RUN, self._on_eval_run_created)
+        event_bus.subscribe(EvaluationEvents.UPDATE_EVAL_RUN, self._on_eval_run_updated)
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_SET_RUN, self._on_eval_set_run_updated
+        )
+
+    async def _on_eval_set_run_created(self, event: EvalSetRunCreatedEvent) -> None:
+        """Handle eval set run created event.
+
+        Args:
+            event: The eval set run created event.
+        """
+        try:
+            self._eval_set_start_times[event.execution_id] = time.time()
+
+            eval_set_run_id = event.eval_set_run_id or event.execution_id
+
+            self._eval_set_info[event.execution_id] = {
+                "eval_set_id": event.eval_set_id,
+                "eval_set_run_id": eval_set_run_id,
+                "entrypoint": event.entrypoint,
+                "no_of_evals": event.no_of_evals,
+                "evaluator_count": len(event.evaluators),
+            }
+
+            # Store for child events
+            self._current_eval_set_run_id = eval_set_run_id
+            self._current_entrypoint = event.entrypoint
+
+            properties: dict[str, Any] = {
+                "EvalSetId": event.eval_set_id,
+                "EvalSetRunId": eval_set_run_id,
+                "Entrypoint": event.entrypoint,
+                "EvalCount": event.no_of_evals,
+                "EvaluatorCount": len(event.evaluators),
+                "AgentType": self._get_agent_type(event.entrypoint),
+                "Runtime": "URT",
+            }
+
+            self._enrich_properties(properties)
+
+            track_event(EVAL_SET_RUN_STARTED, properties)
+
+        except Exception as e:
+            logger.debug(f"Error tracking eval set run started: {e}")
+
+    async def _on_eval_run_created(self, event: EvalRunCreatedEvent) -> None:
+        """Handle eval run created event.
+
+        Args:
+            event: The eval run created event.
+        """
+        try:
+            self._eval_run_start_times[event.execution_id] = time.time()
+            self._eval_run_info[event.execution_id] = {
+                "eval_item_id": event.eval_item.id,
+                "eval_item_name": event.eval_item.name,
+            }
+
+            properties: dict[str, Any] = {
+                "EvalId": event.eval_item.id,
+                "EvalName": event.eval_item.name,
+                "Runtime": "URT",
+            }
+
+            # Add eval set run id from parent
+            if self._current_eval_set_run_id:
+                properties["EvalSetRunId"] = self._current_eval_set_run_id
+
+            # Add entrypoint and agent type
+            if self._current_entrypoint:
+                properties["Entrypoint"] = self._current_entrypoint
+                properties["AgentType"] = self._get_agent_type(self._current_entrypoint)
+
+            self._enrich_properties(properties)
+
+            track_event(EVAL_RUN_STARTED, properties)
+
+        except Exception as e:
+            logger.debug(f"Error tracking eval run started: {e}")
+
+    async def _on_eval_run_updated(self, event: EvalRunUpdatedEvent) -> None:
+        """Handle eval run updated (completed/failed) event.
+
+        Args:
+            event: The eval run updated event.
+        """
+        try:
+            # Calculate duration
+            start_time = self._eval_run_start_times.pop(event.execution_id, None)
+            duration_ms = int((time.time() - start_time) * 1000) if start_time else None
+
+            # Get stored info
+            run_info = self._eval_run_info.pop(event.execution_id, {})
+
+            # Calculate average score
+            scores = [
+                r.result.score for r in event.eval_results if r.result.score is not None
+            ]
+            avg_score = sum(scores) / len(scores) if scores else None
+
+            # Try to get trace ID from spans
+            trace_id: str | None = None
+            if event.spans:
+                for span in event.spans:
+                    if span.context and span.context.trace_id:
+                        # Format trace ID as hex string
+                        trace_id = format(span.context.trace_id, "032x")
+                        break
+
+            properties: dict[str, Any] = {
+                "EvalId": run_info.get("eval_item_id", event.eval_item.id),
+                "EvalName": run_info.get("eval_item_name", event.eval_item.name),
+                "Success": event.success,
+                "EvaluatorCount": len(event.eval_results),
+                "Runtime": "URT",
+            }
+
+            if self._current_eval_set_run_id:
+                properties["EvalSetRunId"] = self._current_eval_set_run_id
+
+            if self._current_entrypoint:
+                properties["Entrypoint"] = self._current_entrypoint
+                properties["AgentType"] = self._get_agent_type(self._current_entrypoint)
+
+            if trace_id:
+                properties["TraceId"] = trace_id
+
+            if duration_ms is not None:
+                properties["DurationMs"] = duration_ms
+
+            if avg_score is not None:
+                properties["AverageScore"] = avg_score
+
+            if event.agent_execution_time:
+                properties["AgentExecutionTimeMs"] = int(
+                    event.agent_execution_time * 1000
+                )
+
+            if event.exception_details:
+                properties["ErrorType"] = type(
+                    event.exception_details.exception
+                ).__name__
+                properties["ErrorMessage"] = str(event.exception_details.exception)[
+                    :500
+                ]
+                properties["IsRuntimeException"] = (
+                    event.exception_details.runtime_exception
+                )
+
+            self._enrich_properties(properties)
+
+            event_name = EVAL_RUN_COMPLETED if event.success else EVAL_RUN_FAILED
+            track_event(event_name, properties)
+
+        except Exception as e:
+            logger.debug(f"Error tracking eval run updated: {e}")
+
+    async def _on_eval_set_run_updated(self, event: EvalSetRunUpdatedEvent) -> None:
+        """Handle eval set run updated (completed/failed) event.
+
+        Args:
+            event: The eval set run updated event.
+        """
+        try:
+            # Calculate duration
+            start_time = self._eval_set_start_times.pop(event.execution_id, None)
+            duration_ms = int((time.time() - start_time) * 1000) if start_time else None
+
+            # Get stored info
+            set_info = self._eval_set_info.pop(event.execution_id, {})
+
+            # Calculate overall average score
+            scores = list(event.evaluator_scores.values())
+            avg_score = sum(scores) / len(scores) if scores else None
+
+            properties: dict[str, Any] = {
+                "EvalSetId": set_info.get("eval_set_id", "unknown"),
+                "Success": event.success,
+                "EvaluatorCount": len(event.evaluator_scores),
+            }
+
+            if set_info.get("eval_set_run_id"):
+                properties["EvalSetRunId"] = set_info["eval_set_run_id"]
+
+            if set_info.get("entrypoint"):
+                properties["Entrypoint"] = set_info["entrypoint"]
+                properties["AgentType"] = self._get_agent_type(set_info["entrypoint"])
+
+            properties["Runtime"] = "URT"
+
+            if set_info.get("no_of_evals"):
+                properties["EvalCount"] = set_info["no_of_evals"]
+
+            if duration_ms is not None:
+                properties["DurationMs"] = duration_ms
+
+            if avg_score is not None:
+                properties["AverageScore"] = avg_score
+
+            # Add individual evaluator scores
+            for evaluator_id, score in event.evaluator_scores.items():
+                # Sanitize evaluator ID for use as property key
+                safe_key = f"Score_{evaluator_id.replace('-', '_')[:50]}"
+                properties[safe_key] = score
+
+            self._enrich_properties(properties)
+
+            event_name = (
+                EVAL_SET_RUN_COMPLETED if event.success else EVAL_SET_RUN_FAILED
+            )
+            track_event(event_name, properties)
+
+            self._current_eval_set_run_id = None
+            self._current_entrypoint = None
+
+        except Exception as e:
+            logger.debug(f"Error tracking eval set run updated: {e}")
+
+    def _enrich_properties(self, properties: dict[str, Any]) -> None:
+        """Enrich properties with common context information.
+
+        Args:
+            properties: The properties dictionary to enrich.
+        """
+        from uipath.platform.common._span_utils import resolve_project_id
+
+        if UiPathConfig.project_id:
+            properties["ProjectId"] = UiPathConfig.project_id
+        if agent_id := resolve_project_id():
+            properties["AgentId"] = agent_id
+
+        if UiPathConfig.organization_id:
+            properties["CloudOrganizationId"] = UiPathConfig.organization_id
+
+        cloud_user_id = UiPathConfig.cloud_user_id
+        if not cloud_user_id:
+            try:
+                cloud_user_id = get_claim_from_token("sub")
+            except Exception:
+                cloud_user_id = None
+        if cloud_user_id:
+            properties["CloudUserId"] = cloud_user_id
+
+        tenant_id = os.getenv("UIPATH_TENANT_ID")
+        if tenant_id:
+            properties["TenantId"] = tenant_id
+
+        # Origin of the eval-set run as classified by the caller (e.g. Manual,
+        # Protegi, FirstSuccessfulRun). The Agents backend forwards the value
+        # via UIPATH_EVAL_RUN_SOURCE so adoption dashboards can exclude
+        # auto-triggered runs (e.g. first-successful-run) from user-driven counts.
+        # Distinct from the `Source` dimension below, which categorises the SDK
+        # emitter ("uipath-python-cli"), not the run origin.
+        run_source = os.getenv("UIPATH_EVAL_RUN_SOURCE")
+        if run_source:
+            properties["RunSource"] = run_source
+
+        properties["Source"] = "uipath-python-cli"
+        properties["ApplicationName"] = "UiPath.Eval"
diff --git a/packages/uipath/src/uipath/_cli/_push/_resolvers.py b/packages/uipath/src/uipath/_cli/_push/_resolvers.py
new file mode 100644
index 000000000..e609014d5
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/_resolvers.py
@@ -0,0 +1,177 @@
+from typing import AsyncIterator
+
+from uipath.platform.connections import ConnectionsService
+from uipath.platform.errors import EnrichedException, FolderNotFoundException
+from uipath.platform.resource_catalog import (
+    Resource,
+    ResourceCatalogService,
+    ResourceType,
+)
+
+from .._utils._studio_project import (
+    ReferencedResourceFolder,
+    ReferencedResourceRequest,
+    VirtualResourceRequest,
+)
+from ..models.runtime_schema import BindingResource, Bindings
+from ._resource_actions import CreateReference, CreateVirtual, ResourceAction, Skip
+
+_NOT_FOUND_SUFFIX = "was not found and will not be added to the solution."
+
+
+async def resolve_bindings(
+    bindings: Bindings,
+    resource_catalog: ResourceCatalogService,
+    connections: ConnectionsService,
+    supported_virtual_kinds: set[str],
+) -> AsyncIterator[ResourceAction]:
+    """Yield one ResourceAction per importable binding.
+
+    Bindings that should be silently ignored (e.g. guardrail bindings without a
+    folderPath) are filtered out here.
+    """
+    for binding in bindings.resources:
+        action = await _resolve_binding(
+            binding, resource_catalog, connections, supported_virtual_kinds
+        )
+        if action is not None:
+            yield action
+
+
+async def _resolve_binding(
+    binding: BindingResource,
+    resource_catalog: ResourceCatalogService,
+    connections: ConnectionsService,
+    supported_virtual_kinds: set[str],
+) -> ResourceAction | None:
+    if binding.resource == "connection":
+        return await _resolve_connection(binding, resource_catalog, connections)
+    return await _resolve_regular(binding, resource_catalog, supported_virtual_kinds)
+
+
+async def _resolve_connection(
+    binding: BindingResource,
+    resource_catalog: ResourceCatalogService,
+    connections: ConnectionsService,
+) -> ResourceAction | None:
+    connection_id_value = binding.value.get("ConnectionId")
+    if connection_id_value is None:
+        raise ValueError(
+            f"Connection binding {binding.key!r} is missing required field 'ConnectionId'"
+        )
+    connection_key = connection_id_value.default_value
+
+    try:
+        connection = await connections.retrieve_async(connection_key)
+    except EnrichedException:
+        connector_name = (binding.metadata or {}).get("Connector")
+        return Skip(
+            message=(
+                f"Connection with key '{connection_key}' of type "
+                f"'{connector_name}' {_NOT_FOUND_SUFFIX}"
+            )
+        )
+
+    resource_name: str = connection.name
+    folder_path: str = connection.folder.get("path")
+
+    found = await _find_in_resource_catalog(
+        resource_catalog, "connection", resource_name, folder_path
+    )
+    if found is None:
+        return Skip(
+            message=(
+                f"Resource '{resource_name}' of type 'connection' at folder path "
+                f"'{folder_path}' {_NOT_FOUND_SUFFIX}"
+            )
+        )
+    return _build_create_reference(found, resource_name)
+
+
+async def _resolve_regular(
+    binding: BindingResource,
+    resource_catalog: ResourceCatalogService,
+    supported_virtual_kinds: set[str],
+) -> ResourceAction | None:
+    name_value = binding.value.get("name")
+    folder_path_value = binding.value.get("folderPath")
+    if not folder_path_value:
+        # guardrail resource, nothing to import
+        return None
+    if name_value is None:
+        raise ValueError(f"Binding {binding.key!r} is missing required field 'name'")
+    resource_name: str = name_value.default_value
+    folder_path: str = folder_path_value.default_value
+    resource_type: str = binding.resource
+
+    found = await _find_in_resource_catalog(
+        resource_catalog, resource_type, resource_name, folder_path
+    )
+    if found is not None:
+        return _build_create_reference(found, resource_name)
+
+    if resource_type not in supported_virtual_kinds:
+        return Skip(
+            message=(
+                f"Cannot create virtual resource '{resource_name}' — "
+                f"kind '{resource_type}' is not supported."
+            )
+        )
+
+    sub_type: str | None = (binding.metadata or {}).get("SubType")
+    return CreateVirtual(
+        request=VirtualResourceRequest(
+            kind=resource_type,
+            name=resource_name,
+            type=sub_type,
+        )
+    )
+
+
+async def _find_in_resource_catalog(
+    resource_catalog: ResourceCatalogService,
+    resource_type: str,
+    name: str,
+    folder_path: str,
+) -> Resource | None:
+    """Look up a single resource in the Resource Catalog.
+
+    Returns the first match or None if the catalog can't search this kind, the
+    folder is unknown, or no resource matches.
+    """
+    catalog_type = next(
+        (m for m in ResourceType if m.value == resource_type.lower()), None
+    )
+    if catalog_type is None:
+        return None
+
+    resources = resource_catalog.list_by_type_async(
+        resource_type=catalog_type, name=name, folder_path=folder_path
+    )
+    try:
+        return await anext(resources, None)
+    except FolderNotFoundException:
+        return None
+    finally:
+        await resources.aclose()
+
+
+def _build_create_reference(
+    found_resource: Resource, resource_name: str
+) -> CreateReference:
+    folder = next(iter(found_resource.folders))
+    return CreateReference(
+        request=ReferencedResourceRequest(
+            key=found_resource.resource_key,
+            kind=found_resource.resource_type,
+            type=found_resource.resource_sub_type,
+            folder=ReferencedResourceFolder(
+                folder_key=folder.key,
+                fully_qualified_name=folder.fully_qualified_name,
+                path=folder.path,
+            ),
+        ),
+        resource_name=resource_name,
+        kind=found_resource.resource_type,
+        sub_type=found_resource.resource_sub_type,
+    )
diff --git a/packages/uipath/src/uipath/_cli/_push/_resource_actions.py b/packages/uipath/src/uipath/_cli/_push/_resource_actions.py
new file mode 100644
index 000000000..4eb76bd57
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/_resource_actions.py
@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from .._utils._studio_project import (
+    ReferencedResourceRequest,
+    VirtualResourceRequest,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CreateReference:
+    request: ReferencedResourceRequest
+    resource_name: str
+    kind: str
+    sub_type: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class CreateVirtual:
+    request: VirtualResourceRequest
+
+
+@dataclass(frozen=True, slots=True)
+class Skip:
+    message: str
+
+
+ResourceAction = CreateReference | CreateVirtual | Skip
diff --git a/packages/uipath/src/uipath/_cli/_push/_summary.py b/packages/uipath/src/uipath/_cli/_push/_summary.py
new file mode 100644
index 000000000..2dcbca57e
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/_summary.py
@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+
+import click
+
+
+@dataclass
+class ResourceImportSummary:
+    created: int = 0
+    updated: int = 0
+    unchanged: int = 0
+    virtual_created: int = 0
+    virtual_existing: int = 0
+    not_found: int = 0
+
+    @property
+    def total(self) -> int:
+        return (
+            self.created
+            + self.updated
+            + self.unchanged
+            + self.virtual_created
+            + self.virtual_existing
+            + self.not_found
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"\n \U0001f535 Resource import summary: {self.total} total resources - "
+            f"{click.style(str(self.created), fg='green')} created, "
+            f"{click.style(str(self.updated), fg='blue')} updated, "
+            f"{click.style(str(self.unchanged), fg='yellow')} unchanged, "
+            f"{click.style(str(self.virtual_created), fg='green')} virtual-created, "
+            f"{click.style(str(self.virtual_existing), fg='yellow')} virtual-existing, "
+            f"{click.style(str(self.not_found), fg='red')} not found"
+        )
diff --git a/packages/uipath/src/uipath/_cli/_push/_virtual_kinds.py b/packages/uipath/src/uipath/_cli/_push/_virtual_kinds.py
new file mode 100644
index 000000000..bc1b20f73
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/_virtual_kinds.py
@@ -0,0 +1,34 @@
+import logging
+
+from .._utils._studio_project import ResourceBuilderMetadataEntry, StudioClient
+
+logger = logging.getLogger(__name__)
+
+_FALLBACK: frozenset[str] = frozenset(
+    {"app", "asset", "bucket", "process", "queue", "taskCatalog", "trigger"}
+)
+
+
+async def fetch_supported_virtual_kinds(studio_client: StudioClient) -> set[str]:
+    """Return the set of resource kinds that support inline creation.
+
+    Falls back to a static list on any failure — the caller shouldn't have to
+    care whether the metadata endpoint was reachable.
+    """
+    try:
+        metadata = await studio_client.get_resource_builder_metadata()
+    except Exception as e:
+        logger.debug("Resource Builder metadata fetch failed, using fallback: %s", e)
+        return set(_FALLBACK)
+    return _extract_supported_kinds(metadata)
+
+
+def _extract_supported_kinds(
+    metadata: list[ResourceBuilderMetadataEntry],
+) -> set[str]:
+    # metadata has one entry per (kind, type), so a kind may appear multiple times
+    return {
+        entry.kind
+        for entry in metadata
+        if any(version.supports_in_line_creation for version in entry.versions)
+    }
diff --git a/packages/uipath/src/uipath/_cli/_push/models.py b/packages/uipath/src/uipath/_cli/_push/models.py
new file mode 100644
index 000000000..764b7799d
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/models.py
@@ -0,0 +1,17 @@
+"""Models for push command."""
+
+from pydantic import BaseModel, Field
+
+
+class EvaluatorFileDetails(BaseModel):
+    """Details about an evaluator file for push operations."""
+
+    path: str
+    custom_evaluator_file_name: str = Field(
+        "", description="Name of the custom evaluator file, if available."
+    )
+
+    @property
+    def is_custom(self) -> bool:
+        """Check if this is a custom evaluator."""
+        return len(self.custom_evaluator_file_name) > 0
diff --git a/packages/uipath/src/uipath/_cli/_push/sw_file_handler.py b/packages/uipath/src/uipath/_cli/_push/sw_file_handler.py
new file mode 100644
index 000000000..64a0e9b0e
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_push/sw_file_handler.py
@@ -0,0 +1,653 @@
+"""Studio Web File Handler for managing file operations in UiPath projects."""
+
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from typing import AsyncIterator
+
+import click
+
+from uipath._cli.models.uipath_json_schema import PackOptions
+from uipath.platform.common import UiPathConfig
+
+from ...platform.errors import EnrichedException
+from .._utils._common import get_claim_from_token
+from .._utils._console import ConsoleLogger
+from .._utils._constants import (
+    AGENT_INITIAL_CODE_VERSION,
+    SCHEMA_VERSION,
+)
+from .._utils._project_files import (
+    FileInfo,
+    UpdateEvent,
+    compute_normalized_hash,
+    files_to_include,
+    read_toml_project,
+)
+from .._utils._studio_project import (
+    AddedResource,
+    ModifiedResource,
+    ProjectFile,
+    ProjectFolder,
+    ProjectStructure,
+    StructuralMigration,
+    StudioClient,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SwFileHandler:
+    """Handler for Studio Web file operations.
+
+    This class encapsulates all file operations for UiPath Studio Web projects,
+    including uploading, updating, deleting, and managing project structure.
+
+    Attributes:
+        directory: Local project directory
+        include_uv_lock: Whether to include uv.lock file
+    """
+
+    def __init__(
+        self,
+        project_id: str,
+        directory: str,
+        include_uv_lock: bool = True,
+        studio_client: StudioClient | None = None,
+    ) -> None:
+        """Initialize the SwFileHandler.
+
+        Args:
+            project_id: The ID of the UiPath project
+            directory: Local project directory
+            include_uv_lock: Whether to include uv.lock file
+            studio_client: Optional; an existing StudioClient instance to reuse instead of creating a new one.
+        """
+        self.directory = directory
+        self.include_uv_lock = include_uv_lock
+        self.console = ConsoleLogger()
+        self._studio_client = studio_client or StudioClient(project_id)
+        self._project_structure: ProjectStructure | None = None
+
+    def _get_folder_by_name(
+        self, structure: ProjectStructure, folder_name: str
+    ) -> ProjectFolder | None:
+        """Get a folder from the project structure by name.
+
+        Args:
+            structure: The project structure
+            folder_name: Name of the folder to find
+
+        Returns:
+            Optional[ProjectFolder]: The found folder or None
+        """
+        for folder in structure.folders:
+            if folder.name == folder_name:
+                return folder
+        return None
+
+    def collect_all_files(
+        self,
+        folder: ProjectFolder,
+        files_dict: dict[str, ProjectFile],
+        current_path: str = "",
+    ) -> None:
+        """Recursively collect all files from a folder with computed paths.
+
+        Args:
+            folder: The folder to traverse
+            files_dict: Dictionary to store files (indexed by name)
+            current_path: The current path prefix for files in this folder
+        """
+        # Add files from current folder
+        for file in folder.files:
+            file_path = f"{current_path}/{file.name}" if current_path else file.name
+            files_dict[file_path] = file
+
+        # Recursively process subfolders
+        for subfolder in folder.folders:
+            subfolder_path = (
+                f"{current_path}/{subfolder.name}" if current_path else subfolder.name
+            )
+            self.collect_all_files(subfolder, files_dict, subfolder_path)
+
+    def _get_remote_files(
+        self,
+        structure: ProjectStructure,
+    ) -> dict[str, ProjectFile]:
+        """Get all files from the project structure indexed by name.
+
+        Args:
+            structure: The project structure
+
+        Returns:
+            files:  dictionary with file paths as keys
+        """
+        files: dict[str, ProjectFile] = {}
+        self.collect_all_files(structure, files)
+
+        return files
+
+    async def _process_file_uploads(
+        self,
+        local_files: list[FileInfo],
+        remote_files: dict[str, ProjectFile],
+    ) -> list[UpdateEvent]:
+        """Process all file uploads.
+
+        This method:
+        1. Compares local files with remote files
+        2. Builds a structural migration with added/modified/deleted resources
+        3. Performs the structural migration
+        4. Cleans up empty folders
+
+        Args:
+            local_files: List of files to upload
+            remote_files: Dictionary of existing files
+
+        Returns:
+            List of FileOperationUpdate objects describing all file operations
+
+        Raises:
+            Exception: If any file upload fails
+        """
+        structural_migration = StructuralMigration(
+            deleted_resources=[], added_resources=[], modified_resources=[]
+        )
+        processed_source_files: set[str] = set()
+        updates: list[UpdateEvent] = []
+
+        for local_file in local_files:
+            if not os.path.exists(local_file.file_path):
+                logger.info(f"File not found: '{local_file.file_path}'")
+                continue
+
+            remote_file = remote_files.get(
+                local_file.relative_path.replace("\\", "/"), None
+            )
+
+            if remote_file:
+                processed_source_files.add(remote_file.id)
+
+                try:
+                    remote_response = (
+                        await self._studio_client.download_project_file_async(
+                            remote_file
+                        )
+                    )
+                    remote_content = remote_response.read().decode("utf-8")
+                    remote_hash = compute_normalized_hash(remote_content)
+
+                    with open(local_file.file_path, "r", encoding="utf-8") as f:
+                        local_content = f.read()
+                        local_hash = compute_normalized_hash(local_content)
+
+                    # Only update if content differs
+                    if local_hash != remote_hash:
+                        structural_migration.modified_resources.append(
+                            ModifiedResource(
+                                id=remote_file.id,
+                                content_file_path=local_file.file_path,
+                            )
+                        )
+                        updates.append(
+                            UpdateEvent(
+                                file_path=local_file.file_path,
+                                status="updating",
+                                message=f"Updating '{local_file.file_name}'",
+                            )
+                        )
+                    else:
+                        # Content is the same, no need to update
+                        updates.append(
+                            UpdateEvent(
+                                file_path=local_file.file_path,
+                                status="up_to_date",
+                                message=f"File '{local_file.file_name}' is up to date",
+                            )
+                        )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to compare file '{local_file.file_path}': {e}"
+                    )
+                    # If comparison fails, proceed with update
+                    structural_migration.modified_resources.append(
+                        ModifiedResource(
+                            id=remote_file.id, content_file_path=local_file.file_path
+                        )
+                    )
+                    updates.append(
+                        UpdateEvent(
+                            file_path=local_file.file_path,
+                            status="updating",
+                            message=f"Updating '{local_file.file_name}'",
+                        )
+                    )
+            else:
+                # File doesn't exist remotely - mark for upload
+                parent_path = os.path.dirname(local_file.relative_path)
+                structural_migration.added_resources.append(
+                    AddedResource(
+                        content_file_path=local_file.file_path,
+                        parent_path=f"{parent_path}" if parent_path != "" else None,
+                    )
+                )
+                updates.append(
+                    UpdateEvent(
+                        file_path=local_file.file_path,
+                        status="uploading",
+                        message=f"Uploading '{local_file.file_name}'",
+                    )
+                )
+
+        # Identify and add deleted files (files that exist remotely but not locally)
+        deleted_files = self._collect_deleted_files(
+            remote_files,
+            processed_source_files,
+            files_to_ignore=["studio_metadata.json"],
+            directories_to_ignore=[
+                name
+                for name, condition in [
+                    ("evals", not UiPathConfig.has_legacy_eval_folder),
+                    ("evaluations", not UiPathConfig.has_eval_folder),
+                ]
+                if condition
+            ],
+        )
+        structural_migration.deleted_resources.extend(deleted_files)
+
+        # Add delete updates
+        for file_id in deleted_files:
+            file_name = next(
+                (name for name, f in remote_files.items() if f.id == file_id),
+                file_id,
+            )
+            updates.append(
+                UpdateEvent(
+                    file_path=file_name,
+                    status="deleting",
+                    message=f"Deleting '{file_name}'",
+                )
+            )
+
+        # Prepare metadata file
+        update_metadata_event = await self._prepare_metadata_file(
+            structural_migration, remote_files
+        )
+        if update_metadata_event:
+            updates.append(update_metadata_event)
+
+        # Perform the structural migration (uploads/updates/deletes all files)
+        await self._studio_client.perform_structural_migration_async(
+            structural_migration
+        )
+
+        # Clean up empty folders after migration
+        await self._cleanup_empty_folders()
+
+        return updates
+
+    def _collect_deleted_files(
+        self,
+        remote_files: dict[str, ProjectFile],
+        processed_source_file_ids: set[str],
+        files_to_ignore: list[str] | None = None,
+        directories_to_ignore: list[str] | None = None,
+    ) -> set[str]:
+        """Identify remote files that no longer exist locally.
+
+        Args:
+            remote_files: Dictionary of existing remote files
+            processed_source_file_ids: Set of file IDs that were processed (exist locally)
+
+        Returns:
+            Set of file IDs to delete
+        """
+        deleted_file_ids: set[str] = set()
+
+        if not files_to_ignore:
+            files_to_ignore = []
+
+        if not directories_to_ignore:
+            directories_to_ignore = []
+
+        for file_path, remote_file in remote_files.items():
+            if any(
+                [
+                    file_path.startswith(directory_name)
+                    for directory_name in directories_to_ignore
+                ]
+            ):
+                continue
+            if (
+                remote_file.id not in processed_source_file_ids
+                and remote_file.name not in files_to_ignore
+            ):
+                deleted_file_ids.add(remote_file.id)
+
+        return deleted_file_ids
+
+    async def _cleanup_empty_folders(self) -> None:
+        """Delete empty folders from the project structure.
+
+        This method:
+        1. Gets the current project structure
+        2. Recursively finds all empty folders
+        3. Deletes each empty folder
+        """
+        structure = await self._studio_client.get_project_structure_async(force=True)
+
+        empty_folders = self._find_empty_folders(structure)
+
+        if empty_folders:
+            for folder in empty_folders:
+                await self._studio_client.delete_item_async(folder["id"])
+                logger.info(f"Deleted empty folder: '{folder['name']}'")
+
+    def _find_empty_folders(self, folder: ProjectFolder) -> list[dict[str, str]]:
+        """Recursively find all empty folders.
+
+        Args:
+            folder: The folder to check
+
+        Returns:
+            List of empty folder info dictionaries with 'id' and 'name' keys
+        """
+        empty_folders: list[dict[str, str]] = []
+
+        for subfolder in folder.folders:
+            # Recursively check subfolders first
+            empty_folders.extend(self._find_empty_folders(subfolder))
+
+            # Check if current subfolder is empty after processing its children
+            if self._is_folder_empty(subfolder):
+                if subfolder.id is not None:
+                    empty_folders.append({"id": subfolder.id, "name": subfolder.name})
+
+        return empty_folders
+
+    def _is_folder_empty(self, folder: ProjectFolder) -> bool:
+        """Check if a folder is empty (no files and no non-empty subfolders).
+
+        Args:
+            folder: The folder to check
+
+        Returns:
+            True if the folder is empty, False otherwise
+        """
+        if folder.files:
+            return False
+
+        if not folder.folders:
+            return True
+
+        # If folder has subfolders, check if all subfolders are empty
+        for subfolder in folder.folders:
+            if not self._is_folder_empty(subfolder):
+                return False
+
+        return True
+
+    async def _prepare_metadata_file(
+        self,
+        structural_migration: StructuralMigration,
+        remote_files: dict[str, ProjectFile],
+    ) -> UpdateEvent:
+        """Prepare .uipath/studio_metadata.json file.
+
+        This method:
+        1. Checks if file exists locally, initializes with defaults if not
+        2. Extracts author from JWT token or pyproject.toml
+        3. Downloads existing studio_metadata.json from remote if it exists to increment code version
+
+        Args:
+            structural_migration: The structural migration to add resources to
+            remote_files: Dictionary of remote files
+
+        Returns:
+            FileOperationUpdate describing the operation, or None if error occurred
+        """
+
+        def get_author_from_token_or_toml() -> str:
+            """Get author from JWT token or fall back to pyproject.toml."""
+            try:
+                preferred_username = get_claim_from_token("preferred_username")
+                if preferred_username:
+                    return preferred_username
+            except Exception:
+                # fallback to toml
+                pass
+
+            toml_data = read_toml_project(
+                os.path.join(self.directory, "pyproject.toml")
+            )
+            return toml_data.get("authors", "").strip()
+
+        author = get_author_from_token_or_toml()
+
+        local_metadata_file = os.path.join(
+            self.directory, str(UiPathConfig.studio_metadata_file_path)
+        )
+        if not os.path.exists(local_metadata_file):
+            metadata = {
+                "schemaVersion": SCHEMA_VERSION,
+                "lastPushDate": datetime.now(timezone.utc).isoformat(),
+                "lastPushAuthor": author,
+                "codeVersion": AGENT_INITIAL_CODE_VERSION,
+            }
+            os.makedirs(os.path.dirname(local_metadata_file), exist_ok=True)
+            with open(local_metadata_file, "w") as f:
+                json.dump(metadata, f, indent=2)
+        else:
+            with open(local_metadata_file, "r") as f:
+                metadata = json.load(f)
+
+        # ensure push-related fields are always present for cloud workspace
+        # context: on initial init the CLI creates a minimal studio_metadata.json file
+        # which does not contain lastPushAuthor and lastPushDate
+        if "lastPushAuthor" not in metadata:
+            metadata["lastPushAuthor"] = author
+        if "lastPushDate" not in metadata:
+            metadata["lastPushDate"] = datetime.now(timezone.utc).isoformat()
+
+        existing = remote_files.get(".uipath/studio_metadata.json")
+        if existing:
+            try:
+                existing_metadata = (
+                    await self._studio_client.download_project_file_async(existing)
+                ).json()
+                version_parts = existing_metadata["codeVersion"].split(".")
+                if len(version_parts) >= 3:
+                    # Increment patch version (0.1.0 -> 0.1.1)
+                    version_parts[-1] = str(int(version_parts[-1]) + 1)
+                    metadata["codeVersion"] = ".".join(version_parts)
+                    metadata["lastPushDate"] = datetime.now(timezone.utc).isoformat()
+                else:
+                    # Invalid version format, use default with patch = 1
+                    metadata["codeVersion"] = AGENT_INITIAL_CODE_VERSION[:-1] + "1"
+                    metadata["lastPushDate"] = datetime.now(timezone.utc).isoformat()
+            except Exception:
+                logger.info(
+                    "Could not parse existing metadata file, using default version"
+                )
+
+            with open(local_metadata_file, "w") as f:
+                f.write(json.dumps(metadata))
+
+            structural_migration.modified_resources.append(
+                ModifiedResource(
+                    id=existing.id,
+                    content_string=json.dumps(metadata),
+                )
+            )
+            return UpdateEvent(
+                file_path=".uipath/studio_metadata.json",
+                status="updating",
+                message="Updating '.uipath/studio_metadata.json'",
+            )
+        else:
+            structural_migration.added_resources.append(
+                AddedResource(
+                    file_name="studio_metadata.json",
+                    content_string=json.dumps(metadata),
+                    parent_path=".uipath",
+                )
+            )
+            return UpdateEvent(
+                file_path=".uipath/studio_metadata.json",
+                status="uploading",
+                message="Uploading '.uipath/studio_metadata.json'",
+            )
+
+    async def upload_source_files(
+        self, pack_options: PackOptions | None = None
+    ) -> AsyncIterator[UpdateEvent]:
+        """Main method to upload source files to the UiPath project.
+
+        This method:
+        1. Gets project structure (or creates if it doesn't exist)
+        2. Collects local files to upload
+        3. Processes file uploads (yields progress updates)
+        4. Performs structural migration
+        5. Cleans up empty folders
+
+        Args:
+            settings: File handling settings (includes/excludes)
+
+        Yields:
+            FileOperationUpdate: Progress updates for each file operation
+
+        Raises:
+            Exception: If any step in the process fails
+        """
+        # Get or create project structure
+        try:
+            structure = await self._studio_client.get_project_structure_async()
+        except EnrichedException as e:
+            if e.status_code == 404:
+                # Project structure doesn't exist - create empty structure and lock
+                structure = ProjectStructure(name="", files=[], folders=[])
+                await self._studio_client._put_lock()
+            else:
+                raise
+
+        remote_files = self._get_remote_files(structure)
+
+        # Get files to upload and process them
+        local_files, skipped_files = files_to_include(
+            pack_options,
+            self.directory,
+            self.include_uv_lock,
+        )
+
+        # Log skipped files from root evals folder
+        if skipped_files:
+            evals_folder_path = os.path.join(self.directory, "evals")
+            logger.info(
+                f"Skipping {len(skipped_files)} file(s) in evals folder ({evals_folder_path}): {', '.join(skipped_files)}"
+            )
+            for skipped_file in skipped_files:
+                yield UpdateEvent(
+                    file_path=skipped_file,
+                    status="skipped",
+                    message=f"Skipping '{skipped_file}' (evals folder)",
+                )
+
+        updates = await self._process_file_uploads(local_files, remote_files)
+
+        # Yield all updates
+        for update in updates:
+            yield update
+
+    async def _process_file_sync(
+        self,
+        local_file_path: str,
+        remote_files: dict[str, ProjectFile],
+        parent_path: str,
+        destination_prefix: str,
+        structural_migration: StructuralMigration,
+        processed_ids: set[str],
+    ) -> None:
+        """Process a single local file for upload or update to remote.
+
+        Args:
+            local_file_path: Path to the local file to sync
+            remote_files: Dictionary of remote files indexed by filename
+            parent_path: Parent path for new file creation
+            destination_prefix: Prefix for destination path in console output
+            structural_migration: Migration object to append resources to
+            processed_ids: Set to track processed remote file IDs
+        """
+        file_name = os.path.basename(local_file_path)
+        remote_file = remote_files.get(file_name)
+        destination = f"{destination_prefix}/{file_name}"
+
+        if remote_file:
+            processed_ids.add(remote_file.id)
+
+            # Download remote file and compare with local
+            try:
+                remote_response = await self._studio_client.download_project_file_async(
+                    remote_file
+                )
+                remote_content = remote_response.read().decode("utf-8")
+                remote_hash = compute_normalized_hash(remote_content)
+
+                with open(local_file_path, "r", encoding="utf-8") as f:
+                    local_content = f.read()
+                    local_hash = compute_normalized_hash(local_content)
+
+                # Only update if content differs
+                if local_hash != remote_hash:
+                    structural_migration.modified_resources.append(
+                        ModifiedResource(
+                            id=remote_file.id, content_file_path=local_file_path
+                        )
+                    )
+                    self.console.info(
+                        f"Updating {click.style(destination, fg='yellow')}"
+                    )
+
+                else:
+                    # Content is the same, no need to update
+                    self.console.info(f"File '{destination}' is up to date")
+            except Exception as e:
+                logger.warning(f"Failed to compare file '{local_file_path}': {e}")
+                # If comparison fails, proceed with update
+                structural_migration.modified_resources.append(
+                    ModifiedResource(
+                        id=remote_file.id, content_file_path=local_file_path
+                    )
+                )
+                self.console.info(f"Updating {click.style(destination, fg='yellow')}")
+        else:
+            structural_migration.added_resources.append(
+                AddedResource(
+                    content_file_path=local_file_path, parent_path=parent_path
+                )
+            )
+            self.console.info(f"Uploading to {click.style(destination, fg='cyan')}")
+
+    def _collect_deleted_remote_files(
+        self,
+        remote_files: dict[str, ProjectFile],
+        processed_ids: set[str],
+        destination_prefix: str,
+        structural_migration: StructuralMigration,
+    ) -> None:
+        """Collect remote files that no longer exist locally for deletion.
+
+        Args:
+            remote_files: Dictionary of remote files indexed by filename
+            processed_ids: Set of remote file IDs that were processed
+            destination_prefix: Prefix for destination path in console output
+            structural_migration: Migration object to append deleted resources to
+        """
+        for file_name, remote_file in remote_files.items():
+            if remote_file.id not in processed_ids:
+                structural_migration.deleted_resources.append(remote_file.id)
+                destination = f"{destination_prefix}/{file_name}"
+                self.console.info(
+                    f"Deleting {click.style(destination, fg='bright_red')}"
+                )
diff --git a/packages/uipath/src/uipath/_cli/_telemetry.py b/packages/uipath/src/uipath/_cli/_telemetry.py
new file mode 100644
index 000000000..d245076a4
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_telemetry.py
@@ -0,0 +1,199 @@
+import logging
+import os
+import time
+from functools import wraps
+from importlib.metadata import version
+from typing import Any, Callable, Dict, Optional
+
+from uipath._cli._utils._common import get_claim_from_token
+from uipath.platform.common import UiPathConfig
+from uipath.telemetry._track import (
+    _get_project_key,
+    is_telemetry_enabled,
+    track_cli_event,
+)
+
+logger = logging.getLogger(__name__)
+
+# Telemetry event name template for Application Insights
+CLI_COMMAND_EVENT = "Cli.{command}"
+
+
+class CliTelemetryTracker:
+    """Tracks CLI command execution and sends telemetry to Application Insights.
+
+    Sends a single event per command execution at completion with:
+    - Status: "Completed" or "Failed"
+    - Success: Boolean indicating success/failure
+    - Error details (if failed)
+    """
+
+    def __init__(self) -> None:
+        self._start_times: Dict[str, float] = {}
+
+    @staticmethod
+    def _get_event_name(command: str) -> str:
+        return f"Cli.{command.capitalize()}"
+
+    def _enrich_properties(self, properties: Dict[str, Any]) -> None:
+        """Enrich properties with common context information.
+
+        Args:
+            properties: The properties dictionary to enrich.
+        """
+        agent_id = os.getenv("UIPATH_AGENT_ID") or _get_project_key()
+        if agent_id:
+            properties["AgentId"] = agent_id
+
+        if UiPathConfig.organization_id:
+            properties["CloudOrganizationId"] = UiPathConfig.organization_id
+
+        if UiPathConfig.tenant_id:
+            properties["CloudTenantId"] = UiPathConfig.tenant_id
+
+        cloud_user_id = UiPathConfig.cloud_user_id
+        if not cloud_user_id:
+            try:
+                cloud_user_id = get_claim_from_token("sub")
+            except Exception:
+                cloud_user_id = None
+        if cloud_user_id:
+            properties["CloudUserId"] = cloud_user_id
+
+        properties["SessionId"] = "nosession"
+
+        try:
+            properties["SDKVersion"] = version("uipath")
+        except Exception:
+            pass
+
+        properties["IsGithubCI"] = bool(os.getenv("GITHUB_ACTIONS"))
+
+        properties["Source"] = "uipath-python-cli"
+        properties["ApplicationName"] = "UiPath.AgentCli"
+
+    def track_command_start(self, command: str) -> None:
+        """Record the start time for duration calculation."""
+        try:
+            self._start_times[command] = time.time()
+            logger.debug(f"Started tracking CLI command: {command}")
+
+        except Exception as e:
+            logger.debug(f"Error recording CLI command start time: {e}")
+
+    def track_command_end(
+        self,
+        command: str,
+        duration_ms: Optional[int] = None,
+    ) -> None:
+        try:
+            if duration_ms is None:
+                start_time = self._start_times.pop(command, None)
+                if start_time:
+                    duration_ms = int((time.time() - start_time) * 1000)
+
+            properties: Dict[str, Any] = {
+                "Command": command,
+                "Status": "Completed",
+                "Success": True,
+            }
+
+            if duration_ms is not None:
+                properties["DurationMs"] = duration_ms
+
+            self._enrich_properties(properties)
+
+            track_cli_event(self._get_event_name(command), properties)
+            logger.debug(f"Tracked CLI command completed: {command}")
+
+        except Exception as e:
+            logger.debug(f"Error tracking CLI command end: {e}")
+
+    def track_command_failed(
+        self,
+        command: str,
+        duration_ms: Optional[int] = None,
+        exception: Optional[Exception] = None,
+    ) -> None:
+        try:
+            if duration_ms is None:
+                start_time = self._start_times.pop(command, None)
+                if start_time:
+                    duration_ms = int((time.time() - start_time) * 1000)
+
+            properties: Dict[str, Any] = {
+                "Command": command,
+                "Status": "Failed",
+                "Success": False,
+            }
+
+            if duration_ms is not None:
+                properties["DurationMs"] = duration_ms
+
+            if exception is not None:
+                properties["ErrorType"] = type(exception).__name__
+                properties["ErrorMessage"] = str(exception)[:500]
+
+            self._enrich_properties(properties)
+
+            track_cli_event(self._get_event_name(command), properties)
+            logger.debug(f"Tracked CLI command failed: {command}")
+
+        except Exception as e:
+            logger.debug(f"Error tracking CLI command failed: {e}")
+
+
+def track_command(command: str) -> Callable[..., Any]:
+    """Decorator to track CLI command execution.
+
+    Sends an event (Cli.<Command>) to Application Insights at command
+    completion with the execution outcome.
+
+    Properties tracked include:
+    - Command: The command name
+    - Status: Execution outcome ("Completed" or "Failed")
+    - Success: Whether the command succeeded (true/false)
+    - DurationMs: Execution time in milliseconds
+    - ErrorType: Exception type name (on failure)
+    - ErrorMessage: Exception message (on failure, truncated to 500 chars)
+    - AgentId: Project key from .uipath/.telemetry.json (GUID)
+    - Version: Package version (uipath package)
+    - ProjectId, CloudOrganizationId, etc. (if available)
+
+    Telemetry failures are silently ignored to ensure CLI execution
+    is never blocked by telemetry issues.
+
+    Args:
+        command: The CLI command name (e.g., "pack", "publish", "run").
+
+    Returns:
+        A decorator function that wraps the CLI command.
+
+    Example:
+        @click.command()
+        @track_command("pack")
+        def pack(root, nolock):
+            ...
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if not is_telemetry_enabled() or UiPathConfig.job_key:
+                return func(*args, **kwargs)
+
+            tracker = CliTelemetryTracker()
+            tracker.track_command_start(command)
+
+            try:
+                result = func(*args, **kwargs)
+                tracker.track_command_end(command)
+                return result
+
+            except Exception as e:
+                tracker.track_command_failed(command, exception=e)
+                raise
+
+        return wrapper
+
+    return decorator
diff --git a/src/uipath/_cli/_templates/.psmdcp.template b/packages/uipath/src/uipath/_cli/_templates/.psmdcp.template
similarity index 100%
rename from src/uipath/_cli/_templates/.psmdcp.template
rename to packages/uipath/src/uipath/_cli/_templates/.psmdcp.template
diff --git a/src/uipath/_cli/_templates/.rels.template b/packages/uipath/src/uipath/_cli/_templates/.rels.template
similarity index 100%
rename from src/uipath/_cli/_templates/.rels.template
rename to packages/uipath/src/uipath/_cli/_templates/.rels.template
diff --git a/src/uipath/_cli/_templates/[Content_Types].xml.template b/packages/uipath/src/uipath/_cli/_templates/[Content_Types].xml.template
similarity index 100%
rename from src/uipath/_cli/_templates/[Content_Types].xml.template
rename to packages/uipath/src/uipath/_cli/_templates/[Content_Types].xml.template
diff --git a/packages/uipath/src/uipath/_cli/_templates/custom_evaluator.py.template b/packages/uipath/src/uipath/_cli/_templates/custom_evaluator.py.template
new file mode 100644
index 000000000..ba723bccc
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_templates/custom_evaluator.py.template
@@ -0,0 +1,65 @@
+from uipath.eval.evaluators import BaseEvaluator, BaseEvaluationCriteria, BaseEvaluatorConfig
+from uipath.eval.models import AgentExecution, EvaluationResult, NumericEvaluationResult, BooleanEvaluationResult, ErrorEvaluationResult
+
+
+class $criteria_class(BaseEvaluationCriteria):
+    """Evaluation criteria for the $evaluator_name evaluator."""
+
+    # Define your evaluation criteria fields here
+    # Example: expected_value: str
+    pass
+
+
+class $config_class(BaseEvaluatorConfig[$criteria_class]):
+    """Configuration for the $evaluator_name evaluator."""
+
+    name: str = "$class_name"
+    # Set default evaluation criteria if needed
+    # default_evaluation_criteria: $criteria_class | None = $criteria_class(expected_value="example")
+
+
+class $class_name(BaseEvaluator[$criteria_class, $config_class, type(None)]):
+    """Description for $class_name"""
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator ID."""
+        return "$class_name"
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: $criteria_class
+    ) -> EvaluationResult:
+        """Evaluate the agent execution against the criteria.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The actual output from the agent
+                - agent_trace: The execution trace from the agent (list of OpenTelemetry spans)
+                - simulation_instructions: The simulation instructions for the agent
+            evaluation_criteria: The criteria to evaluate against
+
+        Returns:
+            EvaluationResult containing the score and details
+        """
+
+        '''
+        # TODO: Implement your evaluation logic here
+        Example: Check if the agent output matches expected criteria
+
+        Access agent execution data:
+        agent_input = agent_execution.agent_input
+        agent_output = agent_execution.agent_output
+        agent_trace = agent_execution.agent_trace
+
+        # Perform your evaluation
+        score = 0.0  # Replace with your scoring logic
+
+        return NumericEvaluationResult(
+            score=score,
+        )
+        '''
+
+        raise NotImplementedError(f"evaluate method not implemented")
diff --git a/src/uipath/_cli/_templates/main.py.template b/packages/uipath/src/uipath/_cli/_templates/main.py.template
similarity index 80%
rename from src/uipath/_cli/_templates/main.py.template
rename to packages/uipath/src/uipath/_cli/_templates/main.py.template
index ca1cab1bb..5292acf90 100644
--- a/src/uipath/_cli/_templates/main.py.template
+++ b/packages/uipath/src/uipath/_cli/_templates/main.py.template
@@ -1,12 +1,11 @@
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class EchoIn:
     message: str
-    repeat: Optional[int] = 1
-    prefix: Optional[str] = None
+    repeat: int | None = 1
+    prefix: str | None = None
 
 
 @dataclass
diff --git a/src/uipath/_cli/_templates/package.nuspec.template b/packages/uipath/src/uipath/_cli/_templates/package.nuspec.template
similarity index 100%
rename from src/uipath/_cli/_templates/package.nuspec.template
rename to packages/uipath/src/uipath/_cli/_templates/package.nuspec.template
diff --git a/packages/uipath/src/uipath/_cli/_utils/_common.py b/packages/uipath/src/uipath/_cli/_utils/_common.py
new file mode 100644
index 000000000..c24bccff0
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_common.py
@@ -0,0 +1,241 @@
+import json
+import logging
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Literal
+from urllib.parse import urlparse
+
+import click
+
+from uipath.platform.common import (
+    ResourceOverwrite,
+    ResourceOverwriteParser,
+    UiPathConfig,
+)
+
+from ..._utils.constants import ENV_UIPATH_ACCESS_TOKEN
+from ..models.runtime_schema import EntryPoint
+from ..spinner import Spinner
+from ._console import ConsoleLogger
+from ._studio_project import (
+    NonCodedAgentProjectException,
+    StudioClient,
+    StudioProjectMetadata,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_claim_from_token(claim_name: str) -> str | None:
+    import jwt
+
+    token = os.getenv(ENV_UIPATH_ACCESS_TOKEN)
+    if not token:
+        raise Exception("JWT token not available")
+    decoded_token = jwt.decode(token, options={"verify_signature": False})
+    return decoded_token.get(claim_name)
+
+
+def environment_options(function):
+    function = click.option(
+        "--alpha",
+        "environment",
+        flag_value="alpha",
+        help="Use alpha environment",
+    )(function)
+    function = click.option(
+        "--staging",
+        "environment",
+        flag_value="staging",
+        help="Use staging environment",
+    )(function)
+    function = click.option(
+        "--cloud",
+        "environment",
+        flag_value="cloud",
+        help="Use production environment",
+    )(function)
+    return function
+
+
+def get_env_vars(spinner: Spinner | None = None) -> list[str]:
+    base_url = os.environ.get("UIPATH_URL")
+    token = os.environ.get("UIPATH_ACCESS_TOKEN")
+
+    if not all([base_url, token]):
+        if spinner:
+            spinner.stop()
+        click.echo(
+            "❌ Missing required environment variables. Please check your .env file contains:"
+        )
+        click.echo("UIPATH_URL, UIPATH_ACCESS_TOKEN")
+        click.get_current_context().exit(1)
+
+    assert base_url and token
+    return [base_url, token]
+
+
+def get_org_scoped_url(base_url: str) -> str:
+    """Get organization scoped URL from base URL.
+
+    Args:
+        base_url: The base URL to scope
+
+    Returns:
+        str: The organization scoped URL
+    """
+    parsed = urlparse(base_url)
+    org_name, *_ = parsed.path.strip("/").split("/")
+    org_scoped_url = f"{parsed.scheme}://{parsed.netloc}/{org_name}"
+    return org_scoped_url
+
+
+def clean_directory(directory: str) -> None:
+    """Clean up Python files in the specified directory.
+
+    Args:
+        directory (str): Path to the directory to clean.
+
+    This function removes all Python files (*.py) from the specified directory.
+    It's used to prepare a directory for a quickstart agent/coded MCP server.
+    """
+    for file_name in os.listdir(directory):
+        file_path = os.path.join(directory, file_name)
+
+        if os.path.isfile(file_path) and file_name.endswith(".py"):
+            os.remove(file_path)
+
+
+def determine_project_type(entrypoints: list[EntryPoint]) -> str:
+    """Determine the project type from entrypoints.
+
+    Returns the type of the first entrypoint, or "function" if no entrypoints exist.
+    Logs a warning if there are multiple entrypoint types.
+
+    Args:
+        entrypoints: List of EntryPoint objects.
+
+    Returns:
+        The project type string (e.g. "agent" or "function").
+    """
+    if not entrypoints:
+        return "function"
+
+    unique_types = set(ep.type for ep in entrypoints)
+    chosen_type = entrypoints[0].type
+
+    if len(unique_types) > 1:
+        console = ConsoleLogger()
+        types_str = ", ".join(sorted(unique_types))
+        console.warning(
+            f"Mixed entrypoint types detected: [{types_str}]. "
+            f'Defaulting project type to "{chosen_type}". '
+            f"We recommend using a single type for all entrypoints."
+        )
+
+    return chosen_type
+
+
+async def ensure_coded_agent_project(studio_client: StudioClient):
+    try:
+        await studio_client.ensure_coded_agent_project_async()
+    except NonCodedAgentProjectException:
+        console = ConsoleLogger()
+        console.error(
+            "The targeted Studio Web project is not of type coded agent. Please check the UIPATH_PROJECT_ID environment variable."
+        )
+
+
+async def may_override_files(
+    studio_client: StudioClient, scope: Literal["remote", "local"]
+) -> bool:
+
+    from packaging import version
+
+    remote_metadata = await studio_client.get_project_metadata_async()
+    if not remote_metadata:
+        return True
+
+    metadata_file_path = UiPathConfig.studio_metadata_file_path
+
+    local_code_version = None
+
+    if os.path.isfile(metadata_file_path):
+        with open(metadata_file_path, "r") as f:
+            local_data = json.load(f)
+            local_metadata = StudioProjectMetadata.model_validate(local_data)
+            local_code_version = local_metadata.code_version
+        if version.parse(local_code_version) >= version.parse(
+            remote_metadata.code_version
+        ):
+            return True
+
+    local_version_display = local_code_version if local_code_version else "Not Set"
+
+    if not remote_metadata.last_push_date:
+        formatted_date = "unknown"
+    else:
+        try:
+            push_date = datetime.fromisoformat(remote_metadata.last_push_date)
+            formatted_date = push_date.strftime("%b %d, %Y at %I:%M %p UTC")
+        except (ValueError, TypeError):
+            formatted_date = remote_metadata.last_push_date
+
+    console = ConsoleLogger()
+    console.warning("Your local version is behind the remote version.")
+    console.info(f"  Remote version:  {remote_metadata.code_version}")
+    console.info(f"  Local version:   {local_version_display}")
+    console.info(f"  Last publisher:  {remote_metadata.last_push_author}")
+    console.info(f"  Last push date:  {formatted_date}")
+
+    return console.confirm(
+        f"Do you want to proceed with overwriting the {scope} files?"
+    )
+
+
+async def read_resource_overwrites_from_file(
+    directory_path: str | None = None,
+) -> dict[str, ResourceOverwrite]:
+    """Read resource overwrites from a JSON file."""
+    config_file_name = UiPathConfig.config_file_name
+    if directory_path is not None:
+        file_path = Path(f"{directory_path}/{config_file_name}")
+    else:
+        file_path = Path(f"{config_file_name}")
+
+    overwrites_dict = {}
+
+    try:
+        with open(file_path, "r") as f:
+            data = json.load(f)
+            resource_overwrites = (
+                data.get("runtime", {})
+                .get("internalArguments", {})
+                .get("resourceOverwrites", {})
+            )
+
+            logger.info(
+                "Resource overwrites read from %s (%d entries):\n%s",
+                file_path,
+                len(resource_overwrites),
+                json.dumps(resource_overwrites, indent=2, sort_keys=True),
+            )
+
+            for key, value in resource_overwrites.items():
+                try:
+                    overwrites_dict[key] = ResourceOverwriteParser.parse(key, value)
+                except Exception as e:
+                    logger.warning(
+                        "Skipping unrecognized resource overwrite '%s': %s",
+                        key,
+                        e,
+                    )
+
+    # Return empty dict if file doesn't exist or invalid json
+    except FileNotFoundError:
+        logger.info("Resource overwrites config file not found: %s", file_path)
+    except json.JSONDecodeError as e:
+        logger.warning("Failed to parse resource overwrites from %s: %s", file_path, e)
+
+    return overwrites_dict
diff --git a/src/uipath/_cli/_utils/_console.py b/packages/uipath/src/uipath/_cli/_utils/_console.py
similarity index 56%
rename from src/uipath/_cli/_utils/_console.py
rename to packages/uipath/src/uipath/_cli/_utils/_console.py
index ee6ba4810..d7ac1ee05 100644
--- a/src/uipath/_cli/_utils/_console.py
+++ b/packages/uipath/src/uipath/_cli/_utils/_console.py
@@ -1,10 +1,19 @@
+from __future__ import annotations
+
 from contextlib import contextmanager
 from enum import Enum
-from typing import Any, Iterator, List, Optional, Type, TypeVar
+from typing import Any, Iterator, NoReturn, Type
 
 import click
 from rich.console import Console
 from rich.live import Live
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeElapsedColumn,
+)
 from rich.spinner import Spinner as RichSpinner
 from rich.text import Text
 
@@ -23,16 +32,13 @@ class LogLevel(Enum):
     MAGIC = "✨"
 
 
-T = TypeVar("T", bound="ConsoleLogger")
-
-
 class ConsoleLogger:
     """A singleton wrapper class for terminal output with emoji support and spinners."""
 
     # Class variable to hold the singleton instance
-    _instance: Optional["ConsoleLogger"] = None
+    _instance: ConsoleLogger | None = None
 
-    def __new__(cls: Type[T]) -> T:
+    def __new__(cls: Type[ConsoleLogger]) -> ConsoleLogger:
         """Ensure only one instance of ConsoleLogger is created.
 
         Returns:
@@ -41,15 +47,17 @@ def __new__(cls: Type[T]) -> T:
         if cls._instance is None:
             cls._instance = super(ConsoleLogger, cls).__new__(cls)
             cls._instance._initialized = False
-        return cls._instance  # type: ignore
+        return cls._instance
 
     def __init__(self):
         """Initialize the ConsoleLogger (only once)."""
         # Only initialize once
         if not getattr(self, "_initialized", False):
             self._console = Console()
-            self._spinner_live: Optional[Live] = None
+            self._spinner_live: Live | None = None
             self._spinner = RichSpinner("dots")
+            self._progress: Progress | None = None
+            self._progress_tasks: dict[str, TaskID] = {}
             self._initialized = True
 
     def _stop_spinner_if_active(self) -> None:
@@ -58,8 +66,15 @@ def _stop_spinner_if_active(self) -> None:
             self._spinner_live.stop()
             self._spinner_live = None
 
+    def _stop_progress_if_active(self) -> None:
+        """Internal method to stop the progress if it's active."""
+        if self._progress:
+            self._progress.stop()
+            self._progress = None
+            self._progress_tasks.clear()
+
     def log(
-        self, message: str, level: LogLevel = LogLevel.INFO, fg: Optional[str] = None
+        self, message: str, level: LogLevel = LogLevel.INFO, fg: str | None = None
     ) -> None:
         """Log a message with the specified level and optional color.
 
@@ -86,20 +101,25 @@ def success(self, message: str) -> None:
         """Log a success message."""
         self.log(message, LogLevel.SUCCESS)
 
-    def error(self, message: str, include_traceback: bool = False) -> None:
+    def error(self, message: str, include_traceback: bool = False) -> NoReturn:
         """Log an error message with optional traceback.
 
         Args:
             message: The error message to display
             include_traceback: Whether to include the current exception traceback
         """
-        self.log(message, LogLevel.ERROR, "red")
-
         if include_traceback:
+            import sys
             import traceback
 
-            click.echo(traceback.format_exc(), err=True)
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            if exc_value is not None:
+                tb = "".join(
+                    traceback.format_exception(exc_type, exc_value, exc_tb, chain=False)
+                )
+                message = f"{message}\n{tb}"
 
+        self.log(message, LogLevel.ERROR, "red")
         click.get_current_context().exit(1)
 
     def warning(self, message: str) -> None:
@@ -154,8 +174,27 @@ def prompt(self, message: str, **kwargs: Any) -> Any:
 
         return click.prompt(click.style(f"{message}", fg="yellow", bold=True), **kwargs)
 
+    def confirm(
+        self, message: str, default: bool = False, fg: str = "cyan", **kwargs: Any
+    ) -> bool:
+        """Wrapper for click.confirm with styled text.
+
+        Args:
+            message: The confirmation message
+            default: Default value if user just presses Enter
+            fg: Foreground color for the message (default: cyan)
+            **kwargs: Additional arguments to pass to click.confirm
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        # Stop any active spinner before prompting
+        self._stop_spinner_if_active()
+
+        return click.confirm(click.style(message, fg=fg), default=default, **kwargs)
+
     def display_options(
-        self, options: List[Any], message: str = "Select an option:"
+        self, options: list[Any], message: str = "Select an option:"
     ) -> None:
         """Display a list of options with indices.
 
@@ -203,6 +242,44 @@ def update_spinner(self, message: str) -> None:
         if self._spinner_live and self._spinner_live.is_started:
             self._spinner.text = Text(message)
 
+    @contextmanager
+    def evaluation_progress(
+        self, evaluations: list[dict[str, str]]
+    ) -> Iterator["EvaluationProgressManager"]:
+        """Context manager for evaluation progress tracking.
+
+        Args:
+            evaluations: List of evaluation items with 'id' and 'name' keys
+
+        Yields:
+            EvaluationProgressManager instance
+        """
+        try:
+            # Stop any existing progress or spinner
+            self._stop_spinner_if_active()
+            self._stop_progress_if_active()
+
+            # Create progress with custom columns
+            self._progress = Progress(
+                SpinnerColumn(),
+                TextColumn("[bold blue]{task.description}"),
+                TimeElapsedColumn(),
+                console=self._console,
+                transient=False,
+            )
+
+            # Add tasks for each evaluation
+            for eval_item in evaluations:
+                task_id = self._progress.add_task(eval_item["name"], total=1)
+                self._progress_tasks[eval_item["id"]] = task_id
+
+            self._progress.start()
+
+            yield EvaluationProgressManager(self._progress, self._progress_tasks)
+
+        finally:
+            self._stop_progress_if_active()
+
     @classmethod
     def get_instance(cls) -> "ConsoleLogger":
         """Get the singleton instance of ConsoleLogger.
@@ -213,3 +290,53 @@ def get_instance(cls) -> "ConsoleLogger":
         if cls._instance is None:
             return cls()
         return cls._instance
+
+
+class EvaluationProgressManager:
+    """Manager for evaluation progress updates."""
+
+    def __init__(self, progress: Progress, tasks: dict[str, TaskID]):
+        """Initialize the progress manager.
+
+        Args:
+            progress: The Rich Progress instance
+            tasks: Mapping of evaluation IDs to task IDs
+        """
+        self.progress = progress
+        self.tasks = tasks
+
+    def complete_evaluation(self, eval_id: str) -> None:
+        """Mark an evaluation as completed.
+
+        Args:
+            eval_id: The evaluation ID
+        """
+        if eval_id in self.tasks:
+            task_id = self.tasks[eval_id]
+            # Update description to show completion
+            current_desc = self.progress.tasks[task_id].description
+            self.progress.update(
+                task_id,
+                completed=1,
+                description=f"[green]✅ {current_desc}[/green]",
+            )
+
+    def fail_evaluation(self, eval_id: str, error_message: str) -> None:
+        """Mark an evaluation as failed.
+
+        Args:
+            eval_id: The evaluation ID
+            error_message: The error message
+        """
+        if eval_id in self.tasks:
+            task_id = self.tasks[eval_id]
+            # Truncate error message if too long
+            short_error = (
+                error_message[:40] + "..." if len(error_message) > 40 else error_message
+            )
+            # Update the description to show failure
+            current_desc = self.progress.tasks[task_id].description
+            self.progress.update(
+                task_id,
+                description=f"[red]❌ {current_desc} - {short_error}[/red]",
+            )
diff --git a/src/uipath/_cli/_utils/_constants.py b/packages/uipath/src/uipath/_cli/_utils/_constants.py
similarity index 90%
rename from src/uipath/_cli/_utils/_constants.py
rename to packages/uipath/src/uipath/_cli/_utils/_constants.py
index 87e9a0449..14e2568b7 100644
--- a/src/uipath/_cli/_utils/_constants.py
+++ b/packages/uipath/src/uipath/_cli/_utils/_constants.py
@@ -1,5 +1,10 @@
 BINDINGS_VERSION = "2.2"
 
+# studio_metadata.json constants
+SCHEMA_VERSION = 1
+AGENT_INITIAL_CODE_VERSION = "1.0.0"
+AGENT_TARGET_RUNTIME = "python"
+
 # Binary file extension categories
 IMAGE_EXTENSIONS = {
     ".png",
diff --git a/packages/uipath/src/uipath/_cli/_utils/_context.py b/packages/uipath/src/uipath/_cli/_utils/_context.py
new file mode 100644
index 000000000..6d571da68
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_context.py
@@ -0,0 +1,65 @@
+"""Type-safe context management for Click commands.
+
+This module provides type-safe access to CLI context across all commands,
+improving developer experience and enabling better IDE autocomplete.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+import click
+
+
+@dataclass
+class CliContext:
+    """CLI global context object.
+
+    This provides type-safe access to configuration shared across all commands.
+    Using a dataclass ensures all attributes are properly typed and documented.
+
+    Attributes:
+        output_format: Output format (table, json, csv)
+        debug: Enable debug logging
+
+    Note:
+        Authentication (URL and secret) are always read from environment variables
+        (UIPATH_URL and UIPATH_ACCESS_TOKEN).
+    """
+
+    output_format: str = "table"
+    debug: bool = False
+
+    _client: Any = field(default=None, init=False, repr=False)
+
+
+def get_cli_context(ctx: click.Context) -> CliContext:
+    """Type-safe helper to retrieve CliContext from Click context.
+
+    This eliminates repeated cast() calls and provides autocompletion
+    for CLI context attributes.
+
+    Args:
+        ctx: Click context object
+
+    Returns:
+        Typed CliContext object
+
+    Raises:
+        click.ClickException: If context object is not properly initialized
+
+    Example:
+        >>> @buckets.command()
+        >>> @click.pass_context
+        >>> def list(ctx):
+        ...     cli_ctx = get_cli_context(ctx)  # Fully typed!
+        ...     print(cli_ctx.output_format)  # Autocomplete works
+    """
+    if not isinstance(ctx.obj, CliContext):
+        raise click.ClickException(
+            "Internal error: CLI context not initialized. "
+            "This is a bug - please report it."
+        )
+    return ctx.obj
+
+
+pass_cli_context = click.make_pass_decorator(CliContext, ensure=True)
diff --git a/src/uipath/_cli/_utils/_debug.py b/packages/uipath/src/uipath/_cli/_utils/_debug.py
similarity index 100%
rename from src/uipath/_cli/_utils/_debug.py
rename to packages/uipath/src/uipath/_cli/_utils/_debug.py
diff --git a/packages/uipath/src/uipath/_cli/_utils/_folders.py b/packages/uipath/src/uipath/_cli/_utils/_folders.py
new file mode 100644
index 000000000..13aa96e97
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_folders.py
@@ -0,0 +1,41 @@
+from typing import Any, Optional, Tuple
+
+from ._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+async def get_personal_workspace_info_async() -> Tuple[Optional[str], Optional[str]]:
+    response = await _get_personal_workspace_info_internal_async()
+    feed_id = response.get("PersonalWorskpaceFeedId")
+    personal_workspace = response.get("PersonalWorkspace")
+
+    if not personal_workspace or not feed_id or "Id" not in personal_workspace:
+        return None, None
+
+    folder_id = personal_workspace.get("Id")
+    return feed_id, folder_id
+
+
+async def get_personal_workspace_key_async() -> Optional[str]:
+    response = await _get_personal_workspace_info_internal_async()
+    personal_workspace = response.get("PersonalWorkspace")
+    if not personal_workspace or "Key" not in personal_workspace:
+        return None
+    return personal_workspace["Key"]
+
+
+async def _get_personal_workspace_info_internal_async() -> dict[str, Any]:
+    from ...platform import UiPath
+
+    uipath = UiPath()
+
+    response = await uipath.api_client.request_async(
+        method="GET",
+        url="/orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended?$expand=PersonalWorkspace",
+    )
+
+    if response.status_code != 200:
+        console.error("Error: Failed to fetch user info. Please try reauthenticating.")
+
+    return response.json()
diff --git a/packages/uipath/src/uipath/_cli/_utils/_formatters.py b/packages/uipath/src/uipath/_cli/_utils/_formatters.py
new file mode 100644
index 000000000..042ce5b25
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_formatters.py
@@ -0,0 +1,182 @@
+"""Output formatting for different output modes.
+
+This module provides consistent output formatting across all CLI commands,
+supporting multiple formats (table, JSON, CSV) with proper handling of
+Pydantic models, iterators, and large datasets.
+"""
+
+import csv
+import json
+from collections.abc import Generator, Iterator
+from io import StringIO
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+
+
+def format_output(
+    data: Any,
+    fmt: str = "table",
+    output: Optional[str] = None,
+    no_color: bool = False,
+) -> None:
+    """Format and output data to stdout or file.
+
+    Handles:
+    - Pydantic models (via model_dump())
+    - Iterators and generators (converts to list)
+    - Lists, dicts, primitives
+    - Large datasets (warns at 10k+ items)
+
+    Args:
+        data: Data to format
+        fmt: Output format (json, table, csv)
+        output: Optional file path to write to
+        no_color: Disable colored output for table format
+
+    Example:
+        >>> format_output([{"name": "bucket1"}, {"name": "bucket2"}], fmt="table")
+        name
+        --------
+        bucket1
+        bucket2
+    """
+    if isinstance(data, (Iterator, Generator)):
+        data = list(data)
+        # Warn about large datasets
+        if len(data) > 10000:
+            click.echo(
+                f"Warning: Loading {len(data)} items into memory for formatting. "
+                "This may be slow or cause memory issues. "
+                "Consider using --limit or redirecting output for large datasets.",
+                err=True,
+            )
+
+    if hasattr(data, "model_dump"):
+        model_fields = getattr(data, "model_fields", None)
+        if isinstance(model_fields, dict):
+            data = data.model_dump(include=set(model_fields.keys()))
+        else:
+            data = data.model_dump()
+    elif isinstance(data, list) and len(data) > 0 and hasattr(data[0], "model_dump"):
+        model_fields = getattr(data[0], "model_fields", None)
+        if isinstance(model_fields, dict):
+            fields = set(model_fields.keys())
+            data = [item.model_dump(include=fields) for item in data]
+        else:
+            data = [item.model_dump() for item in data]
+
+    if hasattr(data, "__aiter__"):
+        raise TypeError(
+            "Async iterators not supported in CLI output. "
+            "Use synchronous methods or convert to list first."
+        )
+
+    if output and fmt == "table":
+        no_color = True
+
+    if fmt == "json":
+        text = _format_json(data)
+    elif fmt == "table":
+        text = _format_table(data, no_color=no_color)
+    elif fmt == "csv":
+        text = _format_csv(data)
+    else:
+        text = str(data)
+
+    if output:
+        Path(output).write_text(text, encoding="utf-8")
+        click.echo(f"Output written to {output}", err=True)
+    else:
+        click.echo(text)
+
+
+def _format_json(data: Any) -> str:
+    """Format data as JSON.
+
+    Args:
+        data: Data to format
+
+    Returns:
+        JSON string with 2-space indentation
+    """
+    return json.dumps(data, indent=2, default=str)
+
+
+def _format_table(data: Any, no_color: bool = False) -> str:
+    """Format data as simple table (AWS/Azure CLI style).
+
+    Uses a simple ASCII table format with column alignment similar to
+    AWS CLI and Azure CLI, avoiding fancy box-drawing characters.
+
+    Args:
+        data: Data to format
+        no_color: Disable colored output (ignored, kept for API compatibility)
+
+    Returns:
+        Formatted table string
+    """
+    items = data if isinstance(data, list) else [data]
+    if not items:
+        return "No results"
+
+    if not isinstance(items[0], dict):
+        items = [{"value": str(item)} for item in items]
+
+    columns = list(items[0].keys())
+
+    str_items = []
+    for item in items:
+        str_items.append({col: str(item.get(col, "")) for col in columns})
+
+    col_widths = {}
+    for col in columns:
+        col_widths[col] = len(col)
+        for item in str_items:
+            col_widths[col] = max(col_widths[col], len(item[col]))
+
+    header_parts = []
+    separator_parts = []
+    for col in columns:
+        header_parts.append(col.ljust(col_widths[col]))
+        separator_parts.append("-" * col_widths[col])
+
+    header = "  ".join(header_parts)
+    separator = "  ".join(separator_parts)
+
+    rows = []
+    for item in str_items:
+        row_parts = [item[col].ljust(col_widths[col]) for col in columns]
+        rows.append("  ".join(row_parts))
+
+    return "\n".join([header, separator, *rows])
+
+
+def _format_csv(data: Any) -> str:
+    """Format data as CSV.
+
+    Args:
+        data: Data to format
+
+    Returns:
+        CSV string with header
+    """
+    items = data if isinstance(data, list) else [data]
+    if not items:
+        return ""
+
+    if not isinstance(items[0], dict):
+        items = [{"value": str(item)} for item in items]
+
+    columns = list(items[0].keys())
+
+    output = StringIO()
+    writer = csv.DictWriter(output, fieldnames=columns, extrasaction="ignore")
+    writer.writeheader()
+
+    for item in items:
+        normalized_row = {col: item.get(col, "") for col in columns}
+        writer.writerow(normalized_row)
+
+    return output.getvalue()
diff --git a/packages/uipath/src/uipath/_cli/_utils/_help_json.py b/packages/uipath/src/uipath/_cli/_utils/_help_json.py
new file mode 100644
index 000000000..bbddda4f7
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_help_json.py
@@ -0,0 +1,109 @@
+import json
+from typing import Any
+
+import click
+
+
+def _get_option_info(param: click.Parameter) -> dict[str, Any]:
+    info: dict[str, Any] = {"name": param.name}
+
+    if isinstance(param, click.Option):
+        info["flags"] = list(param.opts)
+        if param.secondary_opts:
+            info["flags"].extend(param.secondary_opts)
+        if param.required:
+            info["required"] = True
+        if param.is_flag:
+            info["is_flag"] = True
+        if param.default is not None and not param.is_flag:
+            if "Sentinel" in type(param.default).__name__:
+                info["default"] = "unset"
+            else:
+                info["default"] = param.default
+        if param.help:
+            info["description"] = param.help
+
+    if hasattr(param.type, "name"):
+        info["type"] = param.type.name
+
+    if isinstance(param.type, click.Choice):
+        info["choices"] = list(param.type.choices)
+
+    return info
+
+
+def _get_command_info(
+    cmd: click.Command, name: str, parent_ctx: click.Context | None = None
+) -> dict[str, Any]:
+    """Extract metadata from a Click command."""
+    info: dict[str, Any] = {"name": name}
+
+    if cmd.help:
+        help_text = cmd.help.split("\n\n")[0].replace("\b", "").strip()
+        info["description"] = help_text
+
+    options = [
+        _get_option_info(p)
+        for p in cmd.params
+        if isinstance(p, click.Option) and p.name != "help" and not p.hidden
+    ]
+    if options:
+        info["options"] = options
+
+    arguments = [
+        {"name": p.name, "required": p.required}
+        for p in cmd.params
+        if isinstance(p, click.Argument)
+    ]
+    if arguments:
+        info["arguments"] = arguments
+
+    if isinstance(cmd, click.Group):
+        sub_ctx = click.Context(cmd, parent=parent_ctx, info_name=name)
+        subcommands = []
+        for sub_name in cmd.list_commands(sub_ctx):
+            sub_cmd = cmd.get_command(sub_ctx, sub_name)
+            if sub_cmd:
+                subcommands.append(_get_command_info(sub_cmd, sub_name, sub_ctx))
+        if subcommands:
+            info["subcommands"] = subcommands
+
+    return info
+
+
+def get_help_json(group: click.Group, ctx: click.Context, version: str) -> str:
+    """Generate JSON help for the CLI.
+
+    Args:
+        group: The root CLI group
+        ctx: Click context
+        version: CLI version string
+
+    Returns:
+        JSON string with CLI structure
+    """
+    result: dict[str, Any] = {
+        "name": ctx.info_name or "uipath",
+        "version": version,
+    }
+
+    if group.help:
+        result["description"] = group.help.split("\n\n")[0].replace("\b", "").strip()
+
+    options = [
+        _get_option_info(p)
+        for p in group.params
+        if isinstance(p, click.Option) and p.name != "help" and not p.hidden
+    ]
+    if options:
+        result["options"] = options
+
+    commands = []
+    for cmd_name in group.list_commands(ctx):
+        cmd = group.get_command(ctx, cmd_name)
+        if cmd:
+            commands.append(_get_command_info(cmd, cmd_name, ctx))
+
+    result["commands"] = commands
+
+    return json.dumps(result, indent=2, default=str)
diff --git a/packages/uipath/src/uipath/_cli/_utils/_parallelization.py b/packages/uipath/src/uipath/_cli/_utils/_parallelization.py
new file mode 100644
index 000000000..6dabe2ad2
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_parallelization.py
@@ -0,0 +1,60 @@
+import asyncio
+from typing import Awaitable, Iterable, TypeVar
+
+T = TypeVar("T")
+
+
+async def execute_parallel(
+    evaluation_result_iterable: Iterable[Awaitable[T]],
+    workers: int,
+) -> list[T]:
+    # Create a queue with max concurrency
+    queue: asyncio.Queue[tuple[int, Awaitable[T]] | None] = asyncio.Queue(
+        maxsize=workers
+    )
+
+    # Dictionary to store results with their original indices
+    results_dict: dict[int, T] = {}
+
+    # Producer task to fill the queue
+    async def producer() -> None:
+        for index, eval_item in enumerate(evaluation_result_iterable):
+            await queue.put((index, eval_item))
+        # Signal completion by putting None markers
+        for _ in range(workers):
+            await queue.put(None)
+
+    # Worker function to process items from the queue
+    async def worker(worker_id: int) -> None:
+        while True:
+            item = await queue.get()
+
+            # Check for termination signal
+            if item is None:
+                queue.task_done()
+                break
+
+            index, eval_item = item
+
+            try:
+                # Execute the evaluation
+                result = await eval_item
+
+                # Store result with its index to maintain order
+                results_dict[index] = result
+            finally:
+                # Mark the task as done
+                queue.task_done()
+
+    # Start producer
+    producer_task = asyncio.create_task(producer())
+
+    # Create worker tasks based on workers
+    worker_tasks = [asyncio.create_task(worker(i)) for i in range(workers)]
+
+    # Wait for producer and all workers to complete
+    await producer_task
+    await asyncio.gather(*worker_tasks)
+
+    # Return results in the original order
+    return [results_dict[i] for i in range(len(results_dict))]
diff --git a/src/uipath/_cli/_utils/_processes.py b/packages/uipath/src/uipath/_cli/_utils/_processes.py
similarity index 97%
rename from src/uipath/_cli/_utils/_processes.py
rename to packages/uipath/src/uipath/_cli/_utils/_processes.py
index 7c3879b95..610da5ec4 100644
--- a/src/uipath/_cli/_utils/_processes.py
+++ b/packages/uipath/src/uipath/_cli/_utils/_processes.py
@@ -17,7 +17,7 @@ def get_release_info(
     package_name: str,
     package_version: str,
     folder_id: str,
-) -> None | tuple[Any, Any] | tuple[None, None]:
+) -> tuple[Any, Any] | tuple[None, None]:
     headers = {
         "Authorization": f"Bearer {token}",
         "x-uipath-organizationunitid": str(folder_id),
diff --git a/packages/uipath/src/uipath/_cli/_utils/_project_files.py b/packages/uipath/src/uipath/_cli/_utils/_project_files.py
new file mode 100644
index 000000000..15f5e53c5
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_project_files.py
@@ -0,0 +1,658 @@
+import hashlib
+import json
+import logging
+import os
+import re
+import tomllib
+from enum import IntEnum
+from pathlib import Path
+from typing import Any, AsyncIterator, Dict, Literal, Optional, Tuple
+
+import anyio
+from pydantic import BaseModel, Field, TypeAdapter
+
+from uipath._cli.models.uipath_json_schema import PackOptions, UiPathJsonConfig
+from uipath.platform.common import UiPathConfig
+
+from .._utils._console import ConsoleLogger
+from ._constants import is_binary_file
+from ._studio_project import (
+    ProjectFile,
+    ProjectFolder,
+    StudioClient,
+    get_folder_by_name,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_existing_project_id(directory: str = ".") -> Optional[str]:
+    """Return an already-established project id for this project, if any.
+
+    Checks the Studio Web project env var first, then falls back to the legacy
+    ``ProjectKey`` stored in ``.uipath/.telemetry.json``. Returns ``None`` when
+    neither is present.
+
+    Args:
+        directory: The project root directory to look for the telemetry file in.
+    """
+    from ...telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
+
+    if project_id := UiPathConfig.project_id:
+        return project_id
+
+    telemetry_file = os.path.join(directory, ".uipath", _TELEMETRY_CONFIG_FILE)
+    if os.path.exists(telemetry_file):
+        try:
+            with open(telemetry_file, "r") as f:
+                telemetry_data = json.load(f)
+                if project_id := telemetry_data.get(_PROJECT_KEY):
+                    return project_id
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    return None
+
+
+class Severity(IntEnum):
+    LOG = 0
+    WARNING = 1
+
+
+class UpdateEvent(BaseModel):
+    """Update about a file operation in progress."""
+
+    file_path: str
+    status: Literal[
+        "downloading",
+        "updated",
+        "skipped",
+        "up_to_date",
+        "downloaded",
+        "uploading",
+        "updating",
+        "deleting",
+        "created_folder",
+    ]
+    message: str
+    severity: Severity = Field(default=Severity.LOG)
+
+
+class ProjectPullError(Exception):
+    """Exception raised when pulling a project fails."""
+
+    def __init__(self, project_id: str, message: str = "Failed to pull UiPath project"):
+        self.project_id = project_id
+        self.message = message
+        super().__init__(self.message)
+
+
+class FileInfo(BaseModel):
+    """Information about a file to be included in the project.
+
+    Attributes:
+        file_path: The absolute path to the file
+        relative_path: The path relative to the project root
+        is_binary: Whether the file should be treated as binary
+    """
+
+    file_name: str
+    file_path: str
+    relative_path: str
+    is_binary: bool
+
+
+console = ConsoleLogger()
+
+
+def get_project_config(directory: str) -> dict[str, Any]:
+    """Retrieve and combine project configuration from uipath.json and pyproject.toml.
+
+    Args:
+        directory: The root directory containing the configuration files
+
+    Returns:
+        dict[str, str]: Combined configuration including project name, description,
+            entry points, version, and authors
+
+    Raises:
+        SystemExit: If required configuration files are missing or invalid
+    """
+    config_path = os.path.join(directory, "uipath.json")
+    toml_path = os.path.join(directory, "pyproject.toml")
+
+    if not os.path.isfile(config_path):
+        console.error("uipath.json not found, please run `uipath init`.")
+    if not os.path.isfile(toml_path):
+        console.error("pyproject.toml not found.")
+
+    with open(config_path, "r") as config_file:
+        config_data = TypeAdapter(UiPathJsonConfig).validate_python(
+            json.load(config_file)
+        )
+
+    toml_data = read_toml_project(toml_path)
+
+    return {
+        "project_name": toml_data["name"],
+        "description": toml_data["description"],
+        "version": toml_data["version"],
+        "authors": toml_data["authors"],
+        "dependencies": toml_data.get("dependencies", {}),
+        "requires-python": toml_data.get("requires-python", None),
+        "packOptions": config_data.pack_options or {},
+    }
+
+
+def validate_project_files(directory: str) -> None:
+    required_files = [
+        UiPathConfig.bindings_file_path,
+        UiPathConfig.entry_points_file_path,
+    ]
+
+    missing_files = []
+    for file_path in required_files:
+        if not os.path.isfile(os.path.join(directory, str(file_path))):
+            missing_files.append(f"'{file_path}'")
+
+    if missing_files:
+        missing_str = ", ".join(missing_files)
+        console.error(
+            f"Missing required files: {missing_str}. Please run 'uipath init'."
+        )
+
+
+def validate_config(config: dict[str, str]) -> None:
+    """Validate the combined project configuration.
+
+    Checks for required fields and invalid characters in project name and description.
+
+    Args:
+        config: The combined configuration dictionary from uipath.json and pyproject.toml
+
+    Raises:
+        SystemExit: If validation fails for any required field or contains invalid characters
+    """
+    if not config["project_name"] or config["project_name"].strip() == "":
+        console.error(
+            "Project name cannot be empty. Please specify a name in pyproject.toml."
+        )
+
+    if not config["description"] or config["description"].strip() == "":
+        console.error(
+            "Project description cannot be empty. Please specify a description in pyproject.toml."
+        )
+
+    if not config["authors"] or config["authors"].strip() == "":
+        console.error(
+            'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
+        )
+
+    if not config["requires-python"] or config["requires-python"].strip() == "":
+        console.error(
+            "'requires-python' field cannot be empty. Please specify it in pyproject.toml:  requires-python = \">=3.11\""
+        )
+
+    invalid_chars = ["&", "<", ">", '"', "'", ";"]
+    for char in invalid_chars:
+        if char in config["description"]:
+            console.error(f"Project description contains invalid character: '{char}'")
+
+    invalid_chars += [" "]
+    for char in invalid_chars:
+        if char in config["project_name"]:
+            console.error(f"Project name contains invalid character: '{char}'")
+
+
+def validate_config_structure(config_data: dict[str, Any]) -> None:
+    """Validate the structure of uipath.json configuration.
+
+    Args:
+        config_data: The raw configuration data from uipath.json
+
+    Raises:
+        SystemExit: If required fields are missing from the configuration
+    """
+    required_fields = ["entryPoints"]
+    for field in required_fields:
+        if field not in config_data:
+            console.error(f"uipath.json is missing the required field: {field}.")
+
+
+def ensure_config_file(directory: str) -> None:
+    """Check if uipath.json exists in the specified directory.
+
+    Args:
+        directory: The directory to check for uipath.json
+
+    Raises:
+        SystemExit: If uipath.json is not found in the directory
+    """
+    if not os.path.isfile(os.path.join(directory, "uipath.json")):
+        console.error(
+            "uipath.json not found. Please run `uipath init` in the project directory."
+        )
+
+
+def extract_dependencies_from_toml(project_data: Dict[str, Any]) -> Dict[str, str]:
+    """Extract and parse dependencies from pyproject.toml project data.
+
+    Args:
+        project_data: The "project" section from pyproject.toml
+
+    Returns:
+        Dictionary mapping package names to version specifiers
+    """
+    dependencies: dict[str, str] = {}
+
+    if "dependencies" not in project_data:
+        return dependencies
+
+    deps_list = project_data["dependencies"]
+    if not isinstance(deps_list, list):
+        console.warning("dependencies should be a list in pyproject.toml")
+        return dependencies
+
+    for dep in deps_list:
+        if not isinstance(dep, str):
+            console.warning(f"Skipping non-string dependency: {dep}")
+            continue
+
+        try:
+            name, version_spec = parse_dependency_string(dep)
+            if name:  # Only add if we got a valid name
+                dependencies[name] = version_spec
+        except Exception as e:
+            console.warning(f"Failed to parse dependency '{dep}': {e}")
+            continue
+
+    return dependencies
+
+
+def parse_dependency_string(dependency: str) -> Tuple[str, str]:
+    """Parse a dependency string into package name and version specifier.
+
+    Handles PEP 508 dependency specifications including:
+    - Simple names: "requests"
+    - Version specifiers: "requests>=2.28.0"
+    - Complex specifiers: "requests>=2.28.0,<3.0.0"
+    - Extras: "requests[security]>=2.28.0"
+    - Environment markers: "requests>=2.28.0; python_version>='3.8'"
+
+    Args:
+        dependency: Raw dependency string from pyproject.toml
+
+    Returns:
+        Tuple of (package_name, version_specifier)
+
+    Examples:
+        "requests" -> ("requests", "*")
+        "requests>=2.28.0" -> ("requests", ">=2.28.0")
+        "requests>=2.28.0,<3.0.0" -> ("requests", ">=2.28.0,<3.0.0")
+        "requests[security]>=2.28.0" -> ("requests", ">=2.28.0")
+    """
+    # Remove whitespace
+    dependency = dependency.strip()
+
+    # Handle environment markers (everything after semicolon)
+    if ";" in dependency:
+        dependency = dependency.split(";")[0].strip()
+
+    # Pattern to match package name with optional extras and version specifiers
+    # Matches: package_name[extras] version_specs
+    pattern = r"^([a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?)(\[[^\]]+\])?(.*)"
+    match = re.match(pattern, dependency)
+
+    if not match:
+        # Fallback for edge cases
+        return dependency, "*"
+
+    package_name = match.group(1)
+    version_part = match.group(4).strip() if match.group(4) else ""
+
+    # If no version specifier, return wildcard
+    if not version_part:
+        return package_name, "*"
+
+    # Clean up version specifier
+    version_spec = version_part.strip()
+
+    # Validate that version specifier starts with a valid operator
+    valid_operators = [">=", "<=", "==", "!=", "~=", ">", "<"]
+    if not any(version_spec.startswith(op) for op in valid_operators):
+        # If it doesn't start with an operator, treat as exact version
+        if version_spec:
+            version_spec = f"=={version_spec}"
+        else:
+            version_spec = "*"
+
+    return package_name, version_spec
+
+
+def read_toml_project(file_path: str) -> dict[str, Any]:
+    """Read and parse pyproject.toml file with improved error handling and validation.
+
+    Args:
+        file_path: Path to pyproject.toml file
+
+    Returns:
+        Dictionary containing project metadata and dependencies
+    """
+    try:
+        with open(file_path, "rb") as f:
+            content = tomllib.load(f)
+    except Exception as e:
+        console.error(f"Failed to read or parse pyproject.toml: {e}")
+
+    # Validate required sections
+    if "project" not in content:
+        console.error("pyproject.toml is missing the required field: project.")
+
+    project = content["project"]
+
+    # Validate required fields with better error messages
+    required_fields = {
+        "name": "Project name is required in pyproject.toml",
+        "description": "Project description is required in pyproject.toml",
+        "version": "Project version is required in pyproject.toml",
+    }
+
+    for field, error_msg in required_fields.items():
+        if field not in project:
+            console.error(
+                f"pyproject.toml is missing the required field: project.{field}. {error_msg}"
+            )
+
+        # Check for empty values only if field exists
+        if field in project and (
+            not project[field]
+            or (isinstance(project[field], str) and not project[field].strip())
+        ):
+            console.error(
+                f"Project {field} cannot be empty. Please specify a {field} in pyproject.toml."
+            )
+
+    # Extract author information safely
+    authors = project.get("authors", [])
+    author_name = ""
+
+    if authors and isinstance(authors, list) and len(authors) > 0:
+        first_author = authors[0]
+        if isinstance(first_author, dict):
+            author_name = first_author.get("name", "")
+        elif isinstance(first_author, str):
+            # Handle case where authors is a list of strings
+            author_name = first_author
+
+    # Extract dependencies with improved parsing
+    dependencies = extract_dependencies_from_toml(project)
+
+    return {
+        "name": project["name"].strip(),
+        "description": project["description"].strip(),
+        "version": project["version"].strip(),
+        "authors": author_name.strip(),
+        "dependencies": dependencies,
+        "requires-python": project.get("requires-python", "").strip(),
+    }
+
+
+def files_to_include(
+    pack_options: Optional[PackOptions],
+    directory: str,
+    include_uv_lock: bool = True,
+    directories_to_ignore: list[str] | None = None,
+) -> tuple[list[FileInfo], list[str]]:
+    """Get list of files to include in the project based on configuration.
+
+    Walks through the directory tree and identifies files to include based on extensions
+    and explicit inclusion rules. Skips virtual environments and hidden directories.
+
+    Args:
+        pack_options: File handling settings
+        directory: Root directory to search for files
+        include_uv_lock: Whether to include uv.lock file
+        directories_to_ignore: List of directories to ignore
+
+    Returns:
+        tuple[list[FileInfo], list[str]]: Tuple of (included files, skipped file paths)
+    """
+    file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]
+    files_included = ["pyproject.toml"]
+    files_excluded = []
+
+    if directories_to_ignore is None:
+        directories_to_ignore = []
+    if include_uv_lock:
+        files_included += ["uv.lock"]
+    if pack_options is not None:
+        if pack_options.file_extensions_included:
+            file_extensions_included.extend(pack_options.file_extensions_included)
+        if pack_options.files_included:
+            files_included.extend(pack_options.files_included)
+        if pack_options.files_excluded:
+            files_excluded.extend(pack_options.files_excluded)
+        if pack_options.directories_excluded:
+            directories_to_ignore.extend(pack_options.directories_excluded)
+
+    def is_venv_dir(d: str) -> bool:
+        """Check if a directory is a Python virtual environment.
+
+        Args:
+            d: Directory path to check
+
+        Returns:
+            bool: True if directory is a virtual environment, False otherwise
+        """
+        return (
+            os.path.exists(os.path.join(d, "Scripts", "activate"))
+            if os.name == "nt"
+            else os.path.exists(os.path.join(d, "bin", "activate"))
+        )
+
+    extra_files: list[FileInfo] = []
+    skipped_files: list[str] = []
+
+    # Walk through directory and return all files in the allowlist
+    for root, dirs, files in os.walk(directory):
+        # Determine if we're in the root evals folder
+        root_rel_path = os.path.relpath(root, directory)
+        normalized_root_rel_path = root_rel_path.replace(os.sep, "/")
+        is_root_evals_folder = normalized_root_rel_path == "evals"
+
+        # Skip all directories that start with . or are a venv or are excluded
+        included_dirs = []
+        for d in dirs:
+            if d.startswith(".") or is_venv_dir(os.path.join(root, d)):
+                continue
+
+            # Check if directory should be excluded
+            dir_path = os.path.join(root, d)
+            dir_rel_path = os.path.relpath(dir_path, directory)
+            normalized_dir_rel_path = dir_rel_path.replace(os.sep, "/")
+
+            # Check exclusion: by dirname (for root level) or by relative path
+            should_exclude_dir = (
+                (
+                    (
+                        d in directories_to_ignore and normalized_dir_rel_path == d
+                    )  # name match for root level only
+                    or normalized_dir_rel_path
+                    in directories_to_ignore  # path match for nested directories
+                )
+                if directories_to_ignore is not None
+                else False
+            )
+
+            if not should_exclude_dir:
+                included_dirs.append(d)
+
+        dirs[:] = included_dirs
+        for file in files:
+            if file.startswith("."):
+                continue
+
+            file_extension = os.path.splitext(file)[1].lower()
+            file_path = os.path.join(root, file)
+            file_name = os.path.basename(file_path)
+            rel_path = os.path.relpath(file_path, directory)
+
+            # Normalize the path
+            normalized_rel_path = rel_path.replace(os.sep, "/")
+
+            # Skip files in the root evals folder (but allow eval-set and evaluators subdirectories)
+            if is_root_evals_folder:
+                skipped_files.append(normalized_rel_path)
+                continue
+
+            # Check inclusion: by extension, by filename (for base directory), or by relative path
+            should_include = (
+                file_extension in file_extensions_included
+                or (
+                    file in files_included and normalized_rel_path == file
+                )  # filename match for base directory only
+                or normalized_rel_path
+                in files_included  # path match for subdirectories
+            )
+
+            # Check exclusion: by filename (for base directory only) or by relative path
+            should_exclude = (
+                (
+                    file in files_excluded and normalized_rel_path == file
+                )  # filename match for base directory only
+                or normalized_rel_path
+                in files_excluded  # path match for subdirectories
+            )
+
+            if should_include and not should_exclude:
+                extra_files.append(
+                    FileInfo(
+                        file_name=file_name,
+                        file_path=file_path,
+                        relative_path=rel_path,
+                        is_binary=is_binary_file(file_extension),
+                    )
+                )
+    return extra_files, skipped_files
+
+
+def compute_normalized_hash(content: str) -> str:
+    """Compute hash of normalized content.
+
+    Args:
+        content: Content to hash
+
+    Returns:
+        str: SHA256 hash of the normalized content
+    """
+    try:
+        # Try to parse as JSON to handle formatting
+        json_content = json.loads(content)
+        normalized = json.dumps(json_content, indent=2)
+    except json.JSONDecodeError:
+        # Not JSON, normalize line endings
+        normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
+def collect_files_from_folder(
+    folder: ProjectFolder, base_path: str, files_dict: Dict[str, ProjectFile]
+) -> None:
+    """Recursively collect all files from a folder and its subfolders.
+
+    Args:
+        folder: The folder to collect files from
+        base_path: Base path for file paths
+        files_dict: Dictionary to store collected files
+    """
+    # Add files from current folder
+    for file in folder.files:
+        file_path = os.path.join(base_path, file.name)
+        files_dict[file_path] = file
+
+    # Recursively process subfolders
+    for subfolder in folder.folders:
+        subfolder_path = os.path.join(base_path, subfolder.name)
+        collect_files_from_folder(subfolder, subfolder_path, files_dict)
+
+
+async def pull_project(
+    project_id: str,
+    download_configuration: dict[str | None, Path],
+    studio_client: StudioClient,
+) -> AsyncIterator[UpdateEvent]:
+    """Pull project files.
+
+    Yields:
+        FileOperationUpdate: Progress updates for each file operation
+    """
+    try:
+        structure = await studio_client.get_project_structure_async()
+        for source_key, destination in download_configuration.items():
+            source_folder = get_folder_by_name(structure, source_key)
+            if source_folder:
+                async for update in download_folder_files(
+                    studio_client, source_folder, destination
+                ):
+                    yield update
+            else:
+                logger.warning(f"No '{source_key}' folder found in remote project")
+    except Exception as e:
+        raise ProjectPullError(project_id) from e
+
+
+async def download_folder_files(
+    studio_client: StudioClient,
+    folder: ProjectFolder,
+    base_path: Path,
+) -> AsyncIterator[UpdateEvent]:
+    """Download files from a folder recursively, yielding progress updates.
+
+    Args:
+        studio_client: Studio client
+        folder: The folder to download files from
+        base_path: Base path for local file storage
+
+    Yields:
+        FileOperationUpdate: Progress updates for each file operation
+    """
+    files_dict: Dict[str, ProjectFile] = {}
+    collect_files_from_folder(folder, "", files_dict)
+
+    for file_path, remote_file in files_dict.items():
+        local_path = anyio.Path(base_path / file_path)
+        await local_path.parent.mkdir(parents=True, exist_ok=True)
+
+        response = await studio_client.download_project_file_async(remote_file)
+        remote_content = response.read().decode("utf-8")
+        remote_hash = compute_normalized_hash(remote_content)
+
+        if await local_path.exists():
+            local_content = await local_path.read_text(encoding="utf-8")
+            local_hash = compute_normalized_hash(local_content)
+
+            if local_hash != remote_hash:
+                await local_path.write_text(
+                    remote_content, encoding="utf-8", newline="\n"
+                )
+
+                yield UpdateEvent(
+                    file_path=file_path,
+                    status="updated",
+                    message=f"Updated '{file_path}'",
+                )
+            else:
+                yield UpdateEvent(
+                    file_path=file_path,
+                    status="up_to_date",
+                    message=f"File '{file_path}' is up to date",
+                )
+        else:
+            await local_path.write_text(remote_content, encoding="utf-8", newline="\n")
+
+            yield UpdateEvent(
+                file_path=file_path,
+                status="downloaded",
+                message=f"Downloaded '{file_path}'",
+            )
diff --git a/packages/uipath/src/uipath/_cli/_utils/_resources.py b/packages/uipath/src/uipath/_cli/_utils/_resources.py
new file mode 100644
index 000000000..c161e70ba
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_resources.py
@@ -0,0 +1,22 @@
+import enum
+
+from ._console import ConsoleLogger
+
+console = ConsoleLogger().get_instance()
+
+
+class Resources(str, enum.Enum):
+    """Available resources that can be created."""
+
+    EVALUATOR = "evaluator"
+
+    @classmethod
+    def from_string(cls, resource: str) -> "Resources":
+        try:
+            return Resources(resource)
+        except ValueError:
+            valid_resources = ", ".join([r.value for r in Resources])
+            console.error(
+                f"Invalid resource type: '{resource}'. Valid types are: {valid_resources}"
+            )
+            raise
diff --git a/packages/uipath/src/uipath/_cli/_utils/_service_base.py b/packages/uipath/src/uipath/_cli/_utils/_service_base.py
new file mode 100644
index 000000000..018e2e112
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_service_base.py
@@ -0,0 +1,343 @@
+"""Base utilities for service commands.
+
+This module provides decorators and utilities for implementing service-specific
+CLI commands with consistent error handling, async support, and output formatting.
+
+Key features:
+- Sequential decorator composition
+- Type-safe context access
+- Enhanced Click exception handling
+- Async/await support
+- Consistent error messages
+"""
+
+import asyncio
+import inspect
+from functools import wraps
+from typing import Any, Callable
+
+import click
+from httpx import HTTPError
+
+from ...platform.errors import (
+    BaseUrlMissingError,
+    EnrichedException,
+    SecretMissingError,
+)
+from ._context import get_cli_context
+
+
+def handle_not_found_error(
+    resource: str, identifier: str, error: Exception | None = None
+) -> None:
+    """Handle 404/LookupError and raise consistent ClickException.
+
+    Args:
+        resource: The resource type (e.g., "Bucket", "Asset", "Queue")
+        identifier: The resource identifier (name, key, etc.)
+        error: Optional original error for chaining
+
+    Raises:
+        click.ClickException: Always raises with consistent message
+    """
+    message = f"{resource} '{identifier}' not found."
+    if error:
+        raise click.ClickException(message) from error
+    else:
+        raise click.ClickException(message) from None
+
+
+def service_command(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator for service commands with async support, error handling, and output.
+
+    This decorator handles:
+    - Sync and async function execution
+    - Output formatting (JSON, table, CSV)
+    - Error handling with proper Click exceptions
+    - Separation of logs (stderr) from data (stdout)
+    - Type-safe context access via get_cli_context()
+    - Enhanced Click exception handling (don't catch Click's own exceptions)
+    - Domain errors converted to click.ClickException
+    - Automatic context injection (no need for @click.pass_context)
+
+    Example:
+        >>> @buckets.command()
+        >>> @service_command
+        >>> async def list_async(ctx):
+        ...     # Context is automatically passed - no @click.pass_context needed
+        ...     return await client.buckets.list_async()
+
+    Note:
+        Do NOT stack @click.pass_context with this decorator - context is
+        already injected by the @wraps(f) and @click.pass_context inside
+        service_command.
+    """
+
+    @wraps(f)
+    @click.pass_context
+    def wrapper(ctx, *args, **kwargs):
+        cli_ctx = get_cli_context(ctx)
+
+        try:
+            result = f(ctx, *args, **kwargs)
+
+            if inspect.iscoroutine(result):
+                try:
+                    result = asyncio.run(result)
+                except RuntimeError as e:
+                    if "cannot be called from a running event loop" in str(e).lower():
+                        prev_loop = asyncio.get_event_loop()
+                        if prev_loop.is_running():
+                            loop = asyncio.new_event_loop()
+                            try:
+                                asyncio.set_event_loop(loop)
+                                result = loop.run_until_complete(result)
+                            finally:
+                                try:
+                                    loop.close()
+                                finally:
+                                    asyncio.set_event_loop(prev_loop)
+                        else:
+                            result = prev_loop.run_until_complete(result)
+                    else:
+                        raise
+
+            # Format and output result
+            if result is not None:
+                from ._formatters import format_output
+
+                fmt = kwargs.get("format") or cli_ctx.output_format
+                output = kwargs.get("output")
+
+                format_output(
+                    result,
+                    fmt=fmt,
+                    output=output,
+                    no_color=False,  # Auto-detected for file output
+                )
+
+            return result
+
+        except click.ClickException:
+            raise
+
+        except BaseUrlMissingError:
+            raise click.ClickException(
+                "UIPATH_URL not configured. Set the UIPATH_URL environment variable or run 'uipath auth'."
+            ) from None
+
+        except SecretMissingError:
+            raise click.ClickException(
+                "Authentication required. Set the UIPATH_ACCESS_TOKEN environment variable or run 'uipath auth'."
+            ) from None
+
+        except EnrichedException as e:
+            if cli_ctx.debug:
+                raise
+
+            if e.status_code == 401:
+                raise click.ClickException(
+                    "Authentication failed (401). Your access token may have expired or is invalid.\n"
+                    "Please run 'uipath auth' to re-authenticate."
+                ) from e
+
+            if e.status_code == 400:
+                try:
+                    import json
+
+                    error_data = json.loads(e.response_content)
+                    if (
+                        isinstance(error_data, dict)
+                        and error_data.get("errorCode") == 1101
+                    ):
+                        raise click.ClickException(
+                            "Folder context required (400). The command requires a folder to be specified.\n"
+                            'Set UIPATH_FOLDER_PATH environment variable (e.g., export UIPATH_FOLDER_PATH="Shared") '
+                            'or use the --folder-path option (e.g., --folder-path "Shared").'
+                        ) from e
+                except (ValueError, json.JSONDecodeError):
+                    pass
+
+            raise click.ClickException(str(e)) from e
+
+        except HTTPError as e:
+            if cli_ctx.debug:
+                raise
+            response = getattr(e, "response", None)
+
+            if response and response.status_code == 401:
+                raise click.ClickException(
+                    "Authentication failed (401). Your access token may have expired or is invalid.\n"
+                    "Please run 'uipath auth' to re-authenticate."
+                ) from e
+
+            if response and response.status_code == 400:
+                try:
+                    error_data = response.json()
+                    if (
+                        isinstance(error_data, dict)
+                        and error_data.get("errorCode") == 1101
+                    ):
+                        raise click.ClickException(
+                            "Folder context required (400). The command requires a folder to be specified.\n"
+                            'Set UIPATH_FOLDER_PATH environment variable (e.g., export UIPATH_FOLDER_PATH="Shared") '
+                            'or use the --folder-path option (e.g., --folder-path "Shared").'
+                        ) from e
+                except ValueError:
+                    pass
+
+            if response:
+                error_msg = f"HTTP Error {response.status_code}: {response.url}"
+                if hasattr(response, "text"):
+                    try:
+                        import json
+
+                        response_data = response.json()
+                        sensitive_fields = {
+                            "access_token",
+                            "refresh_token",
+                            "password",
+                            "secret",
+                            "api_key",
+                            "authorization",
+                        }
+                        if isinstance(response_data, dict):
+                            for key in list(response_data.keys()):
+                                if any(
+                                    sensitive in key.lower()
+                                    for sensitive in sensitive_fields
+                                ):
+                                    response_data[key] = "***REDACTED***"
+                        error_details = json.dumps(response_data, indent=2)
+                        error_msg += f"\nResponse:\n{error_details[:500]}"
+                    except Exception:
+                        error_msg += f"\nResponse: {response.text[:200]}"
+            else:
+                error_msg = f"HTTP Error: {str(e)}"
+            raise click.ClickException(error_msg) from e
+
+        except Exception as e:
+            if cli_ctx.debug:
+                raise
+            raise click.ClickException(str(e)) from e
+
+    return wrapper
+
+
+def common_service_options(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Add common options for service commands.
+
+    Adds:
+    - --folder-path: Folder path (e.g., "Shared") with validation
+    - --folder-key: Folder key (UUID) with validation
+    - --format: Output format override
+    - --output: Output file override
+    """
+    from ._validators import validate_folder_path, validate_uuid
+
+    decorators = [
+        click.option(
+            "--folder-path",
+            callback=validate_folder_path,
+            help='Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable.',
+        ),
+        click.option("--folder-key", callback=validate_uuid, help="Folder key (UUID)"),
+        click.option(
+            "--format",
+            type=click.Choice(["json", "table", "csv"]),
+            help="Output format (overrides global)",
+        ),
+        click.option(
+            "--output", "-o", type=click.Path(), help="Output file (overrides global)"
+        ),
+    ]
+
+    for decorator in reversed(decorators):
+        f = decorator(f)
+
+    return f
+
+
+def standard_service_command(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Convenience decorator for standard service commands.
+
+    This composes decorators in explicit, sequential order:
+    1. service_command (execution & error handling)
+    2. common_service_options (folder, format, output)
+
+    The sequential pattern makes the decorator stack more readable
+    and easier for AI agents to understand.
+
+    Usage:
+        >>> # Simple command
+        >>> @buckets.command()
+        >>> @standard_service_command
+        >>> def retrieve(ctx, name, folder_path, ...):
+        ...     pass
+
+        >>> # Custom composition (when you need flexibility)
+        >>> @buckets.command()
+        >>> @service_command
+        >>> @click.option('--custom-flag', ...)
+        >>> @common_service_options
+        >>> @click.pass_context
+        >>> def special(ctx, custom_flag, ...):
+        ...     pass
+    """
+    decorated_func = f
+
+    decorated_func = service_command(decorated_func)
+
+    decorated_func = common_service_options(decorated_func)
+
+    return decorated_func
+
+
+class ServiceCommandBase:
+    """Base class for service command utilities."""
+
+    @staticmethod
+    def get_client(ctx):
+        """Get or create UiPath client from context.
+
+        This caches the client in the CLI context to avoid recreating
+        it for every command invocation.
+
+        Args:
+            ctx: Click context
+
+        Returns:
+            UiPath client instance
+
+        Raises:
+            click.ClickException: If required environment variables are not set
+        """
+        import os
+
+        import click
+
+        cli_ctx = get_cli_context(ctx)
+
+        if cli_ctx._client is None:
+            from ...platform._uipath import UiPath
+
+            base_url = os.environ.get("UIPATH_URL")
+            secret = os.environ.get("UIPATH_ACCESS_TOKEN")
+
+            if not base_url:
+                raise click.ClickException(
+                    "UIPATH_URL not configured. Set the UIPATH_URL environment variable or run 'uipath auth'."
+                )
+
+            if not secret:
+                raise click.ClickException(
+                    "Authentication required. Set the UIPATH_ACCESS_TOKEN environment variable or run 'uipath auth'."
+                )
+
+            cli_ctx._client = UiPath(
+                base_url=base_url,
+                secret=secret,
+                debug=cli_ctx.debug,
+            )
+
+        return cli_ctx._client
diff --git a/packages/uipath/src/uipath/_cli/_utils/_service_cli_generator.py b/packages/uipath/src/uipath/_cli/_utils/_service_cli_generator.py
new file mode 100644
index 000000000..8f2182f5b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_service_cli_generator.py
@@ -0,0 +1,705 @@
+"""Service CLI Generator for automatic CRUD command generation.
+
+This module provides ServiceCLIGenerator, which automatically generates
+standard Click CLI commands for services implementing CRUDServiceProtocol.
+
+The generator creates commands for:
+- list: List all resources
+- retrieve: Get a single resource
+- create: Create a new resource
+- delete: Delete a resource
+- exists: Check if a resource exists (if service supports it)
+
+Example:
+    >>> from ._service_metadata import ServiceMetadata, CreateParameter
+    >>> from ._service_cli_generator import ServiceCLIGenerator
+    >>>
+    >>> metadata = ServiceMetadata(
+    ...     service_name="buckets",
+    ...     service_attr="buckets",
+    ...     resource_type="Bucket",
+    ...     create_params={
+    ...         "description": CreateParameter(
+    ...             type="str",
+    ...             required=False,
+    ...             help="Bucket description",
+    ...         )
+    ...     },
+    ... )
+    >>>
+    >>> generator = ServiceCLIGenerator(metadata)
+    >>> buckets_group = generator.register(parent_group)
+"""
+
+from enum import Enum
+from itertools import islice
+from typing import Any, Callable, TypedDict
+
+import click
+
+from ._service_base import (
+    ServiceCommandBase,
+    common_service_options,
+    service_command,
+)
+from ._service_metadata import ServiceMetadata
+from ._service_protocol import has_exists_method, validate_service_protocol
+from ._type_registry import get_type
+
+
+class GeneratorType(str, Enum):
+    """Enum for command generator types.
+
+    Attributes:
+        AUTO: Auto-generated by ServiceCLIGenerator
+        MANUAL: Manually added nested group or custom command
+        OVERRIDE: Manual override of auto-generated command
+    """
+
+    AUTO = "ServiceCLIGenerator"
+    MANUAL = "manual"
+    OVERRIDE = "manual_override"
+
+
+def _optional_decorator(
+    condition: bool, decorator: Callable[[Any], Any]
+) -> Callable[[Any], Any]:
+    """Apply decorator conditionally based on a boolean flag.
+
+    This makes conditional decorator patterns more explicit and readable.
+
+    Args:
+        condition: Whether to apply the decorator
+        decorator: The decorator function to apply if condition is True
+
+    Returns:
+        The decorator if condition is True, otherwise an identity function
+
+    Example:
+        >>> @_optional_decorator(
+        ...     condition=config.confirmation_required,
+        ...     decorator=click.option("--confirm", is_flag=True)
+        ... )
+        ... def my_command():
+        ...     pass
+    """
+    if condition:
+        return decorator
+    return lambda f: f
+
+
+class ProvenanceDict(TypedDict, total=False):
+    """Type definition for command provenance tracking.
+
+    Attributes:
+        generator: Source of the command (ServiceCLIGenerator, manual, manual_override)
+        service_name: Name of the service
+        resource_type: Type of resource (e.g., "Bucket")
+        command_function: Name of the command function
+        type: Type of manual addition (e.g., "nested_group")
+        original_generator: Original generator for overridden commands
+        overridden_at: Context where override occurred (e.g., "user_custom")
+    """
+
+    generator: str
+    service_name: str
+    resource_type: str
+    command_function: str
+    type: str
+    original_generator: str
+    overridden_at: str
+
+
+class ServiceCLIGenerator:
+    """Generates CLI commands for CRUD services.
+
+    This class automatically creates Click commands for services that implement
+    the CRUDServiceProtocol. It handles:
+    - Command generation from metadata
+    - Parameter type resolution
+    - Confirmation and dry-run support
+    - Output formatting integration
+    - Provenance tracking
+
+    Attributes:
+        metadata: Service metadata configuration
+        _command_names: Set of generated command names
+        _provenance: Dict tracking command generation metadata
+
+    Example:
+        >>> metadata = ServiceMetadata(
+        ...     service_name="buckets",
+        ...     service_attr="buckets",
+        ...     resource_type="Bucket",
+        ... )
+        >>> generator = ServiceCLIGenerator(metadata)
+        >>> buckets_group = generator.register(parent_group)
+    """
+
+    def __init__(self, metadata: ServiceMetadata) -> None:
+        """Initialize the generator with service metadata.
+
+        Args:
+            metadata: Service metadata configuration
+
+        Raises:
+            ValueError: If metadata has invalid types
+        """
+        self.metadata = metadata
+        self._command_names: set[str] = set()
+        self._provenance: dict[str, ProvenanceDict] = {}
+
+        self.metadata.validate_types()
+
+    def validate_service(self, client: Any) -> None:
+        """Validate that the service implements the required protocol.
+
+        This method should be called early during CLI setup to fail fast
+        if the service doesn't implement the required CRUD methods.
+
+        Args:
+            client: Client instance with service attributes
+
+        Raises:
+            TypeError: If service doesn't implement CRUDServiceProtocol
+            AttributeError: If service attribute doesn't exist on client
+
+        Example:
+            >>> generator = ServiceCLIGenerator(metadata)
+            >>> from uipath.platform import UiPath
+            >>> client = UiPath(...)
+            >>> generator.validate_service(client)  # Fails early if invalid
+            >>> generator.register(cli_group)  # Now safe to register
+        """
+        service = getattr(client, self.metadata.service_attr)
+        validate_service_protocol(service, self.metadata.service_name)
+
+    def register(self, parent_group: click.Group) -> click.Group:
+        """Register service commands under a parent Click group.
+
+        This creates a new Click group for the service and adds all
+        CRUD commands to it based on the metadata.
+
+        Args:
+            parent_group: Parent Click group to add service group to
+
+        Returns:
+            The created service Click group
+
+        Raises:
+            TypeError: If service doesn't implement CRUDServiceProtocol
+
+        Example:
+            >>> @click.group()
+            ... def cli():
+            ...     pass
+            >>> generator = ServiceCLIGenerator(metadata)
+            >>> service_group = generator.register(cli)
+        """
+        service_group = click.Group(
+            name=self.metadata.service_name,
+            help=f"Manage {self.metadata.resource_plural}",
+        )
+
+        self._add_list_command(service_group)
+        self._add_retrieve_command(service_group)
+        self._add_create_command(service_group)
+        self._add_delete_command(service_group)
+
+        self._add_exists_command(service_group)
+
+        parent_group.add_command(service_group)
+
+        return service_group
+
+    def _add_list_command(self, group: click.Group) -> None:
+        """Add list command to the group.
+
+        Generates: uipath <service> list [--folder-path PATH] [--folder-key KEY] [--limit N] [--offset N]
+        """
+
+        @group.command("list")
+        @click.option("--limit", type=int, help="Maximum number of items to return")
+        @click.option("--offset", type=int, default=0, help="Number of items to skip")
+        @common_service_options
+        @service_command
+        def list_cmd(
+            ctx: click.Context,
+            folder_path: str | None,
+            folder_key: str | None,
+            format: str | None,
+            output: str | None,
+            limit: int | None,
+            offset: int,
+        ) -> list[Any]:
+            """List resources."""
+            client = ServiceCommandBase.get_client(ctx)
+            service = getattr(client, self.metadata.service_attr)
+
+            resources = service.list(folder_path=folder_path, folder_key=folder_key)
+
+            if limit is not None:
+                return list(islice(resources, offset, offset + limit))
+            elif offset > 0:
+                return list(islice(resources, offset, None))
+            else:
+                return list(resources)
+
+        list_cmd.help = f"""List all {self.metadata.resource_plural}.
+
+Examples:
+    uipath {self.metadata.service_name} list
+    uipath {self.metadata.service_name} list --folder-path Shared
+"""
+
+        self._track_command("list", list_cmd)
+
+    def _add_retrieve_command(self, group: click.Group) -> None:
+        """Add retrieve command to the group.
+
+        Generates: uipath <service> retrieve <name> [--folder-path PATH]
+        """
+        identifier = self.metadata.retrieve_identifier
+
+        @group.command("retrieve")
+        @click.argument(identifier.upper())
+        @common_service_options
+        @service_command
+        def retrieve_cmd(
+            ctx: click.Context,
+            folder_path: str | None,
+            folder_key: str | None,
+            format: str | None,
+            output: str | None,
+            **kwargs: Any,
+        ) -> None:
+            """Retrieve a resource."""
+            client = ServiceCommandBase.get_client(ctx)
+            service = getattr(client, self.metadata.service_attr)
+
+            identifier_value = kwargs.get(identifier)
+
+            resource = service.retrieve(
+                identifier_value, folder_path=folder_path, folder_key=folder_key
+            )
+
+            return resource
+
+        retrieve_cmd.help = f"""Retrieve a single {self.metadata.resource_type}.
+
+Examples:
+    uipath {self.metadata.service_name} retrieve my-resource
+    uipath {self.metadata.service_name} retrieve my-resource --folder-path Shared
+"""
+
+        self._track_command("retrieve", retrieve_cmd)
+
+    def _add_create_command(self, group: click.Group) -> None:
+        """Add create command to the group.
+
+        Generates: uipath <service> create <name> [options] [--folder-path PATH]
+        """
+
+        def create_command_decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            """Apply all create parameter decorators to the function."""
+            for param_name, param_config in reversed(
+                list(self.metadata.create_params.items())
+            ):
+                option_name = param_config.option_name or param_name
+                param_type = get_type(param_config.type)
+
+                # Build Click option
+                func = click.option(
+                    f"--{option_name.replace('_', '-')}",
+                    type=param_type,
+                    required=param_config.required,
+                    default=param_config.default,
+                    help=param_config.help,
+                )(func)
+
+            return func
+
+        @group.command("create")
+        @click.argument("NAME")
+        @create_command_decorator
+        @common_service_options
+        @service_command
+        def create_cmd(
+            ctx: click.Context,
+            folder_path: str | None,
+            folder_key: str | None,
+            format: str | None,
+            output: str | None,
+            name: str,
+            **kwargs: Any,
+        ) -> None:
+            """Create a resource."""
+            client = ServiceCommandBase.get_client(ctx)
+            service = getattr(client, self.metadata.service_attr)
+
+            create_kwargs = {}
+            for param_name in self.metadata.create_params.keys():
+                if param_name in kwargs and kwargs[param_name] is not None:
+                    create_kwargs[param_name] = kwargs[param_name]
+
+            resource = service.create(
+                name, folder_path=folder_path, folder_key=folder_key, **create_kwargs
+            )
+
+            click.echo(
+                f"Created {self.metadata.resource_type.lower()} '{name}'", err=True
+            )
+            return resource
+
+        create_cmd.help = f"""Create a new {self.metadata.resource_type}.
+
+Examples:
+    uipath {self.metadata.service_name} create my-resource
+    uipath {self.metadata.service_name} create my-resource --folder-path Shared
+"""
+
+        self._track_command("create", create_cmd)
+
+    def _add_delete_command(self, group: click.Group) -> None:
+        """Add delete command to the group.
+
+        Generates: uipath <service> delete <name> [--confirm] [--dry-run] [--folder-path PATH]
+        """
+        delete_config = self.metadata.delete_cmd
+
+        @group.command("delete")
+        @click.argument("NAME")
+        @_optional_decorator(
+            delete_config.confirmation_required,
+            click.option(
+                "--confirm",
+                is_flag=True,
+                help="Confirm deletion without prompting",
+            ),
+        )
+        @_optional_decorator(
+            delete_config.dry_run_supported,
+            click.option(
+                "--dry-run",
+                is_flag=True,
+                help="Show what would be deleted without actually deleting",
+            ),
+        )
+        @common_service_options
+        @service_command
+        def delete_cmd(
+            ctx: click.Context,
+            folder_path: str | None,
+            folder_key: str | None,
+            format: str | None,
+            output: str | None,
+            name: str,
+            **kwargs: Any,
+        ) -> None:
+            """Delete a resource."""
+            client = ServiceCommandBase.get_client(ctx)
+            service = getattr(client, self.metadata.service_attr)
+
+            if delete_config.dry_run_supported:
+                dry_run = kwargs.get("dry_run", False)
+                if dry_run:
+                    click.echo(
+                        f"Would delete {self.metadata.resource_type.lower()} '{name}'",
+                        err=True,
+                    )
+                    return
+
+            if delete_config.confirmation_required:
+                confirm_flag = kwargs.get("confirm", False)
+                if not confirm_flag:
+                    if delete_config.confirmation_prompt:
+                        prompt = delete_config.confirmation_prompt.format(
+                            resource=self.metadata.resource_type, identifier=name
+                        )
+                    else:
+                        prompt = f"Delete {self.metadata.resource_type} '{name}'?"
+
+                    if not click.confirm(prompt):
+                        click.echo("Deletion cancelled.")
+                        return
+
+            service.delete(name=name, folder_path=folder_path, folder_key=folder_key)
+
+            click.echo(
+                f"Deleted {self.metadata.resource_type.lower()} '{name}'", err=True
+            )
+
+        delete_cmd.help = f"""Delete a {self.metadata.resource_type}.
+
+Examples:
+    uipath {self.metadata.service_name} delete my-resource --confirm
+    uipath {self.metadata.service_name} delete my-resource --dry-run
+"""
+
+        self._track_command("delete", delete_cmd)
+
+    def _add_exists_command(self, group: click.Group) -> None:
+        """Add exists command to the group (if service supports it).
+
+        Generates: uipath <service> exists <name> [--folder-path PATH]
+
+        Note:
+            This command is only added to the CLI. The actual validation
+            of whether the service implements exists() happens at runtime.
+        """
+        exists_config = self.metadata.exists_cmd
+        identifier = exists_config.identifier_arg_name
+
+        @group.command("exists")
+        @click.argument(identifier.upper())
+        @common_service_options
+        @service_command
+        def exists_cmd(
+            ctx: click.Context,
+            folder_path: str | None,
+            folder_key: str | None,
+            format: str | None,
+            output: str | None,
+            **kwargs: Any,
+        ) -> bool | dict[str, Any] | None:
+            """Check if a resource exists."""
+            client = ServiceCommandBase.get_client(ctx)
+            service = getattr(client, self.metadata.service_attr)
+
+            if not has_exists_method(service):
+                click.echo(
+                    f"Error: {self.metadata.resource_type} service does not support exists command",
+                    err=True,
+                )
+                raise click.Abort()
+
+            identifier_value = kwargs.get(identifier)
+
+            exists = service.exists(
+                identifier_value, folder_path=folder_path, folder_key=folder_key
+            )
+
+            if exists_config.return_format == "bool":
+                return exists
+            elif exists_config.return_format == "dict":
+                return {"exists": exists, identifier: identifier_value}
+            else:  # text
+                if exists:
+                    click.echo(
+                        f"{self.metadata.resource_type} '{identifier_value}' exists"
+                    )
+                else:
+                    click.echo(
+                        f"{self.metadata.resource_type} '{identifier_value}' does not exist"
+                    )
+                return None
+
+        exists_cmd.help = f"""Check if a {self.metadata.resource_type} exists.
+
+Examples:
+    uipath {self.metadata.service_name} exists my-resource
+    uipath {self.metadata.service_name} exists my-resource --folder-path Shared
+"""
+
+        self._track_command("exists", exists_cmd)
+
+    def _track_command(self, command_name: str, command: Callable[..., Any]) -> None:
+        """Track generated command for provenance.
+
+        Args:
+            command_name: Name of the command (e.g., "list", "create")
+            command: The Click command function
+        """
+        self._command_names.add(command_name)
+
+        func_name = command_name
+        if hasattr(command, "callback") and hasattr(command.callback, "__name__"):
+            func_name = command.callback.__name__
+        elif hasattr(command, "__name__"):
+            func_name = command.__name__
+
+        provenance: ProvenanceDict = {
+            "generator": GeneratorType.AUTO.value,
+            "service_name": self.metadata.service_name,
+            "resource_type": self.metadata.resource_type,
+            "command_function": func_name,
+        }
+
+        self._provenance[command_name] = provenance
+        setattr(command, "__provenance__", provenance)  # noqa: B010  # Dynamic attribute not in type
+
+    def get_command_names(self) -> set[str]:
+        """Get set of generated command names.
+
+        Returns:
+            Set of command names (e.g., {"list", "retrieve", "create", "delete", "exists"})
+        """
+        return self._command_names.copy()
+
+    def get_provenance(self, command_name: str) -> ProvenanceDict | None:
+        """Get provenance information for a generated command.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            Provenance dict or None if command not found
+        """
+        return self._provenance.get(command_name)
+
+    def add_nested_group(
+        self, service_group: click.Group, group_name: str, custom_group: click.Group
+    ) -> None:
+        """Add a custom nested command group to the service group.
+
+        This allows adding custom operations that don't fit the CRUD pattern,
+        such as the buckets file commands (upload, download, list-files, etc.).
+
+        Args:
+            service_group: The service group created by register()
+            group_name: Name for the nested group (e.g., "file")
+            custom_group: The Click group with custom commands
+
+        Raises:
+            ValueError: If group_name collides with existing command
+
+        Example:
+            >>> @click.group()
+            ... def file_group():
+            ...     '''File operations'''
+            ...     pass
+            >>>
+            >>> @file_group.command("upload")
+            ... def upload_cmd():
+            ...     '''Upload a file'''
+            ...     pass
+            >>>
+            >>> generator = ServiceCLIGenerator(metadata)
+            >>> service_group = generator.register(parent_group)
+            >>> generator.add_nested_group(service_group, "file", file_group)
+        """
+        if group_name in service_group.commands:
+            existing_provenance = self.get_provenance(group_name)
+            if existing_provenance:
+                raise ValueError(
+                    f"Cannot add nested group '{group_name}': "
+                    f"conflicts with auto-generated command '{group_name}' "
+                    f"(generator: {existing_provenance['generator']})"
+                )
+            else:
+                raise ValueError(
+                    f"Cannot add nested group '{group_name}': "
+                    f"command name already exists"
+                )
+
+        service_group.add_command(custom_group, name=group_name)
+
+        self._command_names.add(group_name)
+        provenance: ProvenanceDict = {
+            "generator": GeneratorType.MANUAL.value,
+            "type": "nested_group",
+            "service_name": self.metadata.service_name,
+            "command_function": group_name,
+        }
+        self._provenance[group_name] = provenance
+        setattr(custom_group, "__provenance__", provenance)  # noqa: B010  # Dynamic attribute not in type
+
+    def override_command(
+        self,
+        service_group: click.Group,
+        command_name: str,
+        custom_command: click.Command,
+    ) -> None:
+        """Override an auto-generated command with a custom implementation.
+
+        This allows replacing auto-generated CRUD commands with custom logic
+        while preserving the same command name and interface.
+
+        Args:
+            service_group: The service group created by register()
+            command_name: Name of the command to override (e.g., "list", "create")
+            custom_command: The custom Click command
+
+        Raises:
+            ValueError: If command_name doesn't exist or wasn't auto-generated
+
+        Example:
+            >>> @click.command("list")
+            ... def custom_list():
+            ...     '''Custom list with extra features'''
+            ...     pass
+            >>>
+            >>> generator = ServiceCLIGenerator(metadata)
+            >>> service_group = generator.register(parent_group)
+            >>> generator.override_command(service_group, "list", custom_list)
+        """
+        if command_name not in service_group.commands:
+            raise ValueError(
+                f"Cannot override command '{command_name}': command does not exist"
+            )
+
+        provenance = self.get_provenance(command_name)
+        if not provenance or provenance.get("generator") != GeneratorType.AUTO.value:
+            raise ValueError(
+                f"Cannot override command '{command_name}': "
+                f"not an auto-generated command (only auto-generated commands can be overridden)"
+            )
+
+        del service_group.commands[command_name]
+        service_group.add_command(custom_command, name=command_name)
+
+        new_provenance: ProvenanceDict = {
+            "generator": GeneratorType.OVERRIDE.value,
+            "original_generator": provenance["generator"],
+            "service_name": self.metadata.service_name,
+            "resource_type": self.metadata.resource_type,
+            "command_function": custom_command.callback.__name__
+            if hasattr(custom_command, "callback")
+            and custom_command.callback is not None
+            else command_name,
+            "overridden_at": "user_custom",
+        }
+        self._provenance[command_name] = new_provenance
+        setattr(custom_command, "__provenance__", new_provenance)  # noqa: B010  # Dynamic attribute not in type
+
+    def validate_no_collisions(
+        self, service_group: click.Group, additional_commands: list[str]
+    ) -> list[str]:
+        """Validate that additional commands won't collide with generated ones.
+
+        This is useful for checking naming conflicts before adding custom commands.
+
+        Args:
+            service_group: The service group created by register()
+            additional_commands: List of command names to check
+
+        Returns:
+            List of collision errors (empty if no collisions)
+
+        Example:
+            >>> generator = ServiceCLIGenerator(metadata)
+            >>> service_group = generator.register(parent_group)
+            >>> errors = generator.validate_no_collisions(service_group, ["list", "custom"])
+            >>> if errors:
+            ...     for error in errors:
+            ...         print(error)
+        """
+        collisions = []
+
+        for cmd_name in additional_commands:
+            if cmd_name in service_group.commands:
+                provenance = self.get_provenance(cmd_name)
+                if provenance:
+                    collisions.append(
+                        f"Command '{cmd_name}' conflicts with auto-generated command "
+                        f"(generator: {provenance.get('generator', 'unknown')})"
+                    )
+                else:
+                    collisions.append(
+                        f"Command '{cmd_name}' conflicts with existing command"
+                    )
+
+        return collisions
+
+
+__all__ = ["ServiceCLIGenerator"]
diff --git a/packages/uipath/src/uipath/_cli/_utils/_service_metadata.py b/packages/uipath/src/uipath/_cli/_utils/_service_metadata.py
new file mode 100644
index 000000000..e8153b9c4
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_service_metadata.py
@@ -0,0 +1,206 @@
+"""Service metadata models using Pydantic.
+
+This module defines the metadata structure for CLI service command generation.
+All models are immutable (frozen) to prevent accidental modification after creation.
+
+The metadata describes:
+- Service identification (name, resource type)
+- CRUD operation parameters
+- Command configuration (confirmation, dry-run support)
+
+Example:
+    >>> from ._service_metadata import ServiceMetadata, CreateParameter
+    >>>
+    >>> BUCKETS_METADATA = ServiceMetadata(
+    ...     service_name="buckets",
+    ...     service_attr="buckets",
+    ...     resource_type="Bucket",
+    ...     create_params={
+    ...         "description": CreateParameter(
+    ...             type="str",
+    ...             required=False,
+    ...             help="Bucket description",
+    ...         )
+    ...     },
+    ... )
+"""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class CreateParameter(BaseModel):
+    """Metadata for a single create command parameter.
+
+    This defines how a parameter should appear in the CLI command.
+
+    Attributes:
+        type: Type name from TYPE_REGISTRY (e.g., "str", "int", "bool", "float")
+        required: Whether the parameter is required (default: False)
+        help: Help text shown in --help output
+        default: Default value if not provided by user
+        option_name: CLI option name (default: derived from field name)
+
+    Example:
+        >>> description_param = CreateParameter(
+        ...     type="str",
+        ...     required=False,
+        ...     help="Resource description",
+        ...     default=None,
+        ... )
+    """
+
+    type: str
+    required: bool = False
+    help: str = ""
+    default: Any = None
+    option_name: str | None = None
+
+    model_config = ConfigDict(frozen=True)
+
+
+class DeleteCommandConfig(BaseModel):
+    """Configuration for delete command behavior.
+
+    Attributes:
+        confirmation_required: Whether to require --confirm flag (default: True)
+        dry_run_supported: Whether to support --dry-run flag (default: True)
+        confirmation_prompt: Custom confirmation prompt template
+
+    Example:
+        >>> delete_config = DeleteCommandConfig(
+        ...     confirmation_required=True,
+        ...     dry_run_supported=True,
+        ...     confirmation_prompt="Delete {resource} '{identifier}'?",
+        ... )
+    """
+
+    confirmation_required: bool = True
+    dry_run_supported: bool = True
+    confirmation_prompt: str | None = None
+
+    model_config = ConfigDict(frozen=True)
+
+
+class ExistsCommandConfig(BaseModel):
+    """Configuration for exists command behavior.
+
+    Attributes:
+        identifier_arg_name: Name of the identifier argument (default: "name")
+        return_format: Format of the return value ("bool", "dict", "text")
+
+    Example:
+        >>> exists_config = ExistsCommandConfig(
+        ...     identifier_arg_name="key",
+        ...     return_format="dict",
+        ... )
+    """
+
+    identifier_arg_name: str = "name"
+    return_format: str = "dict"  # "bool", "dict", or "text"
+
+    model_config = ConfigDict(frozen=True)
+
+
+class ServiceMetadata(BaseModel):
+    """Complete metadata for a service's CLI commands.
+
+    This metadata is used by ServiceCLIGenerator to auto-generate standard
+    CRUD commands (list, retrieve, create, delete, exists).
+
+    Attributes:
+        service_name: CLI command group name (e.g., "buckets", "assets")
+        service_attr: Attribute name on UiPath client (e.g., client.buckets)
+        resource_type: Human-readable resource name (e.g., "Bucket", "Asset")
+        resource_plural: Plural form of resource type (auto-generated if not provided)
+        create_params: Dictionary of parameters for create command
+        delete_cmd: Configuration for delete command behavior
+        exists_cmd: Configuration for exists command behavior
+        list_supports_filters: Whether list command supports additional filters
+        retrieve_identifier: Name of the identifier argument for retrieve
+
+    Example:
+        >>> metadata = ServiceMetadata(
+        ...     service_name="buckets",
+        ...     service_attr="buckets",
+        ...     resource_type="Bucket",
+        ...     create_params={
+        ...         "description": CreateParameter(
+        ...             type="str",
+        ...             required=False,
+        ...             help="Bucket description",
+        ...         )
+        ...     },
+        ... )
+        >>> metadata.resource_plural
+        'Buckets'
+    """
+
+    service_name: str
+    service_attr: str
+    resource_type: str
+    resource_plural: str | None = None
+    create_params: dict[str, CreateParameter] = Field(default_factory=dict)
+    delete_cmd: DeleteCommandConfig = Field(default_factory=DeleteCommandConfig)
+    exists_cmd: ExistsCommandConfig = Field(default_factory=ExistsCommandConfig)
+    list_supports_filters: bool = False
+    retrieve_identifier: str = "name"
+
+    model_config = ConfigDict(frozen=True)
+
+    @model_validator(mode="after")
+    def set_defaults(self) -> "ServiceMetadata":
+        """Set default values that depend on other fields.
+
+        This validator runs after model creation to set derived defaults:
+        - resource_plural from resource_type
+        - delete_cmd defaults if not explicitly set
+
+        Note:
+            Since the model is frozen, we use object.__setattr__ to modify fields.
+        """
+        if self.resource_plural is None:
+            object.__setattr__(self, "resource_plural", f"{self.resource_type}s")
+
+        return self
+
+    def validate_types(self) -> None:
+        """Validate that all parameter types are in TYPE_REGISTRY.
+
+        Raises:
+            ValueError: If any parameter type is not registered
+
+        Example:
+            >>> metadata = ServiceMetadata(
+            ...     service_name="test",
+            ...     service_attr="test",
+            ...     resource_type="Test",
+            ...     create_params={
+            ...         "invalid": CreateParameter(type="InvalidType", required=False)
+            ...     },
+            ... )
+            >>> metadata.validate_types()
+            Traceback (most recent call last):
+            ...
+            ValueError: Invalid type 'InvalidType' for parameter 'invalid' in service 'test'...
+        """
+        from ._type_registry import is_valid_type
+
+        for param_name, param in self.create_params.items():
+            if not is_valid_type(param.type):
+                from ._type_registry import TYPE_REGISTRY
+
+                valid_types = ", ".join(sorted(TYPE_REGISTRY.keys()))
+                raise ValueError(
+                    f"Invalid type '{param.type}' for parameter '{param_name}' "
+                    f"in service '{self.service_name}'. Valid types: {valid_types}"
+                )
+
+
+__all__ = [
+    "CreateParameter",
+    "DeleteCommandConfig",
+    "ExistsCommandConfig",
+    "ServiceMetadata",
+]
diff --git a/packages/uipath/src/uipath/_cli/_utils/_service_protocol.py b/packages/uipath/src/uipath/_cli/_utils/_service_protocol.py
new file mode 100644
index 000000000..59c55345a
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_service_protocol.py
@@ -0,0 +1,223 @@
+"""Protocol definition for CRUD services.
+
+This module defines the CRUDServiceProtocol that services must implement
+to be compatible with the CLI command generator.
+
+The protocol uses Python's Protocol (PEP 544) for structural subtyping,
+allowing duck-typing without requiring explicit inheritance.
+
+Example:
+    >>> from typing import Protocol, runtime_checkable
+    >>> from ._service_protocol import CRUDServiceProtocol
+    >>>
+    >>> # A service that implements the protocol
+    >>> class BucketsService:
+    ...     def list(self, folder_path=None, folder_key=None):
+    ...         return iter([])
+    ...
+    ...     def retrieve(self, name, folder_path=None, folder_key=None):
+    ...         return {"name": name}
+    ...
+    ...     # ... other CRUD methods
+    >>>
+    >>> # No explicit inheritance needed - structural typing
+    >>> def use_service(service: CRUDServiceProtocol):
+    ...     return list(service.list())
+"""
+
+from typing import Any, Iterator, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class CRUDServiceProtocol(Protocol):
+    """Protocol for services that support standard CRUD operations.
+
+    Services implementing this protocol can use the ServiceCLIGenerator
+    to automatically generate CLI commands.
+
+    All methods support folder-scoped operations via folder_path or folder_key
+    parameters. This matches the UiPath platform's hierarchical folder structure.
+
+    Required Methods:
+        list: List all resources (returns iterator)
+        retrieve: Get a single resource by identifier
+        create: Create a new resource
+        delete: Delete a resource by identifier
+
+    Optional Methods (NOT in protocol, checked separately):
+        exists: Check if a resource exists (will be used if present on service)
+
+    Note:
+        This is a Protocol, not a base class. Services don't need to inherit
+        from it; they just need to implement the required methods with
+        compatible signatures.
+
+        The exists() method is NOT part of the protocol to allow optional
+        implementation. Use hasattr(service, 'exists') to check for it.
+    """
+
+    def list(
+        self,
+        *,
+        folder_path: str | None = None,
+        folder_key: str | None = None,
+        **kwargs: Any,
+    ) -> Iterator[Any]:
+        """List all resources in the specified folder.
+
+        Args:
+            folder_path: Folder path (e.g., "Shared")
+            folder_key: Folder UUID key
+            **kwargs: Additional service-specific parameters
+
+        Returns:
+            Iterator of resource objects
+
+        Example:
+            >>> buckets_service.list(folder_path="Shared")
+            <iterator of Bucket objects>
+        """
+        ...
+
+    def retrieve(
+        self,
+        name: str,
+        *,
+        folder_path: str | None = None,
+        folder_key: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Retrieve a single resource by identifier.
+
+        Args:
+            name: Resource identifier (usually name, but could be key)
+            folder_path: Folder path (e.g., "Shared")
+            folder_key: Folder UUID key
+            **kwargs: Additional service-specific parameters
+
+        Returns:
+            Resource object
+
+        Raises:
+            LookupError: If resource not found
+
+        Example:
+            >>> buckets_service.retrieve("my-bucket", folder_path="Shared")
+            Bucket(name="my-bucket", ...)
+        """
+        ...
+
+    def create(
+        self,
+        name: str,
+        *,
+        folder_path: str | None = None,
+        folder_key: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Create a new resource.
+
+        Args:
+            name: Resource name
+            folder_path: Folder path (e.g., "Shared")
+            folder_key: Folder UUID key
+            **kwargs: Additional service-specific parameters (from metadata)
+
+        Returns:
+            Created resource object
+
+        Example:
+            >>> buckets_service.create(
+            ...     "my-bucket",
+            ...     folder_path="Shared",
+            ...     description="My bucket"
+            ... )
+            Bucket(name="my-bucket", description="My bucket", ...)
+        """
+        ...
+
+    def delete(
+        self,
+        name: str,
+        *,
+        folder_path: str | None = None,
+        folder_key: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Delete a resource by identifier.
+
+        Args:
+            name: Resource identifier to delete
+            folder_path: Folder path (e.g., "Shared")
+            folder_key: Folder UUID key
+            **kwargs: Additional service-specific parameters
+
+        Raises:
+            LookupError: If resource not found
+
+        Example:
+            >>> buckets_service.delete("my-bucket", folder_path="Shared")
+        """
+        ...
+
+
+def has_exists_method(service: Any) -> bool:
+    """Check if a service has the optional exists() method.
+
+    This is separate from the Protocol because exists() is optional.
+    Not all services need to implement it.
+
+    Args:
+        service: Service instance to check
+
+    Returns:
+        True if service has a callable exists() method
+
+    Example:
+        >>> class ServiceWithExists:
+        ...     def exists(self, name, **kwargs):
+        ...         return True
+        >>>
+        >>> service = ServiceWithExists()
+        >>> has_exists_method(service)
+        True
+    """
+    return hasattr(service, "exists") and callable(service.exists)
+
+
+def validate_service_protocol(service: Any, service_name: str) -> None:
+    """Validate that a service implements the CRUDServiceProtocol.
+
+    Args:
+        service: Service instance to validate
+        service_name: Name of the service for error messages
+
+    Raises:
+        TypeError: If service doesn't implement required methods
+
+    Example:
+        >>> class IncompleteService:
+        ...     def list(self):
+        ...         pass
+        ...     # Missing other methods
+        >>>
+        >>> validate_service_protocol(IncompleteService(), "incomplete")
+        Traceback (most recent call last):
+        ...
+        TypeError: Service 'incomplete' must implement: retrieve, create, delete
+    """
+    required_methods = ["list", "retrieve", "create", "delete"]
+    missing_methods = []
+    for method_name in required_methods:
+        if not hasattr(service, method_name) or not callable(
+            getattr(service, method_name)
+        ):
+            missing_methods.append(method_name)
+
+    if missing_methods:
+        raise TypeError(
+            f"Service '{service_name}' must implement: {', '.join(missing_methods)}"
+        )
+
+
+__all__ = ["CRUDServiceProtocol", "validate_service_protocol", "has_exists_method"]
diff --git a/packages/uipath/src/uipath/_cli/_utils/_studio_project.py b/packages/uipath/src/uipath/_cli/_utils/_studio_project.py
new file mode 100644
index 000000000..f70c3e96a
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_studio_project.py
@@ -0,0 +1,951 @@
+import json
+import logging
+import os
+from enum import Enum
+from functools import wraps
+from pathlib import PurePath
+from typing import Any, Callable, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from uipath._utils.constants import (
+    ENV_TENANT_ID,
+    HEADER_SW_LOCK_KEY,
+    HEADER_TENANT_ID,
+    PYTHON_CONFIGURATION_FILE,
+    STUDIO_METADATA_FILE,
+)
+from uipath.platform import UiPath
+from uipath.platform.common import (
+    ResourceOverwrite,
+    ResourceOverwriteParser,
+    UiPathConfig,
+)
+from uipath.platform.errors import EnrichedException
+from uipath.tracing import traced
+
+logger = logging.getLogger(__name__)
+
+
+class NonCodedAgentProjectException(Exception):
+    """Raised when the targeted project is not a coded agent one."""
+
+    pass
+
+
+class ProjectFile(BaseModel):
+    """Model representing a file in a UiPath project.
+
+    Attributes:
+        id: The unique identifier of the file
+        name: The name of the file
+        is_main: Whether this is a main file
+        file_type: The type of the file
+        is_entry_point: Whether this is an entry point
+        ignored_from_publish: Whether this file is ignored during publish
+        app_form_id: The ID of the associated app form
+        external_automation_id: The ID of the external automation
+        test_case_id: The ID of the associated test case
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: str = Field(alias="id")
+    name: str = Field(alias="name")
+    is_main: Optional[bool] = Field(default=None, alias="isMain")
+    file_type: Optional[str] = Field(default=None, alias="fileType")
+    is_entry_point: Optional[bool] = Field(default=None, alias="isEntryPoint")
+    ignored_from_publish: Optional[bool] = Field(
+        default=None, alias="ignoredFromPublish"
+    )
+    app_form_id: Optional[str] = Field(default=None, alias="appFormId")
+    external_automation_id: Optional[str] = Field(
+        default=None, alias="externalAutomationId"
+    )
+    test_case_id: Optional[str] = Field(default=None, alias="testCaseId")
+
+    @field_validator("file_type", mode="before")
+    @classmethod
+    def convert_file_type(cls, v: Union[str, int, None]) -> Optional[str]:
+        """Convert numeric file type to string.
+
+        Args:
+            v: The value to convert
+
+        Returns:
+            Optional[str]: The converted value or None
+        """
+        if isinstance(v, int):
+            return str(v)
+        return v
+
+
+class ProjectFolder(BaseModel):
+    """Model representing a folder in a UiPath project structure.
+
+    Attributes:
+        id: The unique identifier of the folder. Root folder id may be None.
+        name: The name of the folder
+        folders: List of subfolders
+        files: List of files in the folder
+        folder_type: The type of the folder
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: Optional[str] = Field(default=None, alias="id")
+    name: str = Field(alias="name")
+    folders: List["ProjectFolder"] = Field(default_factory=list)
+    files: List[ProjectFile] = Field(default_factory=list)
+    folder_type: Optional[str] = Field(default=None, alias="folderType")
+
+    @field_validator("folder_type", mode="before")
+    @classmethod
+    def convert_folder_type(cls, v: Union[str, int, None]) -> Optional[str]:
+        """Convert numeric folder type to string.
+
+        Args:
+            v: The value to convert
+
+        Returns:
+            Optional[str]: The converted value or None
+        """
+        if isinstance(v, int):
+            return str(v)
+        return v
+
+
+class ProjectStructure(ProjectFolder):
+    """Model representing the complete file structure of a UiPath project.
+
+    Attributes:
+        id: The unique identifier of the root folder (optional)
+        name: The name of the root folder (optional)
+        folders: List of folders in the project
+        files: List of files at the root level
+        folder_type: The type of the root folder (optional)
+    """
+
+
+class LockInfo(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+    project_lock_key: Optional[str] = Field(alias="projectLockKey")
+    solution_lock_key: Optional[str] = Field(alias="solutionLockKey")
+
+
+class ResourceBuilderMetadataVersion(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    supports_in_line_creation: bool = Field(
+        default=False, alias="supportsInLineCreation"
+    )
+
+
+class ResourceBuilderMetadataEntry(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    kind: str
+    type: str | None = None
+    versions: list[ResourceBuilderMetadataVersion] = Field(default_factory=list)
+
+
+class VirtualResourceRequest(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    kind: str = Field(alias="kind")
+    name: str = Field(alias="name")
+    type: Optional[str] = Field(default=None, alias="type")
+    activity_name: Optional[str] = Field(default=None, alias="activityName")
+    api_version: Optional[str] = Field(default=None, alias="apiVersion")
+
+
+class Status(str, Enum):
+    ADDED = "ADDED"
+    UNCHANGED = "UNCHANGED"
+    UPDATED = "UPDATED"
+
+
+class VirtualResourceResult(BaseModel):
+    """Structured outcome of a virtual resource creation attempt.
+
+    Only `ADDED` and `UNCHANGED` are possible — virtual resources are never
+    updated in place.
+    """
+
+    status: Status
+
+
+class ReferencedResourceFolder(BaseModel):
+    """Folder reference for a referenced resource.
+
+    Attributes:
+        fully_qualified_name: The fully qualified name of the folder
+        path: The path to the folder
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    folder_key: str = Field(alias="folderKey")
+    fully_qualified_name: str = Field(alias="fullyQualifiedName")
+    path: str = Field(alias="path")
+
+
+type_mappings = {
+    "text": "stringAsset",
+    "integer": "integerAsset",
+    "bool": "booleanAsset",
+    "credential": "credentialAsset",
+    "secret": "secretAsset",
+    "orchestrator": "orchestratorBucket",
+    "amazon": "amazonBucket",
+    "azure": "azureBucket",
+}
+
+
+class ReferencedResourceRequest(BaseModel):
+    """Request payload for creating a referenced resource.
+
+    Attributes:
+        key: The resource key
+        kind: The kind of resource
+        type: The type of resource
+        folder: Folder of the referenced resource
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    key: str = Field(alias="key")
+    kind: str = Field(alias="kind")
+    type: Optional[str] = Field(alias="type")
+    folder: ReferencedResourceFolder = Field(alias="folder")
+
+    @field_validator("kind", mode="before")
+    @classmethod
+    def lowercase_kind(cls, v: str) -> str:
+        return v[0].lower() + v[1:] if v else v
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def type_mapping(cls, v: Optional[str]) -> Optional[str]:
+        if not v:
+            return v
+        if v.lower() in type_mappings:
+            return type_mappings[v.lower()]
+        return v[0].lower() + v[1:]
+
+
+class ResourceOverwriteData(BaseModel):
+    """Represents the overwrite details from the API response.
+
+    Attributes:
+        name: The name of the resource being overwritten
+        folder_path: The folder path of the overwrite resource
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    name: str = Field(alias="name")
+    folder_path: str = Field(alias="folderPath")
+
+
+def get_folder_by_name(
+    structure: ProjectStructure, folder_name: str | None
+) -> Optional[ProjectFolder]:
+    """Get a folder from the project structure by name.
+
+    Args:
+        structure: The project structure
+        folder_name: Name of the folder to find or None for root folder
+
+    Returns:
+        Optional[ProjectFolder]: The found folder or None
+    """
+    if not folder_name:
+        return structure
+
+    for folder in structure.folders:
+        if folder.name == folder_name:
+            return folder
+    return None
+
+
+def get_subfolder_by_name(
+    parent_folder: ProjectFolder, subfolder_name: str
+) -> Optional[ProjectFolder]:
+    """Get a subfolder from within a parent folder by name.
+
+    Args:
+        parent_folder: The parent folder to search within
+        subfolder_name: Name of the subfolder to find
+
+    Returns:
+        Optional[ProjectFolder]: The found subfolder or None
+    """
+    for folder in parent_folder.folders:
+        if folder.name == subfolder_name:
+            return folder
+    return None
+
+
+def resolve_path(
+    folder: ProjectFolder,
+    path: PurePath,
+) -> ProjectFile | ProjectFolder:
+    """Resolve a path relative to the folder.
+
+    Args:
+        folder: Project folder
+        path: Path relative to the folder
+
+    Returns: The resolved folder or file. If resolution fails, an assertion is raised.
+    """
+    root = path.parts
+    while len(root) > 1:
+        child = next(
+            (folder for folder in folder.folders if folder.name == root[0]), None
+        )
+        assert child, "Path not found."
+        folder = child
+        root = root[1:]
+    file = next((f for f in folder.files if f.name == root[0]), None)
+    child = next((folder for folder in folder.folders if folder.name == root[0]), None)
+    resolved = file or child
+    assert resolved, "Path not found."
+    return resolved
+
+
+class AddedResource(BaseModel):
+    """Represents a new file to be added during a structural migration."""
+
+    content_file_path: Optional[str] = None
+    parent_path: Optional[str] = None
+    file_name: Optional[str] = None
+    content_string: Optional[str] = None
+
+
+class ModifiedResource(BaseModel):
+    """Represents a file update during a structural migration."""
+
+    id: str
+    content_file_path: Optional[str] = None
+    content_string: Optional[str] = None
+
+
+class StructuralMigration(BaseModel):
+    deleted_resources: List[str]
+    added_resources: List[AddedResource]
+    modified_resources: List[ModifiedResource]
+
+
+class ProjectLockUnavailableError(RuntimeError):
+    """Raised when a project lock prevents execution."""
+
+    pass
+
+
+class ReferencedResourceResponse(BaseModel):
+    """Response from creating a referenced resource.
+
+    Attributes:
+        status: The status of the operation
+        resource: The resource details
+        saved: Whether the resource was saved
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    status: Status
+    resource: dict[str, Any]
+    saved: bool
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def parse_status(cls, v: str | Status) -> Status:
+        """Parse status string to Status enum."""
+        if isinstance(v, Status):
+            return v
+        if isinstance(v, str):
+            upper_v = v.upper()
+            for status in Status:
+                if status.value == upper_v:
+                    return status
+            raise ValueError(f"Invalid status value: {v}")
+        raise ValueError(
+            f"Status must be a string or Status enum, got {type(v).__name__}"
+        )
+
+
+def with_lock_retry(func: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(self: "StudioClient", *args, **kwargs):
+        try:
+            lock_info: LockInfo = await self._retrieve_lock()
+            if lock_info is not None and lock_info.project_lock_key is not None:
+                headers = kwargs.get("headers", {}) or {}
+                headers[HEADER_SW_LOCK_KEY] = lock_info.project_lock_key
+                kwargs["headers"] = headers
+
+            return await func(self, *args, **kwargs)
+        except EnrichedException as e:
+            if e.status_code == 423:
+                raise ProjectLockUnavailableError(
+                    "Project is locked by another operation. Please try again later."
+                ) from e
+            raise
+
+    return wrapper
+
+
+class StudioSolutionsClient:
+    def __init__(self, solution_id: str):
+        from uipath.platform import UiPath
+
+        self.uipath: UiPath = UiPath()
+        self._solutions_base_url: str = f"/studio_/backend/api/Solution/{solution_id}"
+
+    @traced(name="create_project", run_type="uipath")
+    async def create_project_async(
+        self,
+        project_name: str,
+        project_type: str = "Agent",
+        trigger_type: str = "Manual",
+        description: Optional[str] = None,
+    ):
+        """Create a new project in the specified solution.
+
+        Args:
+            project_name: The name for the new project
+            project_type: The type of project to create (default: "Agent")
+            trigger_type: The trigger type for the project (default: "Manual")
+
+        Returns:
+            dict: The created project details including project ID
+        """
+        data = {
+            "createDefaultProjectCommand[projectType]": project_type,
+            "createDefaultProjectCommand[triggerType]": trigger_type,
+            "createDefaultProjectCommand[name]": project_name,
+            "createDefaultProjectCommand[description]": description,
+        }
+
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"{self._solutions_base_url}/projects",
+            data=data,
+            scoped="org",
+        )
+
+        return response.json()
+
+
+class StudioProjectMetadata(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    schema_version: int = Field(alias="schemaVersion")
+    last_push_date: str | None = Field(alias="lastPushDate", default=None)
+    last_push_author: str | None = Field(alias="lastPushAuthor", default=None)
+    code_version: str = Field(alias="codeVersion")
+
+
+class StudioClient:
+    def __init__(self, project_id: str, uipath: Optional[UiPath] = None):
+        self.uipath: UiPath = uipath or UiPath()
+        self.file_operations_base_url: str = (
+            f"/studio_/backend/api/Project/{project_id}/FileOperations"
+        )
+        self._lock_operations_base_url: str = (
+            f"/studio_/backend/api/Project/{project_id}/Lock"
+        )
+        self._project_id = project_id
+        self._resources_cache: Optional[List[dict[str, Any]]] = None
+        self._project_structure_cache: Optional[ProjectStructure] = None
+
+    async def _get_solution_id(self) -> str:
+        # implement property cache logic as coroutines are not supported
+        if (solution_id := UiPathConfig.studio_solution_id) is not None:
+            return solution_id
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"/studio_/backend/api/Project/{self._project_id}",
+            scoped="org",
+        )
+        UiPathConfig.studio_solution_id = response.json()["solutionId"]
+        return UiPathConfig.studio_solution_id
+
+    async def ensure_coded_agent_project_async(self):
+        structure = await self.get_project_structure_async()
+        if not any(file.name == PYTHON_CONFIGURATION_FILE for file in structure.files):
+            raise NonCodedAgentProjectException()
+
+    async def get_project_metadata_async(self) -> Optional[StudioProjectMetadata]:
+        structure = await self.get_project_structure_async()
+
+        folder = get_folder_by_name(structure, ".uipath")
+        if not folder:
+            return None
+        try:
+            file = next(
+                file for file in folder.files if file.name == STUDIO_METADATA_FILE
+            )
+        except StopIteration:
+            return None
+        response = await self.download_project_file_async(file)
+        return StudioProjectMetadata.model_validate_json(
+            response.read().decode("utf-8")
+        )
+
+    async def get_resource_builder_metadata(
+        self,
+    ) -> list[ResourceBuilderMetadataEntry]:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url="/studio_/backend/api/resourcebuilder/metadata",
+            scoped="org",
+        )
+        return [
+            ResourceBuilderMetadataEntry.model_validate(entry)
+            for entry in response.json()
+        ]
+
+    async def _get_existing_resources(self) -> List[dict[str, Any]]:
+        if self._resources_cache is not None:
+            return self._resources_cache
+
+        solution_id = await self._get_solution_id()
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/entities",
+            scoped="org",
+        )
+        resources_data = response.json().get("resources", [])
+        self._resources_cache = [
+            {"name": r.get("name"), "kind": r.get("kind")} for r in resources_data
+        ]
+        return self._resources_cache
+
+    async def get_resource_overwrites(self) -> dict[str, ResourceOverwrite]:
+        """Get resource overwrites from the solution.
+
+        Returns:
+            dict[str, ResourceOverwrite]: Dict of resource overwrites
+        """
+        if not os.path.exists(UiPathConfig.bindings_file_path):
+            logger.warning(
+                "Bindings file not found at %s, no overwrites to fetch from Studio",
+                UiPathConfig.bindings_file_path,
+            )
+            return {}
+
+        with open(UiPathConfig.bindings_file_path, "rb") as f:
+            file_content = f.read()
+
+        logger.info(
+            "Resource bindings (%s):\n%s",
+            UiPathConfig.bindings_file_path,
+            file_content.decode(),
+        )
+
+        solution_id = await self._get_solution_id()
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+
+        files = [
+            (
+                "file",
+                (
+                    os.path.basename(UiPathConfig.bindings_file_path),
+                    file_content,
+                    "application/json",
+                ),
+            )
+        ]
+
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"/studio_/backend/api/resourcebuilder/{solution_id}/binding-overwrites",
+            scoped="org",
+            headers={HEADER_TENANT_ID: tenant_id},
+            files=files,
+        )
+        data = response.json()
+
+        logger.info(
+            "Resource overwrites received for solution %s (%d entries):\n%s",
+            solution_id,
+            len(data),
+            json.dumps(data, indent=2),
+        )
+
+        overwrites = {}
+        for key, value in data.items():
+            overwrites[key] = ResourceOverwriteParser.parse(key, value)
+
+        return overwrites
+
+    async def create_virtual_resource(
+        self, virtual_resource_request: VirtualResourceRequest
+    ) -> VirtualResourceResult:
+        """Create a virtual resource, or report UNCHANGED if already present.
+
+        Returns UNCHANGED when the same name+kind already exists in the
+        solution. Name collisions with a different kind are not checked
+        client-side — they surface as a server error via EnrichedException.
+        """
+        name = virtual_resource_request.name
+        kind = virtual_resource_request.kind
+        existing_resources = await self._get_existing_resources()
+
+        if any(r["name"] == name and r["kind"] == kind for r in existing_resources):
+            return VirtualResourceResult(status=Status.UNCHANGED)
+
+        solution_id = await self._get_solution_id()
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/virtual",
+            scoped="org",
+            json=virtual_resource_request.model_dump(exclude_none=True),
+        )
+        resource_key = response.json()["key"]
+        await self._update_resource_specs(resource_key, new_specs={"name": name})
+
+        if self._resources_cache is not None:
+            self._resources_cache.append({"name": name, "kind": kind})
+
+        return VirtualResourceResult(status=Status.ADDED)
+
+    async def create_referenced_resource(
+        self, referenced_resource_request: ReferencedResourceRequest
+    ) -> ReferencedResourceResponse:
+        """Create a referenced resource.
+
+        Args:
+            referenced_resource_request: The referenced resource request details
+
+        Returns:
+            ReferencedResourceResponse: Serialized response with status, resource details, and saved flag
+        """
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+
+        solution_id = await self._get_solution_id()
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/reference",
+            scoped="org",
+            json=referenced_resource_request.model_dump(
+                by_alias=True, exclude_none=True
+            ),
+            headers={HEADER_TENANT_ID: tenant_id},
+        )
+
+        return ReferencedResourceResponse.model_validate(response.json())
+
+    async def _update_resource_specs(
+        self, resource_key: str, new_specs: dict[str, Any]
+    ):
+        solution_id = await self._get_solution_id()
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+
+        await self.uipath.api_client.request_async(
+            "PATCH",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/{resource_key}/configuration",
+            scoped="org",
+            json=new_specs,
+            headers={HEADER_TENANT_ID: tenant_id},
+        )
+
+    @traced(name="get_project_structure", run_type="uipath")
+    async def get_project_structure_async(
+        self, force: bool = False
+    ) -> ProjectStructure:
+        """Retrieve the project's file structure from UiPath Cloud.
+
+        Makes an API call to fetch the complete file structure of a project,
+        including all files and folders. The response is validated against
+        the ProjectStructure model. Results are cached unless force is True.
+
+        Args:
+            force: If True, bypass cache and fetch fresh data from the API
+
+        Returns:
+            ProjectStructure: The complete project structure
+        """
+        if not force and self._project_structure_cache is not None:
+            return self._project_structure_cache
+
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/Structure",
+            scoped="org",
+        )
+
+        self._project_structure_cache = ProjectStructure.model_validate(response.json())
+        return self._project_structure_cache
+
+    @traced(name="create_folder", run_type="uipath")
+    @with_lock_retry
+    async def create_folder_async(
+        self,
+        folder_name: str,
+        parent_id: Optional[str] = None,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> str:
+        """Create a folder in the project.
+
+        Args:
+            folder_name: Name of the folder to create
+            parent_id: Optional parent folder ID
+            headers: HTTP headers (automatically injected by decorator)
+
+        Returns:
+            str: The created folder ID
+        """
+        data = {"name": folder_name}
+        if parent_id:
+            data["parent_id"] = parent_id
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"{self.file_operations_base_url}/Folder",
+            scoped="org",
+            json=data,
+            headers=headers or {},
+        )
+        return response.json()
+
+    @traced(name="download_file", run_type="uipath")
+    async def download_file_async(self, file_id: str) -> Any:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/File/{file_id}",
+            scoped="org",
+        )
+        return response
+
+    @traced(name="download_file", run_type="uipath")
+    async def download_project_file_async(self, file: ProjectFile) -> Any:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/File/{file.id}",
+            scoped="org",
+        )
+        return response
+
+    @traced(name="upload_file", run_type="uipath")
+    @with_lock_retry
+    async def upload_file_async(
+        self,
+        *,
+        local_file_path: Optional[str] = None,
+        file_content: Optional[str | bytes] = None,
+        file_name: str,
+        folder: Optional[ProjectFolder] = None,
+        remote_file: Optional[ProjectFile] = None,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> tuple[str, str]:
+        if local_file_path:
+            with open(local_file_path, "rb") as f:
+                file_content = f.read()
+        files_data = {"file": (file_name, file_content, "application/octet-stream")}
+
+        if remote_file:
+            # File exists in source_code folder, use PUT to update
+            response = await self.uipath.api_client.request_async(
+                "PUT",
+                files=files_data,
+                url=f"{self.file_operations_base_url}/File/{remote_file.id}",
+                scoped="org",
+                headers=headers or {},
+            )
+            action = "Updated"
+        else:
+            response = await self.uipath.api_client.request_async(
+                "POST",
+                url=f"{self.file_operations_base_url}/File",
+                data={"parentId": folder.id} if folder else None,
+                files=files_data,
+                scoped="org",
+                headers=headers or {},
+            )
+            action = "Uploaded"
+
+        # response contains only the uploaded file identifier
+        return response.json(), action
+
+    @traced(name="delete_file", run_type="uipath")
+    @with_lock_retry
+    async def delete_item_async(
+        self,
+        item_id: str,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> None:
+        await self.uipath.api_client.request_async(
+            "DELETE",
+            url=f"{self.file_operations_base_url}/Delete/{item_id}",
+            scoped="org",
+            headers=headers or {},
+        )
+
+    def _resolve_content_and_filename(
+        self,
+        *,
+        content_string: Optional[str],
+        content_file_path: Optional[str],
+        file_name: Optional[str] = None,
+        modified: bool = False,
+    ) -> tuple[bytes, Optional[str]]:
+        """Resolve multipart content bytes and filename for a resource.
+
+        Args:
+            content_string: Inline content as a string.
+            content_file_path: Path to a local file to read if inline content is not provided.
+            file_name: Explicit filename to use when adding a new resource.
+
+        Returns:
+            A tuple of (content_bytes, filename).
+
+        Raises:
+            FileNotFoundError: If a provided file path does not exist.
+            ValueError: If a filename cannot be determined.
+        """
+        content_bytes: bytes = b""
+        resolved_name: Optional[str] = None
+        if content_string is not None:
+            content_bytes = content_string.encode("utf-8")
+        elif content_file_path:
+            if os.path.exists(content_file_path):
+                with open(content_file_path, "rb") as f:
+                    content_bytes = f.read()
+            else:
+                raise FileNotFoundError(f"File not found: {content_file_path}")
+
+        if file_name:
+            resolved_name = file_name
+        elif content_file_path:
+            resolved_name = os.path.basename(content_file_path)
+        elif not modified:
+            raise ValueError(
+                "Unable to determine filename for multipart upload. "
+                "When providing inline content (content_string), you must also provide file_name. "
+                "Alternatively, set content_file_path so the filename can be inferred. "
+                f"Received file_name={file_name!r}, content_file_path={content_file_path!r}."
+            )
+
+        return content_bytes, resolved_name
+
+    @traced(name="synchronize_files", run_type="uipath")
+    @with_lock_retry
+    async def perform_structural_migration_async(
+        self,
+        structural_migration: StructuralMigration,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> Any:
+        """Perform structural migration of project files.
+
+        Args:
+            structural_migration: The structural migration data containing deleted and added resources
+            headers: HTTP headers (automatically injected by decorator)
+
+        Returns:
+            Any: The API response
+        """
+        files: Any = []
+        deleted_resources_json = json.dumps(structural_migration.deleted_resources)
+
+        files.append(
+            (
+                "DeletedResources",
+                (None, deleted_resources_json),
+            )
+        )
+        for i, added_resource in enumerate(structural_migration.added_resources):
+            content_bytes, filename = self._resolve_content_and_filename(
+                content_string=added_resource.content_string,
+                content_file_path=added_resource.content_file_path,
+                file_name=added_resource.file_name,
+            )
+
+            files.append((f"AddedResources[{i}].Content", (filename, content_bytes)))
+
+            if added_resource.parent_path:
+                files.append(
+                    (
+                        f"AddedResources[{i}].ParentPath",
+                        (None, added_resource.parent_path),
+                    )
+                )
+
+        for i, modified_resource in enumerate(structural_migration.modified_resources):
+            content_bytes, _ = self._resolve_content_and_filename(
+                content_string=modified_resource.content_string,
+                content_file_path=modified_resource.content_file_path,
+                modified=True,
+            )
+
+            files.append((f"ModifiedResources[{i}].Content", content_bytes))
+            files.append(
+                (
+                    f"ModifiedResources[{i}].Id",
+                    (None, modified_resource.id),
+                )
+            )
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"{self.file_operations_base_url}/StructuralMigration",
+            scoped="org",
+            files=files,
+            headers=headers or {},
+        )
+
+        return response
+
+    async def _retrieve_lock(self) -> LockInfo:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self._lock_operations_base_url}",
+            scoped="org",
+        )
+        return LockInfo.model_validate(response.json())
+
+    async def _put_lock(self):
+        await self.uipath.api_client.request_async(
+            "PUT",
+            url=f"{self._lock_operations_base_url}/dummy-uuid-Shared?api-version=2",
+            scoped="org",
+        )
diff --git a/src/uipath/_cli/_utils/_tracing.py b/packages/uipath/src/uipath/_cli/_utils/_tracing.py
similarity index 100%
rename from src/uipath/_cli/_utils/_tracing.py
rename to packages/uipath/src/uipath/_cli/_utils/_tracing.py
diff --git a/packages/uipath/src/uipath/_cli/_utils/_type_registry.py b/packages/uipath/src/uipath/_cli/_utils/_type_registry.py
new file mode 100644
index 000000000..d853c7d43
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_type_registry.py
@@ -0,0 +1,106 @@
+"""Type registry for safe parameter type resolution.
+
+This module provides a safe way to resolve type strings to Python types,
+replacing the use of eval() which is a security vulnerability.
+
+The TYPE_REGISTRY is used by the ServiceMetadata system to convert type
+strings (e.g., "str", "int") to actual Python types for Click parameter
+validation.
+
+Security Note:
+    This registry approach prevents arbitrary code execution that would be
+    possible with eval(). Only explicitly registered types can be used.
+
+Example:
+    >>> from ._type_registry import get_type
+    >>> str_type = get_type("str")
+    >>> str_type is str
+    True
+    >>> get_type("InvalidType")  # Raises ValueError
+    ValueError: Unknown type: 'InvalidType'. Valid types: bool, float, int, str
+"""
+
+from typing import Any, Type
+
+TYPE_REGISTRY: dict[str, Type[Any]] = {
+    "str": str,
+    "int": int,
+    "bool": bool,
+    "float": float,
+}
+
+
+def get_type(type_name: str) -> Type[Any]:
+    """Get Python type from string name safely.
+
+    Args:
+        type_name: String name of the type (e.g., "str", "int", "bool", "float")
+
+    Returns:
+        The Python type corresponding to the type name
+
+    Raises:
+        ValueError: If type_name is not in the registry
+
+    Example:
+        >>> get_type("str")
+        <class 'str'>
+        >>> get_type("int")
+        <class 'int'>
+        >>> get_type("InvalidType")
+        Traceback (most recent call last):
+        ...
+        ValueError: Unknown type: 'InvalidType'. Valid types: bool, float, int, str
+    """
+    param_type = TYPE_REGISTRY.get(type_name)
+    if param_type is None:
+        valid_types = ", ".join(sorted(TYPE_REGISTRY.keys()))
+        raise ValueError(f"Unknown type: '{type_name}'. Valid types: {valid_types}")
+    return param_type
+
+
+def register_type(type_name: str, type_class: Type[Any]) -> None:
+    """Register a new type in the registry.
+
+    This function allows extending the registry with custom types if needed.
+    Use with caution and only register types that are safe for CLI parameters.
+
+    Args:
+        type_name: String name for the type
+        type_class: The Python type class
+
+    Raises:
+        ValueError: If type_name already exists in registry
+
+    Example:
+        >>> from pathlib import Path
+        >>> register_type("path", Path)
+        >>> get_type("path")
+        <class 'pathlib.Path'>
+    """
+    if type_name in TYPE_REGISTRY:
+        raise ValueError(
+            f"Type '{type_name}' is already registered as {TYPE_REGISTRY[type_name]}"
+        )
+    TYPE_REGISTRY[type_name] = type_class
+
+
+def is_valid_type(type_name: str) -> bool:
+    """Check if a type name is registered.
+
+    Args:
+        type_name: String name to check
+
+    Returns:
+        True if type is registered, False otherwise
+
+    Example:
+        >>> is_valid_type("str")
+        True
+        >>> is_valid_type("InvalidType")
+        False
+    """
+    return type_name in TYPE_REGISTRY
+
+
+__all__ = ["TYPE_REGISTRY", "get_type", "register_type", "is_valid_type"]
diff --git a/packages/uipath/src/uipath/_cli/_utils/_uv_helpers.py b/packages/uipath/src/uipath/_cli/_utils/_uv_helpers.py
new file mode 100644
index 000000000..9464fb4ef
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_uv_helpers.py
@@ -0,0 +1,114 @@
+import os
+import subprocess
+
+from .._utils._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+def handle_uv_operations(directory: str) -> None:
+    """Handle UV package manager operations for the project.
+
+    This function checks if UV is available and if the project uses UV,
+    then ensures the lock file is up to date by running 'uv lock'.
+
+    Args:
+        directory: The project root directory where UV operations should be performed
+
+    Note:
+        This function will silently return if UV is not available or if the project
+        doesn't use UV (no uv.lock file present).
+    """
+    if not is_uv_available():
+        return
+    if not is_uv_project(directory):
+        return
+    # Always run uv lock to ensure lock file is up to date
+    run_uv_lock(directory)
+
+
+def is_uv_available() -> bool:
+    """Check if UV package manager is available in the system.
+
+    Attempts to run 'uv --version' to verify UV is installed and accessible.
+
+    Returns:
+        bool: True if UV is available and working, False otherwise
+
+    Note:
+        This function will return False if:
+        - UV is not installed
+        - UV command fails to execute
+        - Any unexpected error occurs during version check
+    """
+    try:
+        subprocess.run(["uv", "--version"], capture_output=True, check=True, timeout=20)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+    except Exception as e:
+        console.warning(
+            f"An unexpected error occurred while checking uv availability: {str(e)}"
+        )
+        return False
+
+
+def is_uv_project(directory: str) -> bool:
+    """Check if the project uses UV package manager.
+
+    Determines if this is a UV project by checking for the presence
+    of a uv.lock file in the project directory.
+
+    Args:
+        directory: The project root directory to check
+
+    Returns:
+        bool: True if uv.lock exists, indicating a UV project, False otherwise
+    """
+    uv_lock_path = os.path.join(directory, "uv.lock")
+
+    # If uv.lock exists, it's definitely a uv project
+    if os.path.exists(uv_lock_path):
+        return True
+
+    return False
+
+
+def run_uv_lock(directory: str) -> bool:
+    """Run 'uv lock' command to update the project's lock file.
+
+    Executes UV lock command to ensure dependencies are properly locked
+    and the lock file is up to date.
+
+    Args:
+        directory: The project root directory where the lock command should be run
+
+    Returns:
+        bool: True if the lock command succeeds, False if it fails for any reason
+
+    Note:
+        This function will log warnings and return False if:
+        - The UV command fails to execute
+        - UV is not found in the system
+        - The lock command times out (60 seconds)
+        - Any unexpected error occurs during execution
+    """
+    try:
+        subprocess.run(
+            ["uv", "lock"],
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        console.warning(f"uv lock failed: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        console.warning("uv command not found. Skipping lock file update.")
+        return False
+    except Exception as e:
+        console.warning(f"An unexpected error occurred while running uv lock: {str(e)}")
+        return False
diff --git a/packages/uipath/src/uipath/_cli/_utils/_validators.py b/packages/uipath/src/uipath/_cli/_utils/_validators.py
new file mode 100644
index 000000000..df5f5d815
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/_utils/_validators.py
@@ -0,0 +1,127 @@
+"""Common validators for CLI commands.
+
+This module provides reusable validation functions for common CLI inputs
+like folder paths, UUIDs, and resource names.
+"""
+
+import re
+from typing import Optional
+
+import click
+
+
+def validate_folder_path(ctx, param, value: Optional[str]) -> Optional[str]:
+    """Validate folder path format.
+
+    Folder paths should be in the format: "Folder1/Subfolder2"
+
+    Args:
+        ctx: Click context
+        param: Click parameter
+        value: Folder path to validate
+
+    Returns:
+        Validated folder path
+
+    Raises:
+        click.BadParameter: If folder path is invalid
+    """
+    if value is None:
+        return None
+
+    if value == "":
+        return value
+
+    if value.startswith("/") or value.endswith("/"):
+        raise click.BadParameter("Folder path should not start or end with '/'")
+
+    return value
+
+
+def validate_uuid(ctx, param, value: Optional[str]) -> Optional[str]:
+    """Validate UUID format.
+
+    Args:
+        ctx: Click context
+        param: Click parameter
+        value: UUID to validate
+
+    Returns:
+        Validated UUID
+
+    Raises:
+        click.BadParameter: If UUID is invalid
+    """
+    if value is None:
+        return None
+
+    # UUID regex pattern
+    uuid_pattern = re.compile(
+        r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+    )
+
+    if not uuid_pattern.match(value):
+        raise click.BadParameter(
+            f"'{value}' is not a valid UUID. "
+            "Expected format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+        )
+
+    return value
+
+
+def validate_resource_name(ctx, param, value: Optional[str]) -> Optional[str]:
+    """Validate resource name.
+
+    Resource names should:
+    - Not be empty
+    - Not contain special characters that might cause issues
+
+    Args:
+        ctx: Click context
+        param: Click parameter
+        value: Resource name to validate
+
+    Returns:
+        Validated resource name
+
+    Raises:
+        click.BadParameter: If resource name is invalid
+    """
+    if value is None:
+        return None
+
+    if not value.strip():
+        raise click.BadParameter("Resource name cannot be empty")
+
+    invalid_chars = ["<", ">", ":", '"', "|", "?", "*"]
+    for char in invalid_chars:
+        if char in value:
+            raise click.BadParameter(
+                f"Resource name contains invalid character: '{char}'"
+            )
+
+    return value
+
+
+def validate_mutually_exclusive(ctx, param, value, exclusive_with: str):
+    """Validate that two options are mutually exclusive.
+
+    Args:
+        ctx: Click context
+        param: Click parameter
+        value: Current parameter value (can be any type)
+        exclusive_with: Name of the mutually exclusive parameter
+
+    Returns:
+        Validated value
+
+    Raises:
+        click.UsageError: If both parameters are provided
+    """
+    if value is not None and ctx.params.get(exclusive_with) is not None:
+        raise click.UsageError(
+            f"--{param.name} and --{exclusive_with} are mutually exclusive. "
+            "Provide only one."
+        )
+
+    return value
diff --git a/packages/uipath/src/uipath/_cli/cli_add.py b/packages/uipath/src/uipath/_cli/cli_add.py
new file mode 100644
index 000000000..3ddfa21d7
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_add.py
@@ -0,0 +1,116 @@
+import logging
+import os
+import re
+from pathlib import Path
+from string import Template
+
+import click
+
+from uipath.eval.constants import EVALS_FOLDER
+
+from ._telemetry import track_command
+from ._utils._console import ConsoleLogger
+from ._utils._resources import Resources
+
+logger = logging.getLogger(__name__)
+console = ConsoleLogger()
+
+
+def to_pascal_case(text: str) -> str:
+    """Convert kebab-case or snake_case to PascalCase."""
+    return "".join(word.capitalize() for word in re.sub(r"[-_]", " ", text).split())
+
+
+def to_snake_case(text: str) -> str:
+    """Convert kebab-case or PascalCase to snake_case."""
+    return re.sub(r"(?<!^)(?=[A-Z])|-", "_", text).lower()
+
+
+def generate_evaluator_template(evaluator_name: str) -> str:
+    """Generate a generic evaluator template."""
+    class_name = to_pascal_case(evaluator_name)
+    if not class_name.endswith("Evaluator"):
+        class_name = class_name + "Evaluator"
+
+    variables = {
+        "class_name": class_name,
+        "evaluator_name": evaluator_name,
+        "criteria_class": class_name.replace("Evaluator", "EvaluationCriteria"),
+        "config_class": class_name + "Config",
+    }
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", "custom_evaluator.py.template"
+    )
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+
+    return Template(content).substitute(variables)
+
+
+def create_evaluator(evaluator_name):
+    cwd = Path.cwd()
+    custom_evaluators_dir = cwd / EVALS_FOLDER / "evaluators" / "custom"
+
+    if not custom_evaluators_dir.exists():
+        console.info(
+            f"Creating {click.style('evals/evaluators/custom', fg='cyan')} folder"
+        )
+        custom_evaluators_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = to_snake_case(evaluator_name)
+    if not filename.endswith(".py"):
+        filename = filename + ".py"
+
+    file_path = custom_evaluators_dir / filename
+
+    if file_path.exists():
+        console.error(f"Evaluator file already exists: {file_path}")
+
+    template_content = generate_evaluator_template(evaluator_name)
+
+    with open(file_path, "w") as f:
+        f.write(template_content)
+
+    relative_path = f"{EVALS_FOLDER}/evaluators/custom/{filename}"
+
+    console.success(f"Created new evaluator: {click.style(relative_path, fg='cyan')}")
+    console.hint("Next steps:")
+    console.hint(
+        f"  1. Edit {click.style(relative_path, fg='cyan')} to implement your evaluation logic"
+    )
+    console.hint(
+        f"  2. Run {click.style(f'uipath register evaluator {filename}', fg='cyan')} to generate the evaluator spec"
+    )
+
+
+@click.command()
+@click.argument("resource", required=True)
+@click.argument("args", nargs=-1)
+@track_command("add")
+def add(resource: str, args: tuple[str]) -> None:
+    """Create a local resource.
+
+    Examples:
+        uipath add evaluator my-custom-evaluator
+    """
+    match Resources.from_string(resource):
+        case Resources.EVALUATOR:
+            usage_hint = f"Usage: {click.style('uipath add evaluator <evaluator_name>', fg='cyan')}"
+            if len(args) < 1:
+                console.hint(usage_hint)
+                console.error("Missing required argument: evaluator_name")
+                return
+            if len(args) > 1:
+                console.hint(usage_hint)
+                console.error(
+                    f"Too many arguments provided: {args}. Expected only evaluator_name."
+                )
+
+            evaluator_name = args[0]
+
+            if not isinstance(evaluator_name, str) or not evaluator_name.strip():
+                console.hint(usage_hint)
+                console.error("Invalid evaluator_name: must be a non-empty string")
+                return
+
+            create_evaluator(evaluator_name)
diff --git a/packages/uipath/src/uipath/_cli/cli_auth.py b/packages/uipath/src/uipath/_cli/cli_auth.py
new file mode 100644
index 000000000..753ba9e85
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_auth.py
@@ -0,0 +1,105 @@
+import asyncio
+
+import click
+
+from ._auth._auth_service import AuthService
+from ._utils._common import environment_options
+from ._utils._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+@click.command()
+@environment_options
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="Force new token",
+)
+@click.option(
+    "--client-id",
+    required=False,
+    help="Client ID for client credentials authentication (unattended mode)",
+)
+@click.option(
+    "--client-secret",
+    required=False,
+    help="Client secret for client credentials authentication (unattended mode)",
+)
+@click.option(
+    "--base-url",
+    required=False,
+    help="Base URL for the UiPath tenant instance (required for client credentials)",
+)
+@click.option(
+    "--tenant",
+    required=False,
+    help="Tenant name within UiPath Automation Cloud",
+)
+@click.option(
+    "--scope",
+    required=False,
+    default="OR.Execution",
+    help="Space-separated list of OAuth scopes to request (e.g., 'OR.Execution OR.Queues'). Defaults to 'OR.Execution'",
+)
+def auth(
+    environment: str,
+    force: bool = False,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+    base_url: str | None = None,
+    tenant: str | None = None,
+    scope: str | None = None,
+):
+    r"""Authenticate with UiPath Cloud Platform.
+
+    The authentication domain is determined in the following order:
+
+    1. The ``UIPATH_URL`` environment variable (if set).
+    2. A flag: ``--cloud`` (default), ``--staging``, or ``--alpha``.
+
+    **Modes:**
+
+    - Interactive (default): Opens a browser window for OAuth authentication.
+    - Unattended: Uses the client credentials flow. Requires ``--client-id``,
+      ``--client-secret``, ``--base-url``, and ``--scope``.
+
+    **Environment Variables:**
+
+    - ``HTTP_PROXY`` / ``HTTPS_PROXY`` / ``NO_PROXY`` — proxy configuration.
+    - ``REQUESTS_CA_BUNDLE`` — path to a custom CA bundle for SSL verification.
+    - ``UIPATH_DISABLE_SSL_VERIFY`` — disables SSL verification (not recommended).
+
+    **Examples:**
+
+        Interactive login (opens browser for OAuth):
+
+        $ uipath auth
+
+        Unattended login using client credentials:
+
+        $ uipath auth --base-url https://cloud.uipath.com/organization/tenant --client-id 00000000-0000-0000-0000-000000000000 --client-secret 'secret_value_here'
+
+    """
+    auth_service = AuthService(
+        environment=environment,
+        force=force,
+        client_id=client_id,
+        client_secret=client_secret,
+        base_url=base_url,
+        tenant=tenant,
+        scope=scope,
+    )
+    with console.spinner("Authenticating with UiPath ..."):
+        try:
+            asyncio.run(auth_service.authenticate())
+            console.success(
+                "Authentication successful.",
+            )
+        except KeyboardInterrupt:
+            console.error(
+                "Authentication cancelled by user.",
+            )
diff --git a/packages/uipath/src/uipath/_cli/cli_debug.py b/packages/uipath/src/uipath/_cli/cli_debug.py
new file mode 100644
index 000000000..92b8ea454
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_debug.py
@@ -0,0 +1,236 @@
+import asyncio
+import logging
+from typing import cast, get_args
+
+import click
+
+from uipath._cli._chat._bridge import get_chat_bridge
+from uipath._cli._debug._bridge import DebugAttachMode, get_debug_bridge
+from uipath._cli._utils._debug import setup_debugging
+from uipath._cli._utils._studio_project import StudioClient
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.mocks import UiPathMockRuntime
+from uipath.eval.mocks._mock_runtime import load_simulation_config
+from uipath.platform.common import ResourceOverwritesContext, UiPathConfig
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeContext,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeFactoryRegistry,
+    UiPathRuntimeProtocol,
+)
+from uipath.runtime.chat import UiPathChatProtocol, UiPathChatRuntime
+from uipath.runtime.debug import UiPathDebugProtocol, UiPathDebugRuntime
+from uipath.tracing import LiveTrackingSpanProcessor, LlmOpsHttpExporter
+
+from ._telemetry import track_command
+from ._utils._console import ConsoleLogger
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.argument("entrypoint", required=False)
+@click.argument("input", required=False, default=None)
+@click.option("--resume", is_flag=True, help="Resume execution from a previous state")
+@click.option(
+    "-f",
+    "--file",
+    required=False,
+    type=click.Path(exists=True),
+    help="File path for the .json input",
+)
+@click.option(
+    "--input-file",
+    required=False,
+    type=click.Path(exists=True),
+    help="Alias for '-f/--file' arguments",
+)
+@click.option(
+    "--output-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the output will be written",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debugging with debugpy. The process will wait for a debugger to attach.",
+)
+@click.option(
+    "--debug-port",
+    type=int,
+    default=5678,
+    help="Port for the debug server (default: 5678)",
+)
+@click.option(
+    "--attach",
+    type=click.Choice(list(get_args(DebugAttachMode)), case_sensitive=False),
+    default=None,
+    help=(
+        "Debugger attach mode. Defaults to 'signalr' for cloud runs, "
+        "'console' for local runs."
+    ),
+)
+@track_command("debug")
+def debug(
+    entrypoint: str | None,
+    input: str | None,
+    resume: bool,
+    file: str | None,
+    input_file: str | None,
+    output_file: str | None,
+    debug: bool,
+    debug_port: int,
+    attach: str | None,
+) -> None:
+    """Debug the project."""
+    input_file = file or input_file
+    # Setup debugging if requested
+    if not setup_debugging(debug, debug_port):
+        console.error(f"Failed to start debug server on port {debug_port}")
+
+    attach_mode: DebugAttachMode | None = (
+        cast(DebugAttachMode, attach.lower()) if attach else None
+    )
+
+    result = Middlewares.next(
+        "debug",
+        entrypoint,
+        input,
+        resume,
+        input_file=input_file,
+        output_file=output_file,
+        debug=debug,
+        debug_port=debug_port,
+        attach=attach_mode,
+    )
+
+    if result.error_message:
+        console.error(result.error_message)
+
+    if result.should_continue:
+        if not entrypoint:
+            console.error("""No entrypoint specified.
+    Usage: `uipath debug <entrypoint> <input_arguments> [-f <input_json_file_path>]`""")
+            return
+
+        try:
+
+            async def execute_debug_runtime():
+                trace_manager = UiPathTraceManager()
+
+                with UiPathRuntimeContext.with_defaults(
+                    input=input,
+                    input_file=input_file,
+                    output_file=output_file,
+                    resume=resume,
+                    trace_manager=trace_manager,
+                    command="debug",
+                ) as ctx:
+                    factory: UiPathRuntimeFactoryProtocol | None = None
+
+                    try:
+                        trigger_poll_interval: float = 5.0
+
+                        factory = UiPathRuntimeFactoryRegistry.get(context=ctx)
+                        factory_settings = await factory.get_settings()
+                        trace_settings = (
+                            factory_settings.trace_settings
+                            if factory_settings
+                            else None
+                        )
+
+                        if ctx.job_id:
+                            if UiPathConfig.is_tracing_enabled:
+                                trace_manager.add_span_processor(
+                                    LiveTrackingSpanProcessor(
+                                        LlmOpsHttpExporter(),
+                                        settings=trace_settings,
+                                    )
+                                )
+                            trigger_poll_interval = (
+                                0.0  # Polling disabled for production jobs
+                            )
+
+                        async def execute_debug_runtime():
+                            chat_runtime: UiPathRuntimeProtocol | None = None
+                            debug_bridge: UiPathDebugProtocol = get_debug_bridge(
+                                ctx, attach=attach_mode
+                            )
+                            runtime = await factory.new_runtime(
+                                entrypoint,
+                                ctx.conversation_id or ctx.job_id or "default",
+                            )
+
+                            delegate = runtime
+                            if ctx.conversation_id and ctx.exchange_id:
+                                chat_bridge: UiPathChatProtocol = get_chat_bridge(
+                                    context=ctx
+                                )
+                                chat_runtime = UiPathChatRuntime(
+                                    delegate=delegate, chat_bridge=chat_bridge
+                                )
+                                delegate = chat_runtime
+
+                            debug_runtime = UiPathDebugRuntime(
+                                delegate=delegate,
+                                debug_bridge=debug_bridge,
+                                trigger_poll_interval=trigger_poll_interval,
+                            )
+
+                            # Build mocking context with agent model for simulations
+                            schema = await runtime.get_schema()
+                            agent_model = None
+                            if schema.metadata and "settings" in schema.metadata:
+                                agent_model = schema.metadata["settings"].get("model")
+
+                            mocking_context = load_simulation_config(
+                                agent_model=agent_model
+                            )
+
+                            mock_runtime = UiPathMockRuntime(
+                                delegate=debug_runtime,
+                                mocking_context=mocking_context,
+                            )
+
+                            try:
+                                ctx.result = await mock_runtime.execute(
+                                    ctx.get_input(),
+                                    options=UiPathExecuteOptions(resume=resume),
+                                )
+                            finally:
+                                await mock_runtime.dispose()
+                                await debug_runtime.dispose()
+                                if chat_runtime:
+                                    await chat_runtime.dispose()
+                                await runtime.dispose()
+
+                        if project_id := UiPathConfig.project_id:
+                            studio_client = StudioClient(project_id)
+
+                            async with ResourceOverwritesContext(
+                                lambda: studio_client.get_resource_overwrites()
+                            ):
+                                await execute_debug_runtime()
+                        else:
+                            logger.info(
+                                "No UIPATH_PROJECT_ID configured, executing without resource overwrites"
+                            )
+                            await execute_debug_runtime()
+
+                    finally:
+                        if factory:
+                            await factory.dispose()
+
+            asyncio.run(execute_debug_runtime())
+        except Exception as e:
+            console.error(
+                f"Error occurred: {e or 'Execution failed'}", include_traceback=True
+            )
+
+
+if __name__ == "__main__":
+    debug()
diff --git a/src/uipath/_cli/cli_deploy.py b/packages/uipath/src/uipath/_cli/cli_deploy.py
similarity index 65%
rename from src/uipath/_cli/cli_deploy.py
rename to packages/uipath/src/uipath/_cli/cli_deploy.py
index fdbf44e7d..087fb890c 100644
--- a/src/uipath/_cli/cli_deploy.py
+++ b/packages/uipath/src/uipath/_cli/cli_deploy.py
@@ -1,7 +1,6 @@
-# type: ignore
 import click
 
-from ..telemetry import track
+from ._telemetry import track_command
 from .cli_pack import pack
 from .cli_publish import publish
 
@@ -21,10 +20,17 @@
     flag_value="personal",
     help="Whether to publish to the personal workspace",
 )
+@click.option(
+    "--folder",
+    "-f",
+    "folder",
+    type=str,
+    help="Folder name to publish to (skips interactive selection)",
+)
 @click.argument("root", type=str, default="./")
-@track
-def deploy(root, feed):
+@track_command("deploy")
+def deploy(root, feed, folder):
     """Pack and publish the project."""
     ctx = click.get_current_context()
     ctx.invoke(pack, root=root)
-    ctx.invoke(publish, feed=feed)
+    ctx.invoke(publish, feed=feed, folder=folder)
diff --git a/packages/uipath/src/uipath/_cli/cli_dev.py b/packages/uipath/src/uipath/_cli/cli_dev.py
new file mode 100644
index 000000000..62740dc4b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_dev.py
@@ -0,0 +1,178 @@
+import asyncio
+import signal
+
+import click
+
+from uipath._cli._utils._console import ConsoleLogger
+from uipath._cli._utils._debug import setup_debugging
+from uipath._cli.middlewares import Middlewares
+from uipath.core.tracing import UiPathTraceManager
+from uipath.runtime import UiPathRuntimeContext, UiPathRuntimeFactoryRegistry
+
+from ._telemetry import track_command
+
+console = ConsoleLogger()
+
+
+def _check_dev_dependency(interface: str) -> None:
+    """Check if uipath-dev is installed and raise helpful error if not."""
+    import importlib.util
+
+    if importlib.util.find_spec("uipath.dev") is None:
+        raise ImportError(
+            "The 'uipath-dev' package is required to use the dev command.\n"
+            "Please install it as a development dependency:\n\n"
+            "  # Using pip:\n"
+            "  pip install uipath-dev\n\n"
+            "  # Using uv:\n"
+            "  uv add uipath-dev --dev\n\n"
+        )
+
+
+@click.command()
+@click.argument(
+    "interface",
+    type=click.Choice(["terminal", "web"], case_sensitive=False),
+    default="web",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debugging with debugpy. The process will wait for a debugger to attach.",
+)
+@click.option(
+    "--debug-port",
+    type=int,
+    default=5678,
+    help="Port for the debug server (default: 5678)",
+)
+@track_command("dev")
+def dev(interface: str, debug: bool, debug_port: int) -> None:
+    """Launch UiPath Developer Console.
+
+    INTERFACE: Choose 'terminal' for console interface (default) or 'web' for browser-based interface.
+    """
+    try:
+        _check_dev_dependency(interface)
+    except ImportError as e:
+        console.error(str(e))
+        return
+
+    if not setup_debugging(debug, debug_port):
+        console.error(f"Failed to start debug server on port {debug_port}")
+
+    console.info("Launching UiPath Developer Console ...")
+    result = Middlewares.next(
+        "dev",
+        interface,
+    )
+
+    if result.should_continue is False:
+        return
+
+    if interface == "terminal":
+
+        async def run_terminal() -> None:
+            from uipath.dev import (  # type: ignore[import-untyped]
+                UiPathDeveloperConsole,
+            )
+
+            factory = None
+            try:
+                trace_manager = UiPathTraceManager()
+                factory = UiPathRuntimeFactoryRegistry.get(
+                    context=UiPathRuntimeContext(
+                        trace_manager=trace_manager, command="dev"
+                    )
+                )
+
+                app = UiPathDeveloperConsole(
+                    runtime_factory=factory, trace_manager=trace_manager
+                )
+
+                await app.run_async()
+
+            except KeyboardInterrupt:
+                console.info("Debug session interrupted by user")
+            finally:
+                if factory:
+                    try:
+                        await factory.dispose()
+                    except Exception as e:
+                        console.error(f"Error during cleanup: {e}")
+
+        asyncio.run(run_terminal())
+
+    elif interface == "web":
+
+        async def run_web() -> None:
+            from uipath.dev.server import (  # type: ignore[import-untyped]
+                UiPathDeveloperServer,
+            )
+
+            factory = None
+            app = None
+            shutdown_event = asyncio.Event()
+
+            def signal_handler(sig, frame):
+                """Handle Ctrl+C gracefully."""
+                console.info("\nShutting down gracefully...")
+                shutdown_event.set()
+
+            signal.signal(signal.SIGINT, signal_handler)
+            signal.signal(signal.SIGTERM, signal_handler)
+
+            try:
+                trace_manager = UiPathTraceManager()
+                factory = UiPathRuntimeFactoryRegistry.get(
+                    context=UiPathRuntimeContext(
+                        trace_manager=trace_manager, command="dev"
+                    )
+                )
+
+                app = UiPathDeveloperServer(
+                    runtime_factory=factory,
+                    trace_manager=trace_manager,
+                    factory_creator=lambda: UiPathRuntimeFactoryRegistry.get(
+                        context=UiPathRuntimeContext(
+                            trace_manager=trace_manager, command="dev"
+                        )
+                    ),
+                )
+
+                server_task = asyncio.create_task(app.run_async())
+                shutdown_task = asyncio.create_task(shutdown_event.wait())
+
+                # Wait for either server to complete or shutdown signal
+                done, pending = await asyncio.wait(
+                    {server_task, shutdown_task}, return_when=asyncio.FIRST_COMPLETED
+                )
+
+                for task in pending:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+
+            except Exception as e:
+                console.error(
+                    f"Error running debug interface: {str(e)}", include_traceback=True
+                )
+            finally:
+                if factory:
+                    try:
+                        await factory.dispose()
+                    except Exception as e:
+                        console.error(f"Error during factory cleanup: {e}")
+
+                await asyncio.sleep(0.2)
+
+        try:
+            asyncio.run(run_web())
+        except KeyboardInterrupt:
+            # Already handled by signal handler
+            pass
+
+    else:
+        console.error(f"Unknown interface: {interface}")
diff --git a/packages/uipath/src/uipath/_cli/cli_eval.py b/packages/uipath/src/uipath/_cli/cli_eval.py
new file mode 100644
index 000000000..e101717d6
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_eval.py
@@ -0,0 +1,464 @@
+import ast
+import asyncio
+import logging
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+import click
+
+from uipath._cli._errors import EntrypointDiscoveryException
+from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
+from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
+from uipath._cli._evals._telemetry import EvalTelemetrySubscriber
+from uipath._cli._utils._folders import get_personal_workspace_key_async
+from uipath._cli._utils._studio_project import StudioClient
+from uipath._cli.middlewares import Middlewares
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.helpers import EVAL_SETS_DIRECTORY_NAME, EvalHelpers, get_agent_model
+from uipath.eval.models.evaluation_set import EvaluationSet
+from uipath.eval.runtime import UiPathEvalContext, evaluate
+from uipath.platform.chat import set_llm_concurrency
+from uipath.platform.common import ResourceOverwritesContext, UiPathConfig
+from uipath.runtime import (
+    UiPathRuntimeContext,
+    UiPathRuntimeFactoryRegistry,
+)
+from uipath.telemetry._track import flush_events
+from uipath.tracing import (
+    JsonLinesFileExporter,
+    LiveTrackingSpanProcessor,
+    LlmOpsHttpExporter,
+)
+
+from ._utils._console import ConsoleLogger
+
+logger = logging.getLogger(__name__)
+console = ConsoleLogger()
+
+
+class LiteralOption(click.Option):
+    def type_cast_value(self, ctx, value):
+        try:
+            return ast.literal_eval(value)
+        except Exception as e:
+            raise click.BadParameter(value) from e
+
+
+def setup_reporting_prereq(no_report: bool) -> bool:
+    if no_report:
+        return False
+
+    if not UiPathConfig.is_studio_project:
+        console.warning(
+            "UIPATH_PROJECT_ID environment variable not set. Results will not be reported to Studio Web."
+        )
+        return False
+
+    if not UiPathConfig.folder_key:
+        folder_key = asyncio.run(get_personal_workspace_key_async())
+        if folder_key:
+            os.environ["UIPATH_FOLDER_KEY"] = folder_key
+    return True
+
+
+def _resolve_model_settings_override(
+    model_settings_id: str, evaluation_set: EvaluationSet
+) -> dict[str, Any] | None:
+    """Resolve model settings override from evaluation set.
+
+    Returns:
+        Model settings dict to use for override, or None if using defaults.
+        Settings are passed to factory via settings kwarg.
+    """
+    # Skip if no model settings ID specified or using default
+    if not model_settings_id or model_settings_id == "default":
+        return None
+
+    # Load evaluation set to get model settings
+    if not evaluation_set.model_settings:
+        logger.warning("No model settings available in evaluation set")
+        return None
+
+    # Find the specified model settings
+    target_model_settings = next(
+        (ms for ms in evaluation_set.model_settings if ms.id == model_settings_id),
+        None,
+    )
+
+    if not target_model_settings:
+        logger.warning(
+            f"Model settings ID '{model_settings_id}' not found in evaluation set"
+        )
+        return None
+
+    logger.info(
+        f"Applying model settings override: model={target_model_settings.model_name}, temperature={target_model_settings.temperature}"
+    )
+
+    # Return settings dict with correct keys for factory
+    override: dict[str, str | float] = {}
+    if (
+        target_model_settings.model_name
+        and target_model_settings.model_name != "same-as-agent"
+    ):
+        override["model"] = target_model_settings.model_name
+    if (
+        target_model_settings.temperature is not None
+        and target_model_settings.temperature != "same-as-agent"
+    ):
+        override["temperature"] = float(target_model_settings.temperature)
+
+    return override if override else None
+
+
+class _EvalDiscoveryError(EntrypointDiscoveryException):
+    """Raised when auto-discovery of entrypoint or eval set fails."""
+
+    def __init__(self, entrypoints: list[str], eval_sets: list[Path]):
+        super().__init__(entrypoints)
+        self.eval_sets = eval_sets
+
+    def get_usage_help(self) -> list[str]:
+        lines = super().get_usage_help()
+
+        if self.eval_sets:
+            lines.append("")
+            lines.append("Available eval sets:")
+            for f in self.eval_sets:
+                lines.append(f"  - {f}")
+        else:
+            lines.append("")
+            lines.append(
+                f"No eval sets found in '{EVAL_SETS_DIRECTORY_NAME}/' directory."
+            )
+
+        lines.append("")
+        lines.append("Usage: uipath eval <entrypoint> <eval_set>")
+        if self.entrypoints and self.eval_sets:
+            lines.append(
+                f"Example: uipath eval {self.entrypoints[0]} {self.eval_sets[0]}"
+            )
+        return lines
+
+
+def _discover_eval_sets() -> list[Path]:
+    """Discover available eval set files."""
+    eval_sets_dir = Path(EVAL_SETS_DIRECTORY_NAME)
+    if eval_sets_dir.exists():
+        return sorted(eval_sets_dir.glob("*.json"))
+    return []
+
+
+@click.command()
+@click.argument("entrypoint", required=False)
+@click.argument("eval_set", required=False)
+@click.option("--eval-ids", cls=LiteralOption, default="[]")
+@click.option(
+    "--eval-set-run-id",
+    required=False,
+    type=str,
+    help="Custom evaluation set run ID (if not provided, a UUID will be generated)",
+)
+@click.option(
+    "--no-report",
+    is_flag=True,
+    help="Do not report the evaluation results",
+    default=False,
+)
+@click.option(
+    "--workers",
+    type=int,
+    default=1,
+    help="Number of parallel workers for running evaluations (default: 1)",
+)
+@click.option(
+    "--output-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the output will be written",
+)
+@click.option(
+    "--enable-mocker-cache",
+    is_flag=True,
+    default=False,
+    help="Enable caching for LLM mocker responses",
+)
+@click.option(
+    "--report-coverage",
+    is_flag=True,
+    default=False,
+    help="Report evaluation coverage",
+)
+@click.option(
+    "--model-settings-id",
+    type=str,
+    default="default",
+    help="Model settings ID from evaluation set to override agent settings (default: 'default')",
+)
+@click.option(
+    "--trace-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where traces will be written in JSONL format",
+)
+@click.option(
+    "--max-llm-concurrency",
+    type=int,
+    default=20,
+    help="Maximum concurrent LLM requests (default: 20)",
+)
+@click.option(
+    "--input-overrides",
+    cls=LiteralOption,
+    default="{}",
+    help='Input field overrides per evaluation ID: \'{"eval-1": {"operator": "*"}, "eval-2": {"a": 100}}\'. Supports deep merge for nested objects.',
+)
+@click.option(
+    "--resume",
+    is_flag=True,
+    default=False,
+    help="Resume execution from a previous suspended state",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=False,
+    help="Include agent execution output (trace, result) in the output file",
+)
+def eval(
+    entrypoint: str | None,
+    eval_set: str | None,
+    eval_ids: list[str],
+    eval_set_run_id: str | None,
+    no_report: bool,
+    workers: int,
+    output_file: str | None,
+    enable_mocker_cache: bool,
+    report_coverage: bool,
+    model_settings_id: str,
+    trace_file: str | None,
+    max_llm_concurrency: int,
+    input_overrides: dict[str, Any],
+    resume: bool,
+    verbose: bool,
+) -> None:
+    """Run an evaluation set against the agent.
+
+    Args:
+        entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
+        eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
+        eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
+        workers: Number of parallel workers for running evaluations
+        no_report: Do not report the evaluation results
+        enable_mocker_cache: Enable caching for LLM mocker responses
+        report_coverage: Report evaluation coverage
+        model_settings_id: Model settings ID to override agent settings
+        trace_file: File path where traces will be written in JSONL format
+        max_llm_concurrency: Maximum concurrent LLM requests
+        input_overrides: Input field overrides mapping (direct field override with deep merge)
+        resume: Resume execution from a previous suspended state
+    """
+    set_llm_concurrency(max_llm_concurrency)
+
+    should_register_progress_reporter = setup_reporting_prereq(no_report)
+
+    result = Middlewares.next(
+        "eval",
+        entrypoint,
+        eval_set,
+        eval_ids,
+        eval_set_run_id=eval_set_run_id,
+        no_report=no_report,
+        workers=workers,
+        output_file=output_file,
+        register_progress_reporter=should_register_progress_reporter,
+    )
+
+    if result.error_message:
+        console.error(result.error_message)
+
+    if result.should_continue:
+        eval_context = UiPathEvalContext()
+        eval_context.workers = workers
+        eval_context.eval_set_run_id = eval_set_run_id
+        eval_context.enable_mocker_cache = enable_mocker_cache
+        eval_context.report_coverage = report_coverage
+        eval_context.input_overrides = input_overrides
+        eval_context.resume = resume
+        eval_context.verbose = verbose
+
+        try:
+
+            async def execute_eval():
+                event_bus = EventBus()
+
+                # Only create studio web exporter when reporting to Studio Web
+                if should_register_progress_reporter:
+                    progress_reporter = StudioWebProgressReporter()
+                    await progress_reporter.subscribe_to_eval_runtime_events(event_bus)
+
+                console_reporter = ConsoleProgressReporter()
+                await console_reporter.subscribe_to_eval_runtime_events(event_bus)
+
+                telemetry_subscriber = EvalTelemetrySubscriber()
+                await telemetry_subscriber.subscribe_to_eval_runtime_events(event_bus)
+
+                trace_manager = UiPathTraceManager()
+
+                with UiPathRuntimeContext.with_defaults(
+                    output_file=output_file,
+                    trace_manager=trace_manager,
+                    command="eval",
+                    resume=resume,
+                ) as ctx:
+                    # Set job_id in eval context for single runtime runs
+                    eval_context.job_id = ctx.job_id
+
+                    runtime_factory = UiPathRuntimeFactoryRegistry.get(context=ctx)
+
+                    try:
+                        # Auto-discover entrypoint and eval set using the runtime factory
+                        resolved_entrypoint = entrypoint
+                        eval_set_path = eval_set
+
+                        available_entrypoints = runtime_factory.discover_entrypoints()
+                        available_eval_sets = _discover_eval_sets()
+
+                        if not resolved_entrypoint:
+                            if len(available_entrypoints) == 1:
+                                resolved_entrypoint = available_entrypoints[0]
+                            else:
+                                raise _EvalDiscoveryError(
+                                    available_entrypoints, available_eval_sets
+                                )
+
+                        if not eval_set_path:
+                            if len(available_eval_sets) == 1:
+                                eval_set_path = str(available_eval_sets[0])
+                            else:
+                                raise _EvalDiscoveryError(
+                                    available_entrypoints, available_eval_sets
+                                )
+
+                        eval_context.entrypoint = resolved_entrypoint
+
+                        # Load eval set and resolve the path
+                        loaded_eval_set, resolved_eval_set_path = (
+                            EvalHelpers.load_eval_set(
+                                eval_set_path, eval_ids, input_overrides=input_overrides
+                            )
+                        )
+
+                        factory_settings = await runtime_factory.get_settings()
+                        trace_settings = (
+                            factory_settings.trace_settings
+                            if factory_settings
+                            else None
+                        )
+
+                        if (
+                            ctx.job_id or should_register_progress_reporter
+                        ) and UiPathConfig.is_tracing_enabled:
+                            # Live tracking for Orchestrator or Studio Web
+                            # Uses UIPATH_TRACE_ID from environment for trace correlation
+                            trace_manager.add_span_processor(
+                                LiveTrackingSpanProcessor(
+                                    LlmOpsHttpExporter(),
+                                    settings=trace_settings,
+                                )
+                            )
+
+                        if trace_file:
+                            trace_settings = (
+                                factory_settings.trace_settings
+                                if factory_settings
+                                else None
+                            )
+                            trace_manager.add_span_exporter(
+                                JsonLinesFileExporter(trace_file),
+                                settings=trace_settings,
+                            )
+
+                        project_id = UiPathConfig.project_id
+
+                        eval_context.execution_id = (
+                            eval_context.job_id
+                            or eval_context.eval_set_run_id
+                            or str(uuid.uuid4())
+                        )
+
+                        eval_context.evaluation_set = loaded_eval_set
+
+                        # Resolve model settings override from eval set
+                        settings_override = _resolve_model_settings_override(
+                            model_settings_id, eval_context.evaluation_set
+                        )
+
+                        runtime = await runtime_factory.new_runtime(
+                            entrypoint=eval_context.entrypoint or "",
+                            runtime_id=eval_context.execution_id,
+                            settings=settings_override,
+                        )
+
+                        eval_context.runtime_schema = await runtime.get_schema()
+
+                        eval_context.evaluators = await EvalHelpers.load_evaluators(
+                            resolved_eval_set_path,
+                            eval_context.evaluation_set,
+                            get_agent_model(eval_context.runtime_schema),
+                        )
+
+                        # Runtime is not required anymore.
+                        await runtime.dispose()
+
+                        if project_id:
+                            studio_client = StudioClient(project_id)
+
+                            async with ResourceOverwritesContext(
+                                lambda: studio_client.get_resource_overwrites()
+                            ):
+                                ctx.result = await evaluate(
+                                    runtime_factory,
+                                    trace_manager,
+                                    eval_context,
+                                    event_bus,
+                                )
+                        else:
+                            logger.debug(
+                                "No UIPATH_PROJECT_ID configured, executing evaluation without resource overwrites"
+                            )
+                            ctx.result = await evaluate(
+                                runtime_factory,
+                                trace_manager,
+                                eval_context,
+                                event_bus,
+                            )
+                    finally:
+                        await runtime_factory.dispose()
+
+            asyncio.run(execute_eval())
+
+        except _EvalDiscoveryError as e:
+            click.echo("\n".join(e.get_usage_help()))
+            if not e.entrypoints:
+                click.echo()
+                console.link(
+                    "uipath.json spec:",
+                    "https://github.com/UiPath/uipath-python/blob/main/packages/uipath/specs/uipath.spec.md",
+                )
+        except ValueError as e:
+            console.error(str(e))
+        except Exception as e:
+            console.error(
+                f"Error occurred: {e or 'Execution failed'}", include_traceback=True
+            )
+        finally:
+            flush_events()
+
+
+if __name__ == "__main__":
+    eval()
diff --git a/packages/uipath/src/uipath/_cli/cli_init.py b/packages/uipath/src/uipath/_cli/cli_init.py
new file mode 100644
index 000000000..90a4ca117
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_init.py
@@ -0,0 +1,513 @@
+import asyncio
+import enum
+import importlib.resources
+import json
+import logging
+import os
+import shutil
+import uuid
+from pathlib import Path
+from typing import Any
+
+import anyio
+import click
+from graphtty import RenderOptions, render
+from graphtty.themes import TOKYO_NIGHT
+from graphtty.types import AsciiGraph
+from mermaid_builder.flowchart import (  # type: ignore[import-untyped]
+    Chart,
+    ChartDir,
+    Link,
+    Node,
+    Subgraph,
+)
+
+from uipath.platform.common import UiPathConfig
+from uipath.runtime import (
+    UiPathRuntimeContext,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeFactoryRegistry,
+    UiPathRuntimeProtocol,
+)
+from uipath.runtime.schema import UiPathRuntimeGraph, UiPathRuntimeSchema
+
+from ._telemetry import track_command
+from ._utils._common import determine_project_type
+from ._utils._console import ConsoleLogger
+from ._utils._constants import AGENT_INITIAL_CODE_VERSION, SCHEMA_VERSION
+from ._utils._project_files import read_toml_project, resolve_existing_project_id
+from .middlewares import Middlewares
+from .models.runtime_schema import Bindings, EntryPoint
+from .models.uipath_json_schema import UiPathJsonConfig
+
+console = ConsoleLogger()
+logger = logging.getLogger(__name__)
+
+CONFIG_PATH = "uipath.json"
+
+GRAPH_INDENT = "    "
+
+
+class Action(str, enum.Enum):
+    CREATED = "Created"
+    UPDATED = "Updated"
+
+
+def generate_env_file(target_directory):
+    env_path = os.path.join(target_directory, ".env")
+
+    if not os.path.exists(env_path):
+        relative_path = os.path.relpath(env_path, target_directory)
+        with open(env_path, "w"):
+            pass
+        console.success(f"{Action.CREATED.value} '{relative_path}' file.")
+
+
+def generate_agent_md_file(
+    target_directory: str, file_name: str, no_agents_md_override: bool
+) -> bool:
+    """Generate an agent-specific file from the packaged resource.
+
+    Args:
+        target_directory: The directory where the file should be created.
+        file_name: The name of the file should be created.
+        no_agents_md_override: Whether to override existing files.
+    """
+    target_path = os.path.join(target_directory, file_name)
+
+    will_override = os.path.exists(target_path)
+
+    if will_override and no_agents_md_override:
+        console.success(
+            f"File {click.style(target_path, fg='cyan')} already exists. Skipping."
+        )
+        return False
+
+    try:
+        source_path = importlib.resources.files("uipath._resources").joinpath(file_name)
+
+        with importlib.resources.as_file(source_path) as s_path:
+            shutil.copy(s_path, target_path)
+
+        if will_override:
+            logger.debug(f"File '{target_path}' has been overridden.")
+
+        return will_override
+
+    except Exception as e:
+        console.warning(f"Could not create {file_name}: {e}")
+
+    return False
+
+
+def generate_agent_md_files(target_directory: str, no_agents_md_override: bool) -> None:
+    """Generate AGENTS.md related files and Claude Code skills.
+
+    Args:
+        target_directory: The directory where the files should be created.
+        no_agents_md_override: Whether to override existing files.
+    """
+    agent_dir = os.path.join(target_directory, ".agent")
+    os.makedirs(agent_dir, exist_ok=True)
+    claude_commands_dir = os.path.join(target_directory, ".claude", "commands")
+    os.makedirs(claude_commands_dir, exist_ok=True)
+
+    files_to_create = {
+        target_directory: ["AGENTS.md", "CLAUDE.md"],
+        agent_dir: ["CLI_REFERENCE.md", "REQUIRED_STRUCTURE.md", "SDK_REFERENCE.md"],
+        claude_commands_dir: ["new-agent.md", "eval.md"],
+    }
+
+    any_overridden = False
+    for directory, filenames in files_to_create.items():
+        for filename in filenames:
+            if generate_agent_md_file(directory, filename, no_agents_md_override):
+                any_overridden = True
+
+    if any_overridden:
+        console.success(
+            f"{Action.UPDATED.value} {click.style('AGENTS.md', fg='cyan')} files and Claude Code skills."
+        )
+        return
+
+    console.success(
+        f"{Action.CREATED.value} {click.style('AGENTS.md', fg='cyan')} files and Claude Code skills."
+    )
+
+
+def write_bindings_file(bindings: Bindings) -> Path:
+    """Write bindings to a JSON file.
+
+    Args:
+        bindings: The Bindings object to write to file
+
+    Returns:
+        str: The path to the written bindings file
+    """
+    bindings_file_path = UiPathConfig.bindings_file_path
+    with open(bindings_file_path, "w") as bindings_file:
+        json_object = bindings.model_dump(by_alias=True, exclude_unset=True)
+        json.dump(json_object, bindings_file, indent=4)
+
+    return bindings_file_path
+
+
+def write_entry_points_file(entry_points: list[UiPathRuntimeSchema]) -> Path:
+    """Write entrypoints to a JSON file.
+
+    Args:
+        entry_points: The entrypoints list
+
+    Returns:
+        str: The path to the written entry_points file
+    """
+    json_object = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+        "$id": "entry-points.json",
+        "entryPoints": [
+            ep.model_dump(
+                by_alias=True,
+                exclude_unset=True,
+            )
+            for ep in entry_points
+        ],
+    }
+
+    entry_points_file_path = UiPathConfig.entry_points_file_path
+    with open(entry_points_file_path, "w") as entry_points_file:
+        json.dump(json_object, entry_points_file, indent=4)
+
+    return entry_points_file_path
+
+
+def write_uiproj_file(
+    entry_point_schemas: list[UiPathRuntimeSchema],
+    current_directory: str,
+) -> None:
+    """Write project.uiproj file, warning if the project type changed.
+
+    Args:
+        entry_point_schemas: The entrypoint schemas from runtime discovery.
+        current_directory: The project root directory.
+
+    """
+    entry_point_models = [
+        EntryPoint.model_validate(ep.model_dump(by_alias=True, exclude_unset=True))
+        for ep in entry_point_schemas
+    ]
+    project_type = determine_project_type(entry_point_models).capitalize()
+
+    toml_data = read_toml_project(os.path.join(current_directory, "pyproject.toml"))
+    project_name = toml_data["name"]
+    project_description = toml_data.get("description")
+
+    uiproj_file_path = Path(current_directory) / str(UiPathConfig.uiproj_file_path)
+    if uiproj_file_path.exists():
+        action = Action.UPDATED.value
+        with open(uiproj_file_path, "r") as f:
+            existing = json.load(f)
+        existing_type = existing.get("ProjectType")
+        if existing_type and existing_type != project_type:
+            console.warning(
+                f'Project type changed from "{existing_type}" to "{project_type}".'
+            )
+    else:
+        action = Action.CREATED.value
+
+    json_object = {
+        "ProjectType": project_type,
+        "Name": project_name,
+        "Description": project_description,
+        "MainFile": None,
+    }
+
+    with open(uiproj_file_path, "w") as f:
+        json.dump(json_object, f, indent=2)
+
+    console.success(f"{action} '{UiPathConfig.uiproj_file_path}' file.")
+
+
+def write_studio_metadata_file(directory: str) -> None:
+    """Write studio_metadata.json with initial codeVersion and schemaVersion.
+
+    Args:
+        directory: The project root directory.
+    """
+    local_metadata_file = os.path.join(
+        directory, str(UiPathConfig.studio_metadata_file_path)
+    )
+    if os.path.exists(local_metadata_file):
+        return
+
+    metadata = {
+        "schemaVersion": SCHEMA_VERSION,
+        "codeVersion": AGENT_INITIAL_CODE_VERSION,
+    }
+    os.makedirs(os.path.dirname(local_metadata_file), exist_ok=True)
+    with open(local_metadata_file, "w") as f:
+        json.dump(metadata, f, indent=2)
+
+    console.success(
+        f"{Action.CREATED.value} '{os.path.relpath(local_metadata_file, directory)}' file."
+    )
+
+
+MERMAID_FILE_HEADER = (
+    "%% AUTO-GENERATED by `uipath init`. Do not edit manually.\n"
+    "%% Regenerated on every `uipath init`.\n"
+)
+
+
+def write_mermaid_files(entry_points: list[UiPathRuntimeSchema]) -> list[Path]:
+    """Write mermaid diagram files for each entrypoint.
+
+    Args:
+        entry_points: The entrypoints list with graph data
+
+    Returns:
+        list[Path]: List of paths to the written mermaid files
+    """
+    mermaid_paths = []
+
+    for ep in entry_points:
+        if not ep.graph:
+            continue
+
+        chart = Chart(direction=ChartDir.TB)
+
+        _add_graph_to_chart(chart, ep.graph)
+
+        mermaid_file_path = Path(os.getcwd()) / f"{ep.file_path}.mermaid"
+
+        with open(mermaid_file_path, "w") as f:
+            f.write(MERMAID_FILE_HEADER)
+            f.write(str(chart))
+
+        mermaid_paths.append(mermaid_file_path)
+
+    return mermaid_paths
+
+
+def _add_graph_to_chart(chart: Chart | Subgraph, graph: UiPathRuntimeGraph) -> None:
+    """Recursively add nodes and edges from UiPathRuntimeGraph to mermaid chart.
+
+    Args:
+        chart: The Chart or Subgraph to add nodes to
+        graph: UiPathRuntimeGraph instance
+    """
+    node_objects = {}
+
+    for node in graph.nodes:
+        if node.subgraph:
+            subgraph = Subgraph(title=node.name, direction=ChartDir.LR)
+            _add_graph_to_chart(subgraph, node.subgraph)
+            chart.add_subgraph(subgraph)
+        else:
+            mermaid_node = Node(title=node.name, id=node.id)
+            chart.add_node(mermaid_node)
+            node_objects[node.id] = mermaid_node
+
+    for edge in graph.edges:
+        link = Link(
+            src=edge.source, dest=edge.target, text=edge.label if edge.label else None
+        )
+        chart.add_link(link)
+
+
+def _enrich_graph_node_descriptions(graph_data: dict[str, Any]) -> None:
+    """Enrich graph node descriptions with metadata (model names, tool names).
+
+    Args:
+        graph_data: The graph data dict to mutate in-place.
+    """
+    node: dict[str, Any]
+    for node in graph_data.get("nodes", []):
+        meta = node.get("metadata") or {}
+        if not node.get("description"):
+            if node.get("type") == "model" and "model_name" in meta:
+                node["description"] = meta["model_name"]
+            elif node.get("type") == "tool" and "tool_names" in meta:
+                names = meta["tool_names"]
+                if isinstance(names, list):
+                    node["description"] = ", ".join(names)
+                elif isinstance(names, str):
+                    node["description"] = names
+
+
+def _render_graph(rendered: str, indent: str = GRAPH_INDENT) -> str:
+    """Indent every line of the rendered graph for visual containment.
+
+    Args:
+        rendered: The raw rendered graph string.
+        indent: The indent prefix for each line.
+
+    Returns:
+        The indented graph string.
+    """
+    return "\n".join(indent + line for line in rendered.splitlines())
+
+
+def _display_entrypoint_graphs(entry_point_schemas: list[UiPathRuntimeSchema]) -> None:
+    """Render and display ASCII graphs for all entrypoints that have graph data.
+
+    Args:
+        entry_point_schemas: List of runtime schemas with optional graph data.
+    """
+    graphs_to_render = [ep for ep in entry_point_schemas if ep.graph and ep.graph.nodes]
+
+    if not graphs_to_render:
+        return
+
+    click.echo()
+
+    for entrypoint_schema in graphs_to_render:
+        if entrypoint_schema.graph is None:
+            continue
+        title = entrypoint_schema.file_path or "Agent"
+        click.echo(click.style(f"  Entrypoint: {title}", fg="cyan", bold=True))
+        click.echo(click.style("  " + "─" * 50, fg="bright_black"))
+        click.echo()
+
+        try:
+            graph_data = entrypoint_schema.graph.model_dump()
+            _enrich_graph_node_descriptions(graph_data)
+
+            ascii_graph = AsciiGraph(**graph_data)
+            options = RenderOptions(theme=TOKYO_NIGHT, max_breadth=3, max_depth=5)
+            rendered = render(ascii_graph, options)
+            click.echo(_render_graph(rendered))
+        except Exception:
+            pass
+
+        click.echo()
+
+
+@click.command()
+@click.option(
+    "--no-agents-md-override",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="Won't override existing .agent files and AGENTS.md file.",
+)
+@track_command("initialize")
+def init(no_agents_md_override: bool) -> None:
+    """Initialize the project."""
+    with console.spinner("Initializing UiPath project ..."):
+        current_directory = os.getcwd()
+        generate_env_file(current_directory)
+
+        async def initialize() -> list[UiPathRuntimeSchema]:
+            try:
+                # Create uipath.json if it doesn't exist
+                config_path = UiPathConfig.config_file_path
+                if not config_path.exists():
+                    config = UiPathJsonConfig.create_default()
+                    config.id = resolve_existing_project_id(current_directory) or str(
+                        uuid.uuid4()
+                    )
+                    config.save_to_file(config_path)
+                    console.success(f"{Action.CREATED.value} '{config_path}' file.")
+                else:
+                    # backfill id if not present
+                    async_config_path = anyio.Path(config_path)
+                    raw_config = json.loads(await async_config_path.read_text())
+                    if not raw_config.get("id"):
+                        raw_config["id"] = resolve_existing_project_id(
+                            current_directory
+                        ) or str(uuid.uuid4())
+                        await async_config_path.write_text(
+                            json.dumps(raw_config, indent=2)
+                        )
+                        console.success(
+                            f"{Action.UPDATED.value} '{config_path}' file with 'id'."
+                        )
+
+                # Create bindings.json if it doesn't exist
+                bindings_path = UiPathConfig.bindings_file_path
+                if not bindings_path.exists():
+                    bindings_path = write_bindings_file(
+                        Bindings(version="2.0", resources=[])
+                    )
+                    console.success(f"{Action.CREATED.value} '{bindings_path}' file.")
+                else:
+                    console.info(f"'{bindings_path}' already exists, skipping.")
+
+                # Always create/update entry-points.json from runtime schemas
+                factory: UiPathRuntimeFactoryProtocol = (
+                    UiPathRuntimeFactoryRegistry.get(
+                        context=UiPathRuntimeContext(command="init")
+                    )
+                )
+                entry_point_schemas: list[UiPathRuntimeSchema] = []
+
+                try:
+                    entrypoints = factory.discover_entrypoints()
+
+                    if not entrypoints:
+                        console.warning(
+                            'No entrypoints found. Add them to `uipath.json` under "functions" or "agents": {"my_function": "src/main.py:main"}'
+                        )
+
+                    # Gather schemas from all discovered runtimes
+                    for entrypoint_name in entrypoints:
+                        runtime: UiPathRuntimeProtocol | None = None
+                        try:
+                            runtime = await factory.new_runtime(
+                                entrypoint_name, runtime_id="default"
+                            )
+                            schema = await runtime.get_schema()
+
+                            entry_point_schemas.append(schema)
+                        finally:
+                            if runtime:
+                                await runtime.dispose()
+                finally:
+                    await factory.dispose()
+
+                # Write entry-points.json with all schemas
+                entry_points_path = write_entry_points_file(entry_point_schemas)
+                console.success(
+                    f"{Action.CREATED.value} '{entry_points_path}' file with {len(entry_point_schemas)} entrypoint(s)."
+                )
+
+                # Write mermaid diagrams for each entrypoint
+                mermaid_paths = write_mermaid_files(entry_point_schemas)
+                if mermaid_paths and len(mermaid_paths) > 0:
+                    console.success(
+                        f"{Action.CREATED.value} {len(mermaid_paths)} mermaid diagram file(s)."
+                    )
+
+                write_uiproj_file(entry_point_schemas, current_directory)
+                write_studio_metadata_file(current_directory)
+
+                return entry_point_schemas
+
+            except Exception as e:
+                console.error(f"Error during initialization:\n{e}")
+                return []
+
+        entry_point_schemas = asyncio.run(initialize())
+
+        result = Middlewares.next(
+            "init",
+            options={
+                "no_agents_md_override": no_agents_md_override,
+            },
+        )
+
+        if result.error_message:
+            console.error(
+                result.error_message, include_traceback=result.should_include_stacktrace
+            )
+
+        if result.info_message:
+            console.info(result.info_message)
+
+        if not result.should_continue:
+            _display_entrypoint_graphs(entry_point_schemas)
+            return
+
+        generate_agent_md_files(current_directory, no_agents_md_override)
+
+        _display_entrypoint_graphs(entry_point_schemas)
diff --git a/src/uipath/_cli/cli_invoke.py b/packages/uipath/src/uipath/_cli/cli_invoke.py
similarity index 78%
rename from src/uipath/_cli/cli_invoke.py
rename to packages/uipath/src/uipath/_cli/cli_invoke.py
index 93cae626a..726b623d1 100644
--- a/src/uipath/_cli/cli_invoke.py
+++ b/packages/uipath/src/uipath/_cli/cli_invoke.py
@@ -1,31 +1,24 @@
-# type: ignore
+import asyncio
 import logging
 import os
-from typing import Optional
+import tomllib
 
 import click
 import httpx
-from dotenv import load_dotenv
-
-from ._utils._console import ConsoleLogger
-
-try:
-    import tomllib
-except ImportError:
-    import tomli as tomllib
 
 from .._utils._ssl_context import get_httpx_client_kwargs
-from ..telemetry import track
+from ._telemetry import track_command
 from ._utils._common import get_env_vars
-from ._utils._folders import get_personal_workspace_info
+from ._utils._console import ConsoleLogger
+from ._utils._folders import get_personal_workspace_info_async
 from ._utils._processes import get_release_info
+from .middlewares import Middlewares
 
 logger = logging.getLogger(__name__)
-load_dotenv(override=True)
 console = ConsoleLogger()
 
 
-def _read_project_details() -> [str, str]:
+def _read_project_details() -> tuple[str, str]:
     current_path = os.getcwd()
     toml_path = os.path.join(current_path, "pyproject.toml")
     if not os.path.isfile(toml_path):
@@ -51,10 +44,8 @@ def _read_project_details() -> [str, str]:
     type=click.Path(exists=True),
     help="File path for the .json input",
 )
-@track
-def invoke(
-    entrypoint: Optional[str], input: Optional[str], file: Optional[str]
-) -> None:
+@track_command("invoke")
+def invoke(entrypoint: str | None, input: str | None, file: str | None) -> None:
     """Invoke an agent published in my workspace."""
     if file:
         _, file_extension = os.path.splitext(file)
@@ -63,18 +54,18 @@ def invoke(
         with open(file) as f:
             input = f.read()
     with console.spinner("Loading configuration ..."):
-        current_path = os.getcwd()
-        load_dotenv(os.path.join(current_path, ".env"), override=True)
         [base_url, token] = get_env_vars()
 
         url = f"{base_url}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-        _, personal_workspace_folder_id = get_personal_workspace_info(base_url, token)
+        _, personal_workspace_folder_id = asyncio.run(
+            get_personal_workspace_info_async()
+        )
         project_name, project_version = _read_project_details()
-
         if not personal_workspace_folder_id:
             console.error(
                 "No personal workspace found for user. Please try reauthenticating."
             )
+            return
 
         _, release_key = get_release_info(
             base_url, token, project_name, project_version, personal_workspace_folder_id
@@ -92,6 +83,25 @@ def invoke(
             "x-uipath-organizationunitid": str(personal_workspace_folder_id),
         }
 
+        context = {
+            "url": url,
+            "payload": payload,
+            "headers": headers,
+        }
+
+        result = Middlewares.next("invoke", context)
+
+        if result.error_message:
+            console.error(
+                result.error_message, include_traceback=result.should_include_stacktrace
+            )
+
+        if result.info_message:
+            console.info(result.info_message)
+
+        if not result.should_continue:
+            return
+
         with httpx.Client(**get_httpx_client_kwargs()) as client:
             response = client.post(url, json=payload, headers=headers)
 
diff --git a/packages/uipath/src/uipath/_cli/cli_list_models.py b/packages/uipath/src/uipath/_cli/cli_list_models.py
new file mode 100644
index 000000000..7c14686a4
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_list_models.py
@@ -0,0 +1,64 @@
+from collections.abc import Iterable
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..platform.agenthub import LlmModel
+from ._utils._context import get_cli_context
+from ._utils._service_base import ServiceCommandBase, service_command
+
+
+@click.command(name="list-models")
+@click.option(
+    "--format",
+    type=click.Choice(["json", "table", "csv"]),
+    help="Output format (overrides global)",
+)
+@click.option(
+    "--output",
+    "--output-file",
+    "-o",
+    type=click.Path(),
+    help="File path where the output will be written",
+)
+@service_command
+async def list_models(ctx, format, output):
+    """List available LLM models."""
+    client = ServiceCommandBase.get_client(ctx)
+    models = await client.agenthub.get_available_llm_models_async()
+
+    fmt = format or get_cli_context(ctx).output_format
+    if fmt == "table" and not output:
+        _render_rich_table(models)
+        return None
+    return models
+
+
+def _render_rich_table(models: Iterable[LlmModel]) -> None:
+    """Render models as a rich table with one column per vendor."""
+    by_vendor: dict[str, list[str]] = {}
+    for model in models:
+        vendor = model.vendor or "Unknown"
+        by_vendor.setdefault(vendor, []).append(model.model_name)
+
+    console = Console()
+    if not by_vendor:
+        console.print("Available LLM Models: none")
+        return
+
+    for names in by_vendor.values():
+        names.sort()
+
+    vendors = sorted(by_vendor.keys())
+
+    table = Table(title="Available LLM Models", show_lines=False)
+    for vendor in vendors:
+        table.add_column(vendor, style="cyan", no_wrap=True)
+
+    max_rows = max(len(by_vendor[v]) for v in vendors)
+    for i in range(max_rows):
+        row = [by_vendor[v][i] if i < len(by_vendor[v]) else "" for v in vendors]
+        table.add_row(*row)
+
+    console.print(table)
diff --git a/src/uipath/_cli/cli_new.py b/packages/uipath/src/uipath/_cli/cli_new.py
similarity index 77%
rename from src/uipath/_cli/cli_new.py
rename to packages/uipath/src/uipath/_cli/cli_new.py
index a5088a3cd..d273055d5 100644
--- a/src/uipath/_cli/cli_new.py
+++ b/packages/uipath/src/uipath/_cli/cli_new.py
@@ -1,10 +1,10 @@
-# type: ignore
+import json
 import os
 import shutil
 
 import click
 
-from ..telemetry import track
+from ._telemetry import track_command
 from ._utils._console import ConsoleLogger
 from .middlewares import Middlewares
 
@@ -28,18 +28,26 @@ def generate_pyproject(target_directory, project_name):
 description = "{project_name}"
 authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
 dependencies = [
-    "uipath>=2.0.26"
+    "uipath>=2.10.0, <2.11.0"
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 """
 
     with open(project_toml_path, "w") as f:
         f.write(toml_content)
 
 
+def generate_uipath_json(target_directory):
+    uipath_json_path = os.path.join(target_directory, "uipath.json")
+    uipath_config = {"functions": {"main": "main.py:main"}}
+
+    with open(uipath_json_path, "w") as f:
+        json.dump(uipath_config, f, indent=2)
+
+
 @click.command()
 @click.argument("name", type=str, default="")
-@track
+@track_command("new")
 def new(name: str):
     """Generate a quick-start project."""
     directory = os.getcwd()
@@ -67,8 +75,10 @@ def new(name: str):
         console.success("Created 'main.py' file.")
         generate_pyproject(directory, name)
         console.success("Created 'pyproject.toml' file.")
+        generate_uipath_json(directory)
+        console.success("Created 'uipath.json' file.")
         init_command = """uipath init"""
-        run_command = """uipath run main.py '{"message": "Hello World!"}'"""
+        run_command = """uipath run main '{"message": "Hello World!"}'"""
         console.hint(f""" Initialize project: {click.style(init_command, fg="cyan")}""")
         console.hint(f"""Run project: {click.style(run_command, fg="cyan")}""")
 
diff --git a/packages/uipath/src/uipath/_cli/cli_pack.py b/packages/uipath/src/uipath/_cli/cli_pack.py
new file mode 100644
index 000000000..d51eec53c
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_pack.py
@@ -0,0 +1,364 @@
+import json
+import os
+import uuid
+import zipfile
+from string import Template
+
+import click
+from pydantic import TypeAdapter
+
+from uipath._cli.models.runtime_schema import Bindings, EntryPoint, EntryPoints
+from uipath._cli.models.uipath_json_schema import UiPathJsonConfig
+from uipath.eval.constants import EVALS_FOLDER, LEGACY_EVAL_FOLDER
+from uipath.platform.common import UiPathConfig
+
+from ._telemetry import track_command
+from ._utils._common import determine_project_type
+from ._utils._console import ConsoleLogger
+from ._utils._project_files import (
+    ensure_config_file,
+    files_to_include,
+    get_project_config,
+    read_toml_project,
+    resolve_existing_project_id,
+    validate_config,
+)
+from ._utils._uv_helpers import handle_uv_operations
+
+console = ConsoleLogger()
+
+schema = "https://cloud.uipath.com/draft/2024-12/entry-point"
+
+
+def get_project_version(directory):
+    toml_path = os.path.join(directory, "pyproject.toml")
+    if not os.path.exists(toml_path):
+        console.warning("pyproject.toml not found. Using default version 0.0.1")
+        return "0.0.1"
+    toml_data = read_toml_project(toml_path)
+    return toml_data["version"]
+
+
+def validate_config_structure(config_data):
+    required_fields = ["entryPoints"]
+    for field in required_fields:
+        if field not in config_data:
+            console.error(f"uipath.json is missing the required field: {field}.")
+
+
+def generate_operate_file(
+    entrypoints: list[EntryPoint],
+    config: UiPathJsonConfig,
+    dependencies=None,
+    directory: str = ".",
+):
+    if not entrypoints:
+        raise ValueError(
+            "No entry points found in entry-points.json. Please run 'uipath init' to generate valid entry points."
+        )
+
+    # prefer id from uipath.json; fall back to the legacy
+    # .telemetry.json or SW project id.
+    if config.id:
+        try:
+            uuid.UUID(config.id)
+        except ValueError:
+            console.error(f"uipath.json 'id' must be a valid GUID, got '{config.id}'.")
+
+    project_id = (
+        config.id or resolve_existing_project_id(directory) or str(uuid.uuid4())
+    )
+
+    project_type = determine_project_type(entrypoints)
+    first_entry = entrypoints[0]
+
+    operate_json_data = {
+        "$schema": schema,
+        "projectId": project_id,
+        "main": first_entry.file_path,
+        "contentType": project_type,
+        "targetFramework": "Portable",
+        "targetRuntime": "python",
+        "runtimeOptions": {
+            "requiresUserInteraction": False,
+            "isAttended": False,
+            "isConversational": config.runtime_options.is_conversational,
+        },
+    }
+
+    if dependencies:
+        operate_json_data["dependencies"] = dependencies
+
+    return operate_json_data
+
+
+def generate_entrypoints_file(entrypoints: list[EntryPoint]):
+    entrypoint_json_data = {
+        "$schema": schema,
+        "$id": "entry-points.json",
+        "entryPoints": [
+            ep.model_dump(by_alias=True, exclude_none=True) for ep in entrypoints
+        ],
+    }
+
+    return entrypoint_json_data
+
+
+def generate_bindings_content() -> Bindings:
+    return Bindings(
+        version="2.0",
+        resources=[],
+    )
+
+
+def generate_content_types_content():
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", "[Content_Types].xml.template"
+    )
+    with open(templates_path, "r") as file:
+        content_types_content = file.read()
+    return content_types_content
+
+
+def generate_nuspec_content(projectName, packageVersion, description, authors):
+    variables = {
+        "packageName": projectName,
+        "packageVersion": packageVersion,
+        "description": description,
+        "authors": authors,
+    }
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", "package.nuspec.template"
+    )
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+    return Template(content).substitute(variables)
+
+
+def generate_rels_content(nuspecPath, psmdcpPath):
+    # /package/services/metadata/core-properties/254324ccede240e093a925f0231429a0.psmdcp
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", ".rels.template"
+    )
+    nuspecId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
+    psmdcpId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
+    variables = {
+        "nuspecPath": nuspecPath,
+        "nuspecId": nuspecId,
+        "psmdcpPath": psmdcpPath,
+        "psmdcpId": psmdcpId,
+    }
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+    return Template(content).substitute(variables)
+
+
+def generate_psmdcp_content(projectName, version, description, authors):
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", ".psmdcp.template"
+    )
+
+    token = str(uuid.uuid4()).replace("-", "")[:32]
+    random_file_name = f"{uuid.uuid4().hex[:16]}.psmdcp"
+    variables = {
+        "creator": authors,
+        "description": description,
+        "packageVersion": version,
+        "projectName": projectName,
+        "publicKeyToken": token,
+    }
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+
+    return [random_file_name, Template(content).substitute(variables)]
+
+
+def generate_package_descriptor_content(entrypoints: list[EntryPoint]):
+    files = {
+        "operate.json": "content/operate.json",
+        "entry-points.json": "content/entry-points.json",
+        "bindings.json": "content/bindings_v2.json",
+    }
+
+    for entry in entrypoints:
+        files[entry.file_path] = entry.file_path
+
+    package_descriptor_content = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+        "files": files,
+    }
+
+    return package_descriptor_content
+
+
+def is_venv_dir(d):
+    return (
+        os.path.exists(os.path.join(d, "Scripts", "activate"))
+        if os.name == "nt"
+        else os.path.exists(os.path.join(d, "bin", "activate"))
+    )
+
+
+def pack_fn(
+    project_name,
+    description,
+    version,
+    authors,
+    directory,
+    dependencies=None,
+    include_uv_lock=True,
+):
+    entry_points_file_path = os.path.join(
+        directory, str(UiPathConfig.entry_points_file_path)
+    )
+    if not os.path.exists(entry_points_file_path):
+        raise Exception("'entry-points.json' file not found. Please run 'uipath init'.")
+
+    with open(entry_points_file_path, "r") as f:
+        entry_points_data = EntryPoints.model_validate(json.load(f))
+
+    entrypoints = entry_points_data.entrypoints
+
+    config_path = os.path.join(directory, "uipath.json")
+    if not os.path.exists(config_path):
+        console.error("uipath.json not found, please run `uipath init`.")
+
+    with open(config_path, "r") as f:
+        config_data = TypeAdapter(UiPathJsonConfig).validate_python(json.load(f))
+
+    operate_file = generate_operate_file(
+        entrypoints, config_data, dependencies, directory
+    )
+
+    # try to read bindings from bindings.json
+    bindings_path = os.path.join(directory, str(UiPathConfig.bindings_file_path))
+    if os.path.exists(bindings_path):
+        with open(bindings_path, "r") as f:
+            bindings_data = TypeAdapter(Bindings).validate_python(json.load(f))
+
+    content_types_content = generate_content_types_content()
+    [psmdcp_file_name, psmdcp_content] = generate_psmdcp_content(
+        project_name, version, description, authors
+    )
+    nuspec_content = generate_nuspec_content(
+        project_name, version, description, authors
+    )
+    rels_content = generate_rels_content(
+        f"/{project_name}.nuspec",
+        f"/package/services/metadata/core-properties/{psmdcp_file_name}",
+    )
+    package_descriptor_content = generate_package_descriptor_content(entrypoints)
+
+    # Create .uipath directory if it doesn't exist
+    os.makedirs(".uipath", exist_ok=True)
+
+    with zipfile.ZipFile(
+        f".uipath/{project_name}.{version}.nupkg", "w", zipfile.ZIP_DEFLATED
+    ) as z:
+        # Add metadata files
+        z.writestr(
+            f"./package/services/metadata/core-properties/{psmdcp_file_name}",
+            psmdcp_content,
+        )
+        z.writestr("[Content_Types].xml", content_types_content)
+        z.writestr(
+            "content/package-descriptor.json",
+            json.dumps(package_descriptor_content, indent=4),
+        )
+        z.writestr("content/operate.json", json.dumps(operate_file, indent=4))
+        if bindings_data:
+            z.writestr(
+                "content/bindings_v2.json",
+                json.dumps(bindings_data.model_dump(by_alias=True), indent=4),
+            )
+        z.writestr(f"{project_name}.nuspec", nuspec_content)
+        z.writestr("_rels/.rels", rels_content)
+
+        files, skipped_files = files_to_include(
+            config_data.pack_options,
+            directory,
+            include_uv_lock,
+            directories_to_ignore=[LEGACY_EVAL_FOLDER, EVALS_FOLDER],
+        )
+
+        for file in files:
+            if file.is_binary:
+                # Read binary files in binary mode
+                with open(file.file_path, "rb") as f:
+                    z.writestr(f"content/{file.relative_path}", f.read())
+            else:
+                try:
+                    # Try UTF-8 first
+                    with open(file.file_path, "r", encoding="utf-8") as f:
+                        z.writestr(f"content/{file.relative_path}", f.read())
+                except UnicodeDecodeError:
+                    # If UTF-8 fails, try with utf-8-sig (for files with BOM)
+                    try:
+                        with open(file.file_path, "r", encoding="utf-8-sig") as f:
+                            z.writestr(f"content/{file.relative_path}", f.read())
+                    except UnicodeDecodeError:
+                        # If that also fails, try with latin-1 as a fallback
+                        with open(file.file_path, "r", encoding="latin-1") as f:
+                            z.writestr(f"content/{file.relative_path}", f.read())
+
+
+def display_project_info(config):
+    max_label_length = max(
+        len(label) for label in ["Name", "Version", "Description", "Authors"]
+    )
+
+    max_length = 100
+    description = config["description"]
+    if len(description) >= max_length:
+        description = description[: max_length - 3] + " ..."
+
+    console.log(f"{'Name'.ljust(max_label_length)}: {config['project_name']}")
+    console.log(f"{'Version'.ljust(max_label_length)}: {config['version']}")
+    console.log(f"{'Description'.ljust(max_label_length)}: {description}")
+    console.log(f"{'Authors'.ljust(max_label_length)}: {config['authors']}")
+
+
+@click.command()
+@click.argument(
+    "root", type=click.Path(exists=True, file_okay=False, dir_okay=True), default="."
+)
+@click.option(
+    "--nolock",
+    is_flag=True,
+    help="Skip running uv lock and exclude uv.lock from the package",
+)
+@track_command("pack")
+def pack(root, nolock):
+    """Pack the project."""
+    version = get_project_version(root)
+
+    ensure_config_file(root)
+    config = get_project_config(root)
+    validate_config(config)
+
+    with console.spinner("Packaging project ..."):
+        try:
+            # Handle uv operations before packaging, unless nolock is specified
+            if not nolock:
+                handle_uv_operations(root)
+
+            pack_fn(
+                config["project_name"],
+                config["description"],
+                version or config["version"],
+                config["authors"],
+                root,
+                config.get("dependencies"),
+                include_uv_lock=not nolock,
+            )
+            display_project_info(config)
+            console.success("Project successfully packaged.")
+
+        except Exception as e:
+            console.error(
+                f"Failed to create package {config['project_name']}.{version or config['version']}: {str(e)}"
+            )
+
+
+if __name__ == "__main__":
+    pack()
diff --git a/src/uipath/_cli/cli_publish.py b/packages/uipath/src/uipath/_cli/cli_publish.py
similarity index 56%
rename from src/uipath/_cli/cli_publish.py
rename to packages/uipath/src/uipath/_cli/cli_publish.py
index e0682941d..246977af1 100644
--- a/src/uipath/_cli/cli_publish.py
+++ b/packages/uipath/src/uipath/_cli/cli_publish.py
@@ -1,16 +1,15 @@
-# type: ignore
+import asyncio
 import json
 import os
 
 import click
 import httpx
-from dotenv import load_dotenv
 
 from .._utils._ssl_context import get_httpx_client_kwargs
-from ..telemetry import track
+from ._telemetry import track_command
 from ._utils._common import get_env_vars
 from ._utils._console import ConsoleLogger
-from ._utils._folders import get_personal_workspace_info
+from ._utils._folders import get_personal_workspace_info_async
 from ._utils._processes import get_release_info
 
 console = ConsoleLogger()
@@ -43,6 +42,7 @@ def get_available_feeds(
         console.error(
             f"Failed to fetch available feeds. Please check your connection. Status code: {response.status_code} {response.text}"
         )
+        return []
     try:
         available_feeds = [
             feed for feed in response.json() if feed["purpose"] == "Processes"
@@ -50,6 +50,51 @@ def get_available_feeds(
         return [(feed["name"], feed["id"]) for feed in available_feeds]
     except Exception as e:
         console.error(f"Failed to deserialize available feeds: {str(e)}")
+        return []
+
+
+def find_feed_by_folder_name(
+    folder: str, available_feeds: list[tuple[str, str]]
+) -> tuple[str, str] | None:
+    """Find a feed by folder name with flexible matching.
+
+    Args:
+        folder: The folder name to search for
+        available_feeds: List of (feed_name, feed_id) tuples
+
+    Returns:
+        Tuple of (feed_name, feed_id) if found, None otherwise
+
+    Matching strategy:
+        1. Exact match (case-insensitive)
+        2. Core name match (strips "Orchestrator " prefix and " Feed" suffix)
+    """
+    folder_lower = folder.lower()
+
+    for feed_tuple in available_feeds:
+        feed_name = feed_tuple[0]
+        feed_name_lower = feed_name.lower()
+
+        # Try exact match first
+        if feed_name_lower == folder_lower:
+            return feed_tuple
+
+        # Extract the core folder name by removing "Orchestrator" prefix and "Feed" suffix
+        # e.g., "Orchestrator My Folder Name Feed" -> "My Folder Name"
+        core_name = feed_name_lower
+        feed_prefix = "orchestrator "
+        if core_name.startswith(f"{feed_prefix}"):
+            core_name = core_name[len(feed_prefix) :]  # Remove "orchestrator "
+
+        suffix = " feed"
+        if core_name.endswith(suffix):
+            core_name = core_name[: -len(suffix)]  # Remove " feed"
+
+        # Try matching with core name
+        if core_name == folder_lower:
+            return feed_tuple
+
+    return None
 
 
 @click.command()
@@ -67,16 +112,32 @@ def get_available_feeds(
     flag_value="personal",
     help="Whether to publish to the personal workspace",
 )
-@track
-def publish(feed):
+@click.option(
+    "--folder",
+    "-f",
+    "folder",
+    type=str,
+    help="Folder name to publish to (skips interactive selection)",
+)
+@track_command("publish")
+def publish(feed, folder):
     """Publish the package."""
-    current_path = os.getcwd()
-    load_dotenv(os.path.join(current_path, ".env"), override=True)
-
     [base_url, token] = get_env_vars()
     headers = {"Authorization": f"Bearer {token}"}
+    # If folder is provided directly, look it up
+    if folder:
+        with console.spinner("Fetching available package feeds..."):
+            available_feeds = get_available_feeds(base_url, headers)
 
-    if feed is None:
+        matching_feed = find_feed_by_folder_name(folder, available_feeds)
+
+        if matching_feed:
+            feed = matching_feed[1]
+            console.info(f"Using feed: {click.style(matching_feed[0], fg='cyan')}")
+        else:
+            console.display_options([f[0] for f in available_feeds], "Available feeds:")
+            console.error(f"Folder '{folder}' not found.")
+    elif feed is None:
         with console.spinner("Fetching available package feeds..."):
             available_feeds = get_available_feeds(base_url, headers)
         console.display_options(
@@ -102,19 +163,17 @@ def publish(feed):
     if not most_recent:
         console.error("No .nupkg files found. Please run `uipath pack` first.")
 
-    is_personal_workspace = False
-
+    personal_workspace_feed_id, personal_workspace_folder_id = None, None
     with console.spinner(f"Publishing most recent package: {most_recent} ..."):
         package_to_publish_path = os.path.join(".uipath", most_recent)
         url = f"{base_url}/orchestrator_/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage()"
 
         if feed and feed != "tenant":
             # Check user personal workspace
-            personal_workspace_feed_id, personal_workspace_folder_id = (
-                get_personal_workspace_info(base_url, token)
+            personal_workspace_feed_id, personal_workspace_folder_id = asyncio.run(
+                get_personal_workspace_info_async()
             )
             if feed == "personal" or feed == personal_workspace_feed_id:
-                is_personal_workspace = True
                 if (
                     personal_workspace_feed_id is None
                     or personal_workspace_folder_id is None
@@ -122,6 +181,7 @@ def publish(feed):
                     console.error(
                         "No personal workspace found for user. Please try reauthenticating."
                     )
+                    return
                 url = url + "?feedId=" + personal_workspace_feed_id
             else:
                 url = url + "?feedId=" + feed
@@ -136,32 +196,34 @@ def publish(feed):
                 if response.status_code == 200:
                     console.success("Package published successfully!")
 
-                    if is_personal_workspace:
-                        package_name = None
-                        package_version = None
+                    if personal_workspace_feed_id and (
+                        feed == "personal" or feed == personal_workspace_feed_id
+                    ):
                         try:
                             data = json.loads(response.text)["value"][0]["Body"]
                             package_name = json.loads(data)["Id"]
                             package_version = json.loads(data)["Version"]
+                            if isinstance(package_name, str):
+                                with console.spinner("Getting process information ..."):
+                                    release_id, _ = get_release_info(
+                                        base_url,
+                                        token,
+                                        package_name,
+                                        package_version,
+                                        personal_workspace_feed_id,
+                                    )
+                                if release_id:
+                                    process_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={personal_workspace_folder_id}"
+                                    console.link(
+                                        "Process configuration link:", process_url
+                                    )
+                                    console.hint(
+                                        "Use the link above to configure any environment variables"
+                                    )
+                                else:
+                                    console.warning("Failed to compose process url")
                         except json.decoder.JSONDecodeError:
                             console.warning("Failed to deserialize package name")
-                        if package_name is not None:
-                            with console.spinner("Getting process information ..."):
-                                release_id, _ = get_release_info(
-                                    base_url,
-                                    token,
-                                    package_name,
-                                    package_version,
-                                    personal_workspace_feed_id,
-                                )
-                            if release_id:
-                                process_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={personal_workspace_folder_id}"
-                                console.link("Process configuration link:", process_url)
-                                console.hint(
-                                    "Use the link above to configure any environment variables"
-                                )
-                            else:
-                                console.warning("Failed to compose process url")
                 else:
                     console.error(
                         f"Failed to publish package. Status code: {response.status_code} {response.text}"
diff --git a/packages/uipath/src/uipath/_cli/cli_pull.py b/packages/uipath/src/uipath/_cli/cli_pull.py
new file mode 100644
index 000000000..1dcdd1b8b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_pull.py
@@ -0,0 +1,90 @@
+"""CLI command for pulling remote project files from UiPath StudioWeb solution."""
+
+import asyncio
+from pathlib import Path
+
+import click
+
+from uipath.platform.common import UiPathConfig
+
+from ._telemetry import track_command
+from ._utils._common import ensure_coded_agent_project, may_override_files
+from ._utils._console import ConsoleLogger
+from ._utils._project_files import (
+    ProjectPullError,
+    pull_project,
+)
+from ._utils._studio_project import StudioClient
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument(
+    "root",
+    type=click.Path(exists=False, file_okay=False, dir_okay=True, path_type=Path),
+    default=Path("."),
+    metavar="",
+)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Automatically overwrite local files without prompts",
+)
+@track_command("pull")
+def pull(root: Path, overwrite: bool) -> None:
+    """Pull remote project files from Studio Web.
+
+    This command pulls the remote project files from a UiPath Studio Web project.
+
+    **Environment Variables:**
+        UIPATH_PROJECT_ID: Required. The ID of the UiPath Studio Web project
+
+    **Example:**
+
+        $ uipath pull
+        $ uipath pull /path/to/project
+        $ uipath pull --overwrite
+    """
+    project_id = UiPathConfig.project_id
+    if not project_id:
+        console.error("UIPATH_PROJECT_ID environment variable not found.")
+        return
+
+    studio_client = StudioClient(project_id=project_id)
+
+    result = Middlewares.next("pull", studio_client, root, overwrite)
+    if result.error_message:
+        console.error(result.error_message)
+        return
+    if not result.should_continue:
+        return
+
+    asyncio.run(ensure_coded_agent_project(studio_client))
+
+    if not overwrite:
+        may_override = asyncio.run(may_override_files(studio_client, "local"))
+        if not may_override:
+            console.info("Operation aborted.")
+            return
+
+    download_configuration: dict[str | None, Path] = {
+        None: root,
+    }
+
+    console.log("Pulling UiPath project from Studio Web...")
+
+    try:
+
+        async def run_pull():
+            async for update in pull_project(
+                project_id, download_configuration, studio_client
+            ):
+                console.info(f"Processing: {update.file_path}")
+                console.info(update.message)
+
+        asyncio.run(run_pull())
+        console.success("Project pulled successfully")
+    except ProjectPullError as e:
+        console.error(f"Failed to pull UiPath project: {str(e)}")
diff --git a/packages/uipath/src/uipath/_cli/cli_push.py b/packages/uipath/src/uipath/_cli/cli_push.py
new file mode 100644
index 000000000..9082d747f
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_push.py
@@ -0,0 +1,287 @@
+import asyncio
+from typing import AsyncIterator
+from urllib.parse import urlparse
+
+import click
+
+from uipath.platform.common import UiPathConfig
+from uipath.platform.errors import EnrichedException
+
+from ._push._resolvers import resolve_bindings
+from ._push._resource_actions import (
+    CreateReference,
+    CreateVirtual,
+    ResourceAction,
+    Skip,
+)
+from ._push._summary import ResourceImportSummary
+from ._push._virtual_kinds import fetch_supported_virtual_kinds
+from ._push.sw_file_handler import SwFileHandler
+from ._telemetry import track_command
+from ._utils._common import ensure_coded_agent_project, may_override_files
+from ._utils._console import ConsoleLogger
+from ._utils._project_files import (
+    Severity,
+    UpdateEvent,
+    ensure_config_file,
+    get_project_config,
+    validate_config,
+    validate_project_files,
+)
+from ._utils._studio_project import (
+    ProjectLockUnavailableError,
+    Status,
+    StudioClient,
+    VirtualResourceRequest,
+)
+from ._utils._uv_helpers import handle_uv_operations
+from .models.runtime_schema import Bindings
+from .models.uipath_json_schema import PackOptions
+
+console = ConsoleLogger()
+
+
+def get_org_scoped_url(base_url: str) -> str:
+    parsed = urlparse(base_url)
+    org_name, *_ = parsed.path.strip("/").split("/")
+
+    org_scoped_url = f"{parsed.scheme}://{parsed.netloc}/{org_name}"
+    return org_scoped_url
+
+
+async def create_resources(studio_client: StudioClient) -> None:
+    console.info("\nImporting referenced resources to Studio Web project...")
+
+    from uipath.platform import UiPath
+
+    uipath = UiPath()
+
+    with open(UiPathConfig.bindings_file_path, "r") as f:
+        bindings = Bindings.model_validate_json(f.read())
+
+    supported_virtual_kinds = await fetch_supported_virtual_kinds(studio_client)
+
+    summary = ResourceImportSummary()
+    async for action in resolve_bindings(
+        bindings,
+        uipath.resource_catalog,
+        uipath.connections,
+        supported_virtual_kinds,
+    ):
+        await _execute_action(action, studio_client, summary)
+
+    console.info(str(summary))
+
+
+async def _execute_action(
+    action: ResourceAction,
+    studio_client: StudioClient,
+    summary: ResourceImportSummary,
+) -> None:
+    match action:
+        case Skip(message=message):
+            console.warning(message)
+            summary.not_found += 1
+
+        case CreateVirtual(request=request):
+            try:
+                result = await studio_client.create_virtual_resource(request)
+            except EnrichedException as e:
+                console.warning(
+                    f"Failed to create virtual resource '{request.name}' of type "
+                    f"'{request.kind}': {e}"
+                )
+                summary.not_found += 1
+                return
+            label = _format_virtual_label(request)
+            match result.status:
+                case Status.ADDED:
+                    console.success(f"{label} created successfully.")
+                    summary.virtual_created += 1
+                case Status.UNCHANGED:
+                    console.info(f"{label} already exists. Skipping...")
+                    summary.virtual_existing += 1
+
+        case CreateReference(
+            request=request,
+            resource_name=resource_name,
+            kind=kind,
+            sub_type=sub_type,
+        ):
+            response = await studio_client.create_referenced_resource(request)
+            details = (
+                f"(kind = {click.style(kind, fg='cyan')}, "
+                f"type = {click.style(sub_type, fg='cyan')})"
+            )
+            match response.status:
+                case Status.ADDED:
+                    console.success(
+                        f"Created reference for resource: "
+                        f"{click.style(resource_name, fg='cyan')} {details}"
+                    )
+                    summary.created += 1
+                case Status.UNCHANGED:
+                    console.info(
+                        f"Resource reference already exists "
+                        f"({click.style('unchanged', fg='yellow')}): "
+                        f"{click.style(resource_name, fg='cyan')} {details}"
+                    )
+                    summary.unchanged += 1
+                case Status.UPDATED:
+                    console.info(
+                        f"Resource reference already exists "
+                        f"({click.style('updated', fg='blue')}): "
+                        f"{click.style(resource_name, fg='cyan')} {details}"
+                    )
+                    summary.updated += 1
+
+
+def _format_virtual_label(request: VirtualResourceRequest) -> str:
+    parts = [
+        f"Resource {click.style(request.name, fg='cyan')}",
+        f" (kind: {click.style(request.kind, fg='yellow')}",
+    ]
+    if request.type:
+        parts.append(f", type: {click.style(request.type, fg='yellow')}")
+    if request.activity_name:
+        parts.append(f", activity: {click.style(request.activity_name, fg='yellow')}")
+    parts.append(")")
+    return "".join(parts)
+
+
+async def upload_source_files_to_project(
+    project_id: str,
+    pack_options: PackOptions | None,
+    directory: str,
+    studio_client: StudioClient | None = None,
+    include_uv_lock: bool = True,
+) -> AsyncIterator[UpdateEvent]:
+    """Upload source files to UiPath project, yielding progress updates.
+
+    This function handles the pushing of local files to the remote project:
+    - Updates existing files that have changed
+    - Uploads new files that don't exist remotely
+    - Deletes remote files that no longer exist locally
+    - Optionally includes the UV lock file
+
+    Args:
+        project_id: The ID of the UiPath project
+        settings: Optional settings dictionary for file handling
+        directory: The local directory to push
+        include_uv_lock: Whether to include the uv.lock file
+
+    Yields:
+        FileOperationUpdate: Progress updates for each file operation
+
+    Raises:
+        ProjectPushError: If the push operation fails
+    """
+    sw_file_handler = SwFileHandler(
+        project_id=project_id,
+        directory=directory,
+        studio_client=studio_client,
+        include_uv_lock=include_uv_lock,
+    )
+
+    async for update in sw_file_handler.upload_source_files(pack_options):
+        yield update
+
+
+@click.command()
+@click.argument(
+    "root",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    default=".",
+    metavar="",
+)
+@click.option(
+    "--ignore-resources",
+    is_flag=True,
+    help="Skip importing the referenced resources to Studio Web solution",
+)
+@click.option(
+    "--nolock",
+    is_flag=True,
+    help="Skip running uv lock and exclude uv.lock from the package",
+)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Automatically overwrite remote files without prompts",
+)
+@track_command("push")
+def push(root: str, ignore_resources: bool, nolock: bool, overwrite: bool) -> None:
+    """Push local project files to Studio Web.
+
+    This command pushes the local project files to a UiPath Studio Web project.
+    It ensures that the remote project structure matches the local files by:
+
+    - Updating existing files that have changed
+    - Uploading new files
+    - Deleting remote files that no longer exist locally
+    - Optionally managing the UV lock file
+
+    **Environment Variables:**
+
+    - `UIPATH_PROJECT_ID`: Required. The ID of the UiPath Cloud project
+
+    **Example:**
+
+        $ uipath push
+        $ uipath push --nolock
+        $ uipath push --overwrite
+        $ uipath push --ignore-resources
+    """
+    ensure_config_file(root)
+    config = get_project_config(root)
+    validate_config(config)
+    validate_project_files(root)
+
+    project_id = UiPathConfig.project_id
+    if not project_id:
+        console.error("UIPATH_PROJECT_ID environment variable not found.")
+
+    studio_client = StudioClient(project_id=project_id)
+
+    asyncio.run(ensure_coded_agent_project(studio_client))
+
+    if not overwrite:
+        may_override = asyncio.run(may_override_files(studio_client, "remote"))
+        if not may_override:
+            console.info("Operation aborted.")
+            return
+
+    async def push_with_updates():
+        """Wrapper to handle async iteration and display updates."""
+        async for update in upload_source_files_to_project(
+            project_id,
+            config.get("packOptions", {}),
+            root,
+            studio_client,
+            include_uv_lock=not nolock,
+        ):
+            match update.severity:
+                case Severity.WARNING:
+                    console.warning(update.message)
+                case _:
+                    console.info(update.message)
+
+        if not ignore_resources:
+            await create_resources(studio_client)
+
+    console.log("Pushing UiPath project to Studio Web...")
+    try:
+        if not nolock:
+            handle_uv_operations(root)
+
+        asyncio.run(push_with_updates())
+
+    except ProjectLockUnavailableError:
+        console.error(
+            "The project is temporarily locked. This could be due to modifications or active processes. Please wait a moment and try again."
+        )
+    except Exception as e:
+        console.error(
+            f"Failed to push UiPath project: {e}",
+            include_traceback=not isinstance(e, EnrichedException),
+        )
diff --git a/packages/uipath/src/uipath/_cli/cli_register.py b/packages/uipath/src/uipath/_cli/cli_register.py
new file mode 100644
index 000000000..49dc0e573
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_register.py
@@ -0,0 +1,51 @@
+import logging
+
+import click
+
+from uipath.eval.evaluators.registration import (
+    EvaluatorRegistrationError,
+    register_evaluator,
+)
+
+from ._telemetry import track_command
+from ._utils._console import ConsoleLogger
+from ._utils._resources import Resources
+
+logger = logging.getLogger(__name__)
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument("resource", required=True)
+@click.argument("args", nargs=-1)
+@track_command("register")
+def register(resource: str, args: tuple[str]) -> None:
+    """Register a local resource.
+
+    Examples:
+        uipath register evaluator my-custom-evaluator.py
+    """
+    match Resources.from_string(resource):
+        case Resources.EVALUATOR:
+            usage_hint = f"Usage: {click.style('uipath register evaluator <evaluator_file_name> (ex. my_custom_evaluator.py)', fg='cyan')}"
+            if len(args) < 1:
+                console.hint(usage_hint)
+                console.error("Missing required argument: evaluator_file_name.")
+                return
+            if len(args) > 1:
+                console.hint(usage_hint)
+                console.error(
+                    f"Too many arguments provided: {args}. Expected only evaluator_file_name (ex. my_custom_evaluator.py)"
+                )
+
+            filename = args[0]
+
+            if not isinstance(filename, str) or not filename.strip():
+                console.hint(usage_hint)
+                console.error("Invalid filename: must be a non-empty string")
+                return
+
+            try:
+                register_evaluator(filename)
+            except EvaluatorRegistrationError as e:
+                console.error(str(e))
diff --git a/packages/uipath/src/uipath/_cli/cli_run.py b/packages/uipath/src/uipath/_cli/cli_run.py
new file mode 100644
index 000000000..48f42018b
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_run.py
@@ -0,0 +1,310 @@
+import asyncio
+
+import click
+from pydantic import ValidationError
+
+from uipath._cli._chat._bridge import get_chat_bridge
+from uipath._cli._debug._bridge import ConsoleDebugBridge
+from uipath._cli._utils._common import read_resource_overwrites_from_file
+from uipath._cli._utils._debug import setup_debugging
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.mocks import SimulationConfig, UiPathMockRuntime, build_mocking_context
+from uipath.platform.common import ResourceOverwritesContext, UiPathConfig
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeFactoryRegistry,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathStreamOptions,
+)
+from uipath.runtime.chat import UiPathChatProtocol, UiPathChatRuntime
+from uipath.runtime.context import UiPathRuntimeContext
+from uipath.runtime.debug import UiPathDebugProtocol
+from uipath.runtime.errors import UiPathRuntimeError
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+from uipath.tracing import (
+    JsonLinesFileExporter,
+    LiveTrackingSpanProcessor,
+    LlmOpsHttpExporter,
+)
+
+from ._errors import EntrypointDiscoveryException
+from ._telemetry import track_command
+from ._utils._console import ConsoleLogger
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+
+
+class _RunDiscoveryError(EntrypointDiscoveryException):
+    """Raised when entrypoint auto-discovery fails."""
+
+    def get_usage_help(self) -> list[str]:
+        lines = super().get_usage_help()
+        lines.append("")
+        lines.append(
+            "Usage: uipath run <entrypoint> <input_arguments>"
+            " [-f <input_json_file_path>]"
+        )
+        if self.entrypoints:
+            lines.append(f"Example: uipath run {self.entrypoints[0]}")
+        return lines
+
+
+@click.command()
+@click.argument("entrypoint", required=False)
+@click.argument("input", required=False, default=None)
+@click.option("--resume", is_flag=True, help="Resume execution from a previous state")
+@click.option(
+    "-f",
+    "--file",
+    required=False,
+    type=click.Path(exists=True),
+    help="File path for the .json input",
+)
+@click.option(
+    "--input-file",
+    required=False,
+    type=click.Path(exists=True),
+    help="Alias for '-f/--file' arguments",
+)
+@click.option(
+    "--output-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the output will be written",
+)
+@click.option(
+    "--trace-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the trace spans will be written (JSON Lines format)",
+)
+@click.option(
+    "--state-file",
+    required=False,
+    type=click.Path(exists=True),
+    help="File path where the state file is stored for persisting execution state. If not provided, a temporary file will be used.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debugging with debugpy. The process will wait for a debugger to attach.",
+)
+@click.option(
+    "--debug-port",
+    type=int,
+    default=5678,
+    help="Port for the debug server (default: 5678)",
+)
+@click.option(
+    "--keep-state-file",
+    is_flag=True,
+    help="Keep the temporary state file even when not resuming and no job id is provided",
+)
+@click.option(
+    "--simulation",
+    required=False,
+    default=None,
+    help="Simulation config as a JSON object (same schema as simulation.json)",
+)
+@track_command("run")
+def run(
+    entrypoint: str | None,
+    input: str | None,
+    resume: bool,
+    file: str | None,
+    input_file: str | None,
+    output_file: str | None,
+    trace_file: str | None,
+    state_file: str | None,
+    debug: bool,
+    debug_port: int,
+    keep_state_file: bool,
+    simulation: str | None,
+) -> None:
+    """Execute the project."""
+    input_file = file or input_file
+
+    # Setup debugging if requested
+    if not setup_debugging(debug, debug_port):
+        console.error(f"Failed to start debug server on port {debug_port}")
+
+    simulation_config: SimulationConfig | None = None
+    if simulation:
+        try:
+            simulation_config = SimulationConfig.model_validate_json(simulation)
+        except (ValidationError, ValueError) as e:
+            console.error(f"Invalid --simulation config: {e}")
+            return
+
+    result = Middlewares.next(
+        "run",
+        entrypoint,
+        input,
+        resume,
+        input_file=input_file,
+        output_file=output_file,
+        trace_file=trace_file,
+        state_file=state_file,
+        debug=debug,
+        debug_port=debug_port,
+        keep_state_file=keep_state_file,
+    )
+
+    if result.error_message:
+        console.error(result.error_message)
+        return
+
+    if result.should_continue:
+        try:
+
+            async def execute_runtime(
+                ctx: UiPathRuntimeContext, runtime: UiPathRuntimeProtocol
+            ) -> UiPathRuntimeResult:
+                options = UiPathExecuteOptions(resume=resume)
+                ctx.result = await runtime.execute(
+                    input=ctx.get_input(), options=options
+                )
+                return ctx.result
+
+            async def debug_runtime(
+                ctx: UiPathRuntimeContext, runtime: UiPathRuntimeProtocol
+            ) -> UiPathRuntimeResult | None:
+                debug_bridge: UiPathDebugProtocol = ConsoleDebugBridge()
+
+                await debug_bridge.emit_execution_started()
+                options = UiPathStreamOptions(resume=resume)
+                async for event in runtime.stream(ctx.get_input(), options=options):
+                    if isinstance(event, UiPathRuntimeResult):
+                        await debug_bridge.emit_execution_completed(event)
+                        ctx.result = event
+                    elif isinstance(event, UiPathRuntimeStateEvent):
+                        if event.phase == UiPathRuntimeStatePhase.UPDATED:
+                            await debug_bridge.emit_state_update(event)
+                return ctx.result
+
+            async def execute() -> None:
+                trace_manager = UiPathTraceManager()
+
+                ctx = UiPathRuntimeContext.with_defaults(
+                    entrypoint=entrypoint,
+                    input=input,
+                    input_file=file or input_file,
+                    output_file=output_file,
+                    trace_file=trace_file,
+                    state_file_path=state_file,
+                    keep_state_file=keep_state_file,
+                    resume=resume,
+                    command="run",
+                    trace_manager=trace_manager,
+                )
+
+                if ctx.trace_file:
+                    trace_manager.add_span_exporter(
+                        JsonLinesFileExporter(ctx.trace_file)
+                    )
+
+                async with ResourceOverwritesContext(
+                    lambda: read_resource_overwrites_from_file(ctx.runtime_dir)
+                ):
+                    with ctx:
+                        base_runtime: UiPathRuntimeProtocol | None = None
+                        runtime: UiPathRuntimeProtocol | None = None
+                        chat_runtime: UiPathRuntimeProtocol | None = None
+                        factory: UiPathRuntimeFactoryProtocol | None = None
+                        try:
+                            factory = UiPathRuntimeFactoryRegistry.get(context=ctx)
+
+                            resolved_entrypoint = entrypoint
+                            if not resolved_entrypoint:
+                                available = factory.discover_entrypoints()
+                                if len(available) == 1:
+                                    resolved_entrypoint = available[0]
+                                else:
+                                    raise _RunDiscoveryError(available)
+
+                            factory_settings = await factory.get_settings()
+                            trace_settings = (
+                                factory_settings.trace_settings
+                                if factory_settings
+                                else None
+                            )
+                            base_runtime = await factory.new_runtime(
+                                resolved_entrypoint,
+                                ctx.conversation_id or ctx.job_id or "default",
+                            )
+                            runtime = base_runtime
+
+                            if simulation_config:
+                                schema = await base_runtime.get_schema()
+                                agent_model = None
+                                if schema.metadata and "settings" in schema.metadata:
+                                    agent_model = schema.metadata["settings"].get(
+                                        "model"
+                                    )
+                                mocking_context = build_mocking_context(
+                                    simulation_config, agent_model
+                                )
+                                if mocking_context:
+                                    runtime = UiPathMockRuntime(
+                                        delegate=base_runtime,
+                                        mocking_context=mocking_context,
+                                    )
+
+                            if ctx.job_id:
+                                if UiPathConfig.is_tracing_enabled:
+                                    trace_manager.add_span_processor(
+                                        LiveTrackingSpanProcessor(
+                                            LlmOpsHttpExporter(),
+                                            settings=trace_settings,
+                                        )
+                                    )
+
+                                if ctx.conversation_id and ctx.exchange_id:
+                                    chat_bridge: UiPathChatProtocol = get_chat_bridge(
+                                        context=ctx
+                                    )
+                                    chat_runtime = UiPathChatRuntime(
+                                        delegate=runtime, chat_bridge=chat_bridge
+                                    )
+
+                                ctx.result = await execute_runtime(
+                                    ctx, chat_runtime or runtime
+                                )
+                            else:
+                                ctx.result = await debug_runtime(ctx, runtime)
+                        finally:
+                            if chat_runtime:
+                                await chat_runtime.dispose()
+                            if runtime is not None and runtime is not base_runtime:
+                                await runtime.dispose()
+                            if base_runtime is not None:
+                                await base_runtime.dispose()
+                            if factory:
+                                await factory.dispose()
+
+            asyncio.run(execute())
+
+        except _RunDiscoveryError as e:
+            click.echo("\n".join(e.get_usage_help()))
+            if not e.entrypoints:
+                click.echo()
+                console.link(
+                    "uipath.json spec:",
+                    "https://github.com/UiPath/uipath-python/blob/main/packages/uipath/specs/uipath.spec.md",
+                )
+            return
+        except UiPathRuntimeError as e:
+            console.error(f"{e.error_info.title} - {e.error_info.detail}")
+        except Exception as e:
+            console.error(
+                f"Error: Unexpected error occurred - {str(e)}", include_traceback=True
+            )
+
+    console.success("Successful execution.")
+
+
+if __name__ == "__main__":
+    run()
diff --git a/packages/uipath/src/uipath/_cli/cli_server.py b/packages/uipath/src/uipath/_cli/cli_server.py
new file mode 100644
index 000000000..c32c6de11
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/cli_server.py
@@ -0,0 +1,406 @@
+import asyncio
+import importlib
+import json
+import os
+import shlex
+import sys
+import tempfile
+import time
+from importlib.metadata import entry_points
+from importlib.util import find_spec
+from typing import Any
+
+import click
+from aiohttp import ClientSession, UnixConnector, web
+
+from ._telemetry import track_command
+from ._utils._console import ConsoleLogger
+from .cli_debug import debug
+from .cli_eval import eval
+from .cli_run import run
+
+console = ConsoleLogger()
+
+SOCKET_ENV_VAR = "UIPATH_SERVER_SOCKET"
+DEFAULT_SOCKET_PATH = "/tmp/uipath-server.sock"
+DEFAULT_PORT = 8765
+
+IS_WINDOWS = sys.platform == "win32"
+
+COMMANDS = {
+    "run": run,
+    "debug": debug,
+    "eval": eval,
+}
+
+
+class _ServerState:
+    """Mutable server state, initialized lazily at server startup."""
+
+    def __init__(self) -> None:
+        self.lock: asyncio.Lock | None = None
+        self.baseline_env: dict[str, str] | None = None
+
+    def init(self) -> None:
+        """Must be called inside a running event loop at server startup."""
+        if self.lock is not None:
+            return
+        self.lock = asyncio.Lock()
+        self.baseline_env = os.environ.copy()
+
+
+_state = _ServerState()
+
+
+DEFAULT_PRELOAD_MODULES = [
+    # Network/async - slowest to load
+    "pysignalr.client",
+    "socketio",
+    "httpx",
+    # Validation/serialization
+    "pydantic",
+    "pydantic_function_models",
+    # CLI/UI
+    "click",
+    "rich",
+]
+
+
+def preload_modules() -> None:
+    """Pre-load modules registered by all uipath packages."""
+    console.info("Pre-loading modules...")
+    start = time.perf_counter()
+
+    modules_to_load: set[str] = set(DEFAULT_PRELOAD_MODULES)
+
+    for ep in entry_points(group="uipath.preload"):
+        try:
+            get_modules = ep.load()
+            modules_to_load.update(get_modules())
+        except Exception as e:
+            console.warning(f"Failed to load entry point {ep.name}: {e}")
+
+    for module_name in modules_to_load:
+        if module_name in sys.modules:
+            continue
+        if find_spec(module_name) is None:
+            continue
+        try:
+            importlib.import_module(module_name)
+            console.success(f"Pre-loaded module: {module_name}")
+        except ImportError as e:
+            console.warning(f"Failed to load {module_name}: {e}")
+
+    elapsed = time.perf_counter() - start
+    console.success(f"Modules pre-loaded in {elapsed:.2f}s")
+
+
+def generate_socket_path() -> str:
+    """Generate a unique socket path for the server to listen on."""
+    return os.path.join(tempfile.gettempdir(), f"uipath-server-{os.getpid()}.sock")
+
+
+def get_field(message: dict[str, Any], *keys: str) -> Any:
+    """Get a field from message, trying multiple key variations."""
+    for key in keys:
+        if key in message:
+            return message[key]
+    return None
+
+
+def parse_args(args: str | list[str] | None) -> list[str]:
+    """Parse args into a list of strings."""
+    if args is None:
+        return []
+    if isinstance(args, list):
+        return args
+    if isinstance(args, str):
+        return shlex.split(args)
+    return []
+
+
+async def send_ack(ack_socket_path: str, server_socket_path: str) -> None:
+    """Send acknowledgment via HTTP POST to the ack socket."""
+    ack_message: dict[str, str] = {
+        "status": "ready",
+        "socket": server_socket_path,
+    }
+
+    conn = UnixConnector(path=ack_socket_path)
+    try:
+        async with ClientSession(connector=conn) as session:
+            async with session.post(
+                "http://localhost/api/python/ack",  # placeholder URL for Unix socket
+                json=ack_message,
+            ) as response:
+                if response.status == 200:
+                    console.success(f"Sent ack to {ack_socket_path}")
+                else:
+                    console.error(f"Ack failed with status {response.status}")
+                    raise RuntimeError(f"Ack failed: {response.status}")
+    except Exception as e:
+        console.error(f"Failed to send ack to {ack_socket_path}: {e}")
+        raise
+
+
+async def handle_health(request: web.Request) -> web.Response:
+    """Handle GET /health endpoint."""
+    return web.Response(text="OK", status=200)
+
+
+async def handle_start(request: web.Request) -> web.Response:
+    """Handle POST /jobs/{job_key}/start endpoint."""
+    job_key = request.match_info.get("job_key")
+    if not job_key:
+        return web.json_response(
+            {"success": False, "error": "Missing job_key"},
+            status=400,
+        )
+
+    try:
+        message: dict[str, Any] = await request.json()
+    except json.JSONDecodeError:
+        return web.json_response(
+            {"success": False, "error": "Invalid JSON"},
+            status=400,
+        )
+
+    command_name = get_field(message, "command", "Command")
+    if not isinstance(command_name, str):
+        return web.json_response(
+            {"success": False, "error": "Missing or invalid field: 'command'"},
+            status=400,
+        )
+
+    args_raw = get_field(message, "args", "Args")
+    args = parse_args(args_raw)
+
+    env_vars = get_field(message, "environmentVariables", "EnvironmentVariables") or {}
+    working_dir = get_field(message, "workingDirectory", "WorkingDirectory")
+
+    console.info(f"Starting job {job_key}: {command_name} {args}")
+
+    cmd = COMMANDS.get(command_name)
+    if cmd is None:
+        return web.json_response(
+            {"success": False, "error": f"Unknown command: {command_name}"},
+            status=400,
+        )
+
+    console.info(f"Original cwd: {os.getcwd()}")
+    console.info(f"Requested working_dir: {working_dir}")
+
+    if _state.lock is None or _state.baseline_env is None:
+        raise RuntimeError("Server state not initialized")
+
+    # Validate environmentVariables type early
+    if env_vars and not isinstance(env_vars, dict):
+        return web.json_response(
+            {
+                "success": False,
+                "error": "Invalid field: 'environmentVariables' must be a dict",
+            },
+            status=400,
+        )
+
+    # Serialize command execution to prevent concurrent os.environ mutation
+    async with _state.lock:
+        original_cwd = os.getcwd()
+
+        try:
+            # Start from server baseline + request env vars only.
+            # This ensures no env vars from previous requests leak through.
+            os.environ.clear()
+            os.environ.update(_state.baseline_env)
+            if isinstance(env_vars, dict):
+                os.environ.update(env_vars)
+
+            if working_dir and isinstance(working_dir, str):
+                try:
+                    os.chdir(working_dir)
+                except (FileNotFoundError, NotADirectoryError, PermissionError) as e:
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "job_key": job_key,
+                            "error": f"Cannot change to working directory: {e}",
+                        },
+                        status=400,
+                    )
+
+            result = await asyncio.to_thread(cmd.main, args, standalone_mode=False)
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "job_key": job_key,
+                    "result": result,
+                }
+            )
+        except SystemExit as e:
+            exit_code = e.code if isinstance(e.code, int) else 1
+            return web.json_response(
+                {
+                    "success": exit_code == 0,
+                    "job_key": job_key,
+                    "error": None if exit_code == 0 else f"Exit code: {exit_code}",
+                }
+            )
+        except Exception as e:
+            return web.json_response(
+                {"success": False, "job_key": job_key, "error": str(e)},
+                status=500,
+            )
+        finally:
+            # Restore to server baseline
+            try:
+                os.chdir(original_cwd)
+            except OSError:
+                pass
+            os.environ.clear()
+            os.environ.update(_state.baseline_env)
+
+
+ALLOWED_HOSTS = {"127.0.0.1", "localhost", "[::1]"}
+
+
+@web.middleware
+async def host_validation_middleware(
+    request: web.Request, handler: Any
+) -> web.StreamResponse:
+    """Validate the Host header to prevent DNS rebinding attacks."""
+    host = request.host
+    if host:
+        host = host.lower()
+        # Strip port from bracketed IPv6 (e.g. "[::1]:8765" -> "[::1]")
+        if host.startswith("["):
+            bracket_end = host.find("]")
+            if bracket_end != -1:
+                host = host[: bracket_end + 1]
+        # Strip port from IPv4/hostname (e.g. "localhost:8765" -> "localhost")
+        elif ":" in host:
+            host = host.rsplit(":", 1)[0]
+        # Strip trailing dot (e.g. "localhost." -> "localhost")
+        host = host.rstrip(".")
+    if host not in ALLOWED_HOSTS:
+        return web.json_response(
+            {"error": "Forbidden: invalid Host header"},
+            status=403,
+        )
+    return await handler(request)
+
+
+def create_app() -> web.Application:
+    """Create the aiohttp application."""
+    app = web.Application(middlewares=[host_validation_middleware])
+    app.router.add_get("/health", handle_health)
+    app.router.add_post("/jobs/{job_key}/start", handle_start)
+    return app
+
+
+async def start_unix_server(
+    ack_socket_path: str, server_socket_path: str | None = None
+) -> None:
+    """Start Unix domain socket HTTP server."""
+    _state.init()
+
+    server_socket_path = server_socket_path or generate_socket_path()
+
+    if os.path.exists(server_socket_path):
+        os.unlink(server_socket_path)
+
+    app = create_app()
+    runner = web.AppRunner(app)
+    await runner.setup()
+
+    try:
+        site = web.UnixSite(runner, server_socket_path)
+        await site.start()
+
+        console.success(f"Server listening on unix://{server_socket_path}")
+
+        await send_ack(ack_socket_path, server_socket_path)
+
+        while True:
+            await asyncio.sleep(3600)
+    finally:
+        await runner.cleanup()
+        if os.path.exists(server_socket_path):
+            os.unlink(server_socket_path)
+
+
+async def start_tcp_server(host: str, port: int) -> None:
+    """Start TCP HTTP server (Windows fallback)."""
+    _state.init()
+
+    app = create_app()
+    runner = web.AppRunner(app)
+    await runner.setup()
+
+    try:
+        site = web.TCPSite(runner, host, port)
+        await site.start()
+
+        console.success(f"Server listening on http://{host}:{port}")
+
+        while True:
+            await asyncio.sleep(3600)
+    finally:
+        await runner.cleanup()
+
+
+@click.command()
+@click.option(
+    "--client-socket",
+    type=str,
+    default=None,
+    help=f"Unix socket path to send ready ack to (default: ${SOCKET_ENV_VAR} or {DEFAULT_SOCKET_PATH})",
+)
+@click.option(
+    "--server-socket",
+    type=str,
+    default=None,
+    help="Unix socket path the server listens on (default: auto-generated in tmp dir)",
+)
+@click.option(
+    "--port",
+    type=int,
+    default=None,
+    help=f"TCP port, used on Windows or when --tcp flag is set (default: {DEFAULT_PORT})",
+)
+@click.option(
+    "--tcp",
+    is_flag=True,
+    help="Force TCP mode even on Unix systems",
+)
+@track_command("server")
+def server(
+    client_socket: str | None,
+    server_socket: str | None,
+    port: int | None,
+    tcp: bool,
+) -> None:
+    """Start an HTTP server that forwards commands to run/debug/eval.
+
+    Creates its own socket to listen on and sends an ack to --client-socket with:
+    {"status": "ready", "socket": "/path/to/server.sock"}
+
+    Endpoint: POST /jobs/{job_key}/start
+    Body: {"command": "run", "args": "agent.json '{}'", "environmentVariables": {}, "workingDirectory": "/path"}
+
+    Endpoint: GET /health
+    """
+    use_tcp = IS_WINDOWS or tcp
+
+    preload_modules()
+
+    try:
+        if use_tcp:
+            asyncio.run(start_tcp_server("127.0.0.1", port or DEFAULT_PORT))
+        else:
+            ack_socket_path = (
+                client_socket or os.environ.get(SOCKET_ENV_VAR) or DEFAULT_SOCKET_PATH
+            )
+            asyncio.run(start_unix_server(ack_socket_path, server_socket))
+    except KeyboardInterrupt:
+        console.info("Shutting down")
diff --git a/src/uipath/_cli/middlewares.py b/packages/uipath/src/uipath/_cli/middlewares.py
similarity index 85%
rename from src/uipath/_cli/middlewares.py
rename to packages/uipath/src/uipath/_cli/middlewares.py
index cfc153fff..9b291c266 100644
--- a/src/uipath/_cli/middlewares.py
+++ b/packages/uipath/src/uipath/_cli/middlewares.py
@@ -2,7 +2,7 @@
 import inspect
 import logging
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable
 
 from ._utils._console import ConsoleLogger
 
@@ -13,8 +13,8 @@
 @dataclass
 class MiddlewareResult:
     should_continue: bool
-    info_message: Optional[str] = None
-    error_message: Optional[str] = None
+    info_message: str | None = None
+    error_message: str | None = None
     should_include_stacktrace: bool = False
 
 
@@ -22,12 +22,16 @@ class MiddlewareResult:
 
 
 class Middlewares:
-    _middlewares: Dict[str, List[MiddlewareFunc]] = {
+    _middlewares: dict[str, list[MiddlewareFunc]] = {
         "new": [],
         "init": [],
         "pack": [],
         "publish": [],
         "run": [],
+        "dev": [],
+        "invoke": [],
+        "eval": [],
+        "debug": [],
     }
     _plugins_loaded = False
 
@@ -42,7 +46,7 @@ def register(cls, command: str, middleware: MiddlewareFunc) -> None:
         )
 
     @classmethod
-    def get(cls, command: str) -> List[MiddlewareFunc]:
+    def get(cls, command: str) -> list[MiddlewareFunc]:
         """Get all middlewares for a specific command."""
         return cls._middlewares.get(command, [])
 
@@ -89,7 +93,7 @@ def next(cls, command: str, *args: Any, **kwargs: Any) -> MiddlewareResult:
         return MiddlewareResult(should_continue=True)
 
     @classmethod
-    def clear(cls, command: Optional[str] = None) -> None:
+    def clear(cls, command: str | None = None) -> None:
         """Clear middlewares for a specific command or all middlewares if command is None."""
         if command:
             if command in cls._middlewares:
@@ -112,26 +116,26 @@ def load_plugins(cls) -> None:
                 else:
                     middlewares = list(entry_points.get("uipath.middlewares", []))
             except Exception:
-                middlewares = list(importlib.metadata.entry_points())  # type: ignore
+                middlewares = list(importlib.metadata.entry_points())  # type: ignore # explicit ignore
                 middlewares = [
                     ep for ep in middlewares if ep.group == "uipath.middlewares"
                 ]
 
             if middlewares:
-                logger.info(f"Found {len(middlewares)} middleware plugins")
+                logger.debug(f"Found {len(middlewares)} middleware plugins")
 
                 for entry_point in middlewares:
                     try:
                         register_func = entry_point.load()
                         register_func()
-                        logger.info(f"Loaded middleware plugin: {entry_point.name}")
+                        logger.debug(f"Loaded middleware plugin: {entry_point.name}")
                     except Exception as e:
-                        logger.error(
+                        console.error(
                             f"Failed to load middleware plugin {entry_point.name}: {str(e)}",
-                            exc_info=True,
+                            include_traceback=True,
                         )
             else:
-                logger.info("No middleware plugins found")
+                logger.debug("No middleware plugins found")
 
         except Exception as e:
             logger.error(f"No middleware plugins loaded: {str(e)}")
diff --git a/packages/uipath/src/uipath/_cli/models/__init__.py b/packages/uipath/src/uipath/_cli/models/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/src/uipath/_cli/models/runtime_schema.py b/packages/uipath/src/uipath/_cli/models/runtime_schema.py
new file mode 100644
index 000000000..a32660abf
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/models/runtime_schema.py
@@ -0,0 +1,62 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BaseModelWithDefaultConfig(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        populate_by_name=True,
+        extra="allow",
+    )
+
+
+class BindingResourceValue(BaseModelWithDefaultConfig):
+    default_value: str = Field(..., alias="defaultValue")
+    is_expression: bool = Field(..., alias="isExpression")
+    display_name: str = Field(..., alias="displayName")
+
+
+# TODO: create stronger binding resource definition with discriminator based on resource enum.
+class BindingResource(BaseModelWithDefaultConfig):
+    resource: str = Field(..., alias="resource")
+    key: str = Field(..., alias="key")
+    value: dict[str, BindingResourceValue] = Field(..., alias="value")
+    metadata: dict[str, Any] | None = Field(alias="metadata", default=None)
+
+
+class Bindings(BaseModelWithDefaultConfig):
+    version: str = Field(..., alias="version")
+    resources: list[BindingResource] = Field(..., alias="resources")
+
+
+class EntryPoint(BaseModelWithDefaultConfig):
+    file_path: str = Field(..., alias="filePath")
+    unique_id: str = Field(..., alias="uniqueId")
+    type: str = Field(..., alias="type")
+    input: dict[str, Any] = Field(..., alias="input")
+    output: dict[str, Any] = Field(..., alias="output")
+    graph: dict[str, Any] | None = Field(default=None, alias="graph")
+    metadata: dict[str, Any] | None = Field(default=None, alias="metadata")
+
+
+class EntryPoints(BaseModelWithDefaultConfig):
+    schema_: str = Field(
+        default="https://cloud.uipath.com/draft/2024-12/entry-point",
+        alias="$schema",
+    )
+    id_: str = Field(default="entry-points.json", alias="$id")
+    entrypoints: list[EntryPoint] = Field(..., alias="entryPoints")
+
+
+class RuntimeInternalArguments(BaseModelWithDefaultConfig):
+    resource_overwrites: dict[str, Any] = Field(..., alias="resourceOverwrites")
+
+
+class RuntimeArguments(BaseModelWithDefaultConfig):
+    internal_arguments: Optional[RuntimeInternalArguments] = Field(
+        default=None, alias="internalArguments"
+    )
diff --git a/packages/uipath/src/uipath/_cli/models/uipath_json_schema.py b/packages/uipath/src/uipath/_cli/models/uipath_json_schema.py
new file mode 100644
index 000000000..4dd2f6700
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/models/uipath_json_schema.py
@@ -0,0 +1,146 @@
+"""Pydantic models for uipath.json configuration file."""
+
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BaseModelWithDefaultConfig(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        populate_by_name=True,
+        extra="allow",
+    )
+
+
+class RuntimeOptions(BaseModelWithDefaultConfig):
+    """Runtime behavior configuration."""
+
+    is_conversational: bool = Field(
+        default=False,
+        alias="isConversational",
+        description="Enable conversational mode for the runtime",
+    )
+
+
+class DesignOptions(BaseModelWithDefaultConfig):
+    """Design-time configuration and preferences."""
+
+
+class PackOptions(BaseModelWithDefaultConfig):
+    """File inclusion and exclusion settings for packaging."""
+
+    file_extensions_included: list[str] = Field(
+        default_factory=list,
+        alias="fileExtensionsIncluded",
+        description="File extensions to include in the package",
+    )
+    files_included: list[str] = Field(
+        default_factory=list,
+        alias="filesIncluded",
+        description="Specific files to include in the package",
+    )
+    files_excluded: list[str] = Field(
+        default_factory=list,
+        alias="filesExcluded",
+        description="Specific files to exclude from the package",
+    )
+    directories_excluded: list[str] = Field(
+        default_factory=list,
+        alias="directoriesExcluded",
+        description="Directories to exclude from the package",
+    )
+    include_uv_lock: bool = Field(
+        default=True,
+        alias="includeUvLock",
+        description="Whether to include uv.lock file in the package",
+    )
+
+
+class UiPathJsonConfig(BaseModelWithDefaultConfig):
+    """Configuration file for UiPath projects."""
+
+    schema_: str = Field(
+        default="https://cloud.uipath.com/draft/2024-12/uipath",
+        alias="$schema",
+        description="Reference to the JSON schema for editor support",
+    )
+    id: str | None = Field(
+        default=None,
+        description="Stable unique identifier for the agent. Minted once at "
+        "project creation (by 'uipath init' or Studio Web) and preserved for the "
+        "lifetime of the project. Used as the package 'projectId' at pack time.",
+    )
+    runtime_options: RuntimeOptions = Field(
+        default_factory=RuntimeOptions,
+        alias="runtimeOptions",
+        description="Runtime behavior configuration",
+    )
+    design_options: DesignOptions | None = Field(
+        default=None,
+        alias="designOptions",
+        description="Design-time configuration and preferences",
+    )
+    pack_options: PackOptions = Field(
+        default_factory=PackOptions,
+        alias="packOptions",
+        description="File inclusion and exclusion settings for packaging",
+    )
+    functions: dict[str, str] = Field(
+        default_factory=dict,
+        description="Entrypoint definitions for pure Python scripts. "
+        "Each key is an entrypoint name, and each value is a path in format 'file_path:function_name'",
+    )
+
+    agents: dict[str, str] = Field(
+        default_factory=dict,
+        description="Entrypoint definitions for agent scripts. "
+        "Each key is an entrypoint name, and each value is a path in format 'file_path:agent_name'",
+    )
+
+    def to_json_string(self, indent: int = 2) -> str:
+        """Export to JSON string with proper formatting."""
+        return self.model_dump_json(
+            by_alias=True,
+            exclude_none=True,
+            indent=indent,
+        )
+
+    @classmethod
+    def create_default(cls) -> "UiPathJsonConfig":
+        """Create a default configuration instance."""
+        return cls(
+            runtime_options=RuntimeOptions(is_conversational=False),
+            pack_options=PackOptions(
+                file_extensions_included=[],
+                files_included=[],
+                files_excluded=[],
+                directories_excluded=[],
+                include_uv_lock=True,
+            ),
+            functions={},
+            agents={},
+        )
+
+    @classmethod
+    def load_from_file(cls, file_path: str = "uipath.json") -> "UiPathJsonConfig":
+        """Load configuration from a JSON file."""
+        import json
+        from pathlib import Path
+
+        path = Path(file_path)
+        if not path.exists():
+            return cls.create_default()
+
+        with open(path) as f:
+            data = json.load(f)
+
+        return cls.model_validate(data)
+
+    def save_to_file(self, file_path: Path) -> None:
+        """Save configuration to a JSON file."""
+        with open(file_path, "w") as f:
+            f.write(self.to_json_string())
diff --git a/packages/uipath/src/uipath/_cli/runtimes.py b/packages/uipath/src/uipath/_cli/runtimes.py
new file mode 100644
index 000000000..613e278a6
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/runtimes.py
@@ -0,0 +1,11 @@
+from importlib.metadata import entry_points
+
+
+def load_runtime_factories():
+    """Auto-discover and register all factory plugins."""
+    for ep in entry_points(group="uipath.runtime.factories"):
+        try:
+            register_func = ep.load()
+            register_func()
+        except Exception as e:
+            print(f"Failed to load factory {ep.name}: {e}")
diff --git a/packages/uipath/src/uipath/_cli/services/__init__.py b/packages/uipath/src/uipath/_cli/services/__init__.py
new file mode 100644
index 000000000..71fc2114f
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/services/__init__.py
@@ -0,0 +1,40 @@
+"""Service command groups for UiPath CLI.
+
+All services are explicitly imported to ensure:
+- File renames break loudly (import error) not silently
+- Clear dependency graph
+- Fast startup (no auto-discovery overhead)
+- Debuggable registration
+"""
+
+from .cli_assets import assets
+from .cli_buckets import buckets
+from .cli_context_grounding import context_grounding
+
+__all__ = ["assets", "buckets", "context_grounding", "register_service_commands"]
+
+
+def register_service_commands(cli_group):
+    """Register all service command groups with the root CLI.
+
+    This function maintains explicitness while reducing registration boilerplate.
+    Benefits:
+    - File renames break loudly (import error) not silently
+    - Clear list of all registered services
+    - Easy to comment out services during development
+
+    Args:
+        cli_group: The root Click group to register services with
+
+    Returns:
+        The cli_group for method chaining
+
+    Industry Precedent:
+        AWS CLI, Azure CLI, and gcloud all use explicit registration.
+    """
+    services = [assets, buckets, context_grounding]
+
+    for service in services:
+        cli_group.add_command(service)
+
+    return cli_group
diff --git a/packages/uipath/src/uipath/_cli/services/_buckets_metadata.py b/packages/uipath/src/uipath/_cli/services/_buckets_metadata.py
new file mode 100644
index 000000000..d5ddab68a
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/services/_buckets_metadata.py
@@ -0,0 +1,53 @@
+"""Metadata configuration for Buckets service CLI.
+
+This module defines the ServiceMetadata for the buckets service, which is used
+by ServiceCLIGenerator to auto-generate standard CRUD commands.
+
+The buckets service was the first service migrated to the Service CLI Generator
+architecture and serves as the reference implementation for future migrations.
+"""
+
+from uipath._cli._utils._service_metadata import (
+    CreateParameter,
+    DeleteCommandConfig,
+    ExistsCommandConfig,
+    ServiceMetadata,
+)
+from uipath._cli._utils._service_protocol import validate_service_protocol
+
+__all__ = ["BUCKETS_METADATA"]
+
+
+BUCKETS_METADATA = ServiceMetadata(
+    service_name="buckets",
+    service_attr="buckets",
+    resource_type="Bucket",
+    resource_plural="Buckets",
+    create_params={
+        "description": CreateParameter(
+            type="str",
+            required=False,
+            help="Bucket description",
+            default=None,
+        ),
+    },
+    delete_cmd=DeleteCommandConfig(
+        confirmation_required=True,
+        dry_run_supported=True,
+        confirmation_prompt=None,
+    ),
+    exists_cmd=ExistsCommandConfig(
+        identifier_arg_name="name",
+        return_format="dict",
+    ),
+)
+
+BUCKETS_METADATA.validate_types()
+
+try:
+    from uipath.platform import UiPath
+
+    sdk = UiPath()
+    validate_service_protocol(sdk.buckets, "buckets")
+except Exception:
+    pass
diff --git a/packages/uipath/src/uipath/_cli/services/cli_assets.py b/packages/uipath/src/uipath/_cli/services/cli_assets.py
new file mode 100644
index 000000000..dfd071bab
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/services/cli_assets.py
@@ -0,0 +1,87 @@
+"""Assets service commands for UiPath CLI.
+
+Assets are key-value pairs stored in Orchestrator that can be used to store
+configuration data, credentials, and other settings used by automation processes.
+"""
+
+import click
+
+from .._utils._service_base import (
+    ServiceCommandBase,
+    common_service_options,
+    service_command,
+)
+
+
+@click.group()
+def assets():
+    r"""Manage UiPath assets.
+
+    Assets are key-value pairs that store configuration data, credentials,
+    and settings used by automation processes.
+
+    \b
+    Examples:
+        # List all assets in a folder
+        uipath assets list --folder-path "Shared"
+
+        # List with filter
+        uipath assets list --filter "ValueType eq 'Text'"
+
+        # List with ordering
+        uipath assets list --orderby "Name asc"
+    """
+    pass
+
+
+@assets.command(name="list")
+@click.option("--filter", "filter_", help="OData $filter expression")
+@click.option("--orderby", help="OData $orderby expression")
+@click.option(
+    "--top",
+    type=click.IntRange(min=1, max=1000),
+    default=100,
+    help="Maximum number of items to return (default: 100, max: 1000)",
+)
+@click.option(
+    "--skip",
+    type=click.IntRange(min=0),
+    default=0,
+    help="Number of items to skip",
+)
+@common_service_options
+@service_command
+def list_assets(
+    ctx,
+    filter_,
+    orderby,
+    top,
+    skip,
+    folder_path,
+    folder_key,
+    format,
+    output,
+):
+    r"""List assets in a folder.
+
+    \b
+    Examples:
+        uipath assets list
+        uipath assets list --folder-path "Shared"
+        uipath assets list --filter "ValueType eq 'Text'"
+        uipath assets list --filter "Name eq 'MyAsset'"
+        uipath assets list --orderby "Name asc"
+        uipath assets list --top 50 --skip 100
+    """
+    client = ServiceCommandBase.get_client(ctx)
+
+    result = client.assets.list(
+        folder_path=folder_path,
+        folder_key=folder_key,
+        filter=filter_,
+        orderby=orderby,
+        top=top,
+        skip=skip,
+    )
+
+    return list(result.items)
diff --git a/packages/uipath/src/uipath/_cli/services/cli_buckets.py b/packages/uipath/src/uipath/_cli/services/cli_buckets.py
new file mode 100644
index 000000000..9e5c6274d
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/services/cli_buckets.py
@@ -0,0 +1,526 @@
+"""Buckets service commands for UiPath CLI.
+
+Buckets are cloud storage containers for files used by automation processes.
+Similar to AWS S3 or Azure Blob Storage.
+
+This module uses the Service CLI Generator to auto-generate standard CRUD commands
+for bucket management, with custom implementations for file operations.
+
+Architecture:
+    - Auto-generated commands: list, create, delete, exists (via ServiceCLIGenerator)
+    - Overridden command: retrieve (custom --name/--key dual-option support)
+    - Manual nested group: files (with 6 custom file operation commands)
+"""
+# ruff: noqa: D301 - Using regular """ strings (not r""") for Click \b formatting
+
+from itertools import islice
+
+import click
+
+from .._utils._service_base import (
+    ServiceCommandBase,
+    common_service_options,
+    handle_not_found_error,
+    service_command,
+)
+from .._utils._service_cli_generator import ServiceCLIGenerator
+from ._buckets_metadata import BUCKETS_METADATA
+
+_cli = click.Group()
+generator = ServiceCLIGenerator(BUCKETS_METADATA)
+buckets = generator.register(_cli)
+buckets.help = """Manage UiPath storage buckets and files.
+
+Buckets are cloud storage containers for files used by automation processes.
+
+\b
+Bucket Operations:
+    list      - List all buckets
+    create    - Create a new bucket
+    delete    - Delete a bucket
+    retrieve  - Get bucket details
+    exists    - Check if bucket exists
+
+\b
+File Operations (use 'buckets files' subcommand):
+    files list     - List files in a bucket
+    files search   - Search files using glob patterns
+    files upload   - Upload a file to a bucket
+    files download - Download a file from a bucket
+    files delete   - Delete a file from a bucket
+    files exists   - Check if a file exists
+
+\b
+Examples:
+    \b
+    # Bucket operations with explicit folder
+    uipath buckets list --folder-path "Shared"
+    uipath buckets create my-bucket --description "Data storage"
+    uipath buckets exists my-bucket
+    uipath buckets delete my-bucket --confirm
+    \b
+    # Using environment variable for folder context
+    export UIPATH_FOLDER_PATH="Shared"
+    uipath buckets list
+    uipath buckets create my-bucket --description "Data storage"
+    \b
+    # File operations
+    uipath buckets files list my-bucket
+    uipath buckets files search my-bucket "*.pdf"
+    uipath buckets files upload my-bucket ./data.csv remote/data.csv
+    uipath buckets files download my-bucket data.csv ./local.csv
+    uipath buckets files delete my-bucket old-data.csv --confirm
+    uipath buckets files exists my-bucket data.csv
+"""
+
+
+@click.command()
+@click.option("--name", help="Bucket name")
+@click.option("--key", help="Bucket key (UUID)")
+@common_service_options
+@service_command
+def retrieve(ctx, name, key, folder_path, folder_key, format, output):
+    """Retrieve a bucket by name or key.
+
+    \b
+    Examples:
+        uipath buckets retrieve --name "my-bucket"
+        uipath buckets retrieve --key "abc-123-def-456" --format json
+    """
+    from httpx import HTTPStatusError
+
+    if not name and not key:
+        raise click.UsageError("Either --name or --key must be provided")
+
+    if name and key:
+        raise click.UsageError("Provide either --name or --key, not both")
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    try:
+        bucket = client.buckets.retrieve(
+            name=name,
+            key=key,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+    except LookupError:
+        handle_not_found_error("Bucket", name or key)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Bucket", name or key, e)
+        raise
+
+    return bucket
+
+
+generator.override_command(buckets, "retrieve", retrieve)
+
+
+@click.command()
+@click.argument("name")
+@click.option("--confirm", is_flag=True, help="Skip confirmation prompt")
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be deleted without deleting"
+)
+@common_service_options
+@service_command
+def delete(ctx, name, confirm, dry_run, folder_path, folder_key, format, output):
+    """Delete a bucket.
+
+    \b
+    Examples:
+        uipath buckets delete my-bucket --confirm
+        uipath buckets delete my-bucket --dry-run
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    # First retrieve to verify bucket exists
+    try:
+        client.buckets.retrieve(
+            name=name,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+    except LookupError:
+        handle_not_found_error("Bucket", name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Bucket", name, e)
+        raise
+
+    # Handle dry-run
+    if dry_run:
+        click.echo(f"Would delete bucket '{name}'", err=True)
+        return
+
+    # Handle confirmation
+    if not confirm:
+        if not click.confirm(f"Delete bucket '{name}'?"):
+            click.echo("Deletion cancelled.")
+            return
+
+    # Perform delete
+    client.buckets.delete(
+        name=name,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Deleted bucket '{name}'", err=True)
+
+
+generator.override_command(buckets, "delete", delete)
+
+
+@click.group()
+def files():
+    """Manage files within buckets.
+
+    \b
+    Examples:
+        \b
+        # List files in a bucket
+        uipath buckets files list my-bucket
+        \b
+        # Search for files with glob pattern
+        uipath buckets files search my-bucket "*.pdf"
+        \b
+        # Upload a file
+        uipath buckets files upload my-bucket ./data.csv remote/data.csv
+        \b
+        # Download a file
+        uipath buckets files download my-bucket data.csv ./local.csv
+        \b
+        # Delete a file
+        uipath buckets files delete my-bucket old-data.csv --confirm
+        \b
+        # Check if file exists
+        uipath buckets files exists my-bucket data.csv
+    """
+    pass
+
+
+@files.command(name="list")
+@click.argument("bucket_name")
+@click.option("--prefix", default="", help="Filter files by prefix")
+@click.option(
+    "--limit",
+    type=click.IntRange(min=0),
+    help="Maximum number of files to return",
+)
+@click.option(
+    "--offset",
+    type=click.IntRange(min=0),
+    default=0,
+    help="Number of files to skip",
+)
+@click.option(
+    "--all", "fetch_all", is_flag=True, help="Fetch all files (auto-paginate)"
+)
+@common_service_options
+@service_command
+def list_files(
+    ctx,
+    bucket_name,
+    prefix,
+    limit,
+    offset,
+    fetch_all,
+    folder_path,
+    folder_key,
+    format,
+    output,
+):
+    """List files in a bucket.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+
+    \b
+    Examples:
+        uipath buckets files list my-bucket
+        uipath buckets files list my-bucket --prefix "data/"
+        uipath buckets files list reports --limit 10 --format json
+        uipath buckets files list my-bucket --all
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    try:
+        files_iterator = client.buckets.list_files(
+            name=bucket_name,
+            prefix=prefix,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        if not fetch_all and limit == 0:
+            return []
+
+        start = offset
+        stop = None if fetch_all or limit is None else start + limit
+        return list(islice(files_iterator, start, stop))
+    except LookupError:
+        handle_not_found_error("Bucket", bucket_name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Bucket", bucket_name, e)
+        raise
+
+
+@files.command(name="search")
+@click.argument("bucket_name")
+@click.argument("pattern")
+@click.option("--prefix", default="", help="Directory path to search in")
+@click.option(
+    "--recursive/--no-recursive",
+    default=False,
+    help="Search subdirectories recursively",
+)
+@click.option(
+    "--limit",
+    type=click.IntRange(min=0),
+    help="Maximum number of files to return",
+)
+@common_service_options
+@service_command
+def search_files(
+    ctx,
+    bucket_name,
+    pattern,
+    prefix,
+    recursive,
+    limit,
+    folder_path,
+    folder_key,
+    format,
+    output,
+):
+    """Search for files using glob patterns.
+
+    Uses the GetFiles API which supports glob patterns like *.pdf or data_*.csv.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        PATTERN: Glob pattern to match files (e.g., "*.pdf", "data_*.csv")
+
+    \b
+    Examples:
+        uipath buckets files search my-bucket "*.pdf"
+        uipath buckets files search reports "*.csv" --recursive
+        uipath buckets files search my-bucket "data_*.json" --prefix "archive/"
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    try:
+        files_iterator = client.buckets.get_files(
+            name=bucket_name,
+            prefix=prefix,
+            recursive=recursive,
+            file_name_glob=pattern,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        files = (
+            list(files_iterator)
+            if limit is None
+            else list(islice(files_iterator, limit))
+        )
+        return files
+    except LookupError:
+        handle_not_found_error("Bucket", bucket_name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Bucket", bucket_name, e)
+        raise
+
+
+@files.command(name="upload")
+@click.argument("bucket_name")
+@click.argument("local_path", type=click.Path(exists=True))
+@click.argument("remote_path")
+@common_service_options
+@service_command
+def upload_file(
+    ctx, bucket_name, local_path, remote_path, folder_path, folder_key, format, output
+):
+    """Upload a file to a bucket.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        LOCAL_PATH: Local file to upload
+        REMOTE_PATH: Destination path in bucket
+
+    \b
+    Examples:
+        uipath buckets files upload my-bucket ./data.csv remote/data.csv
+        uipath buckets files upload reports ./report.pdf monthly/report.pdf
+    """
+    client = ServiceCommandBase.get_client(ctx)
+
+    click.echo(f"Uploading {local_path}...", err=True)
+    client.buckets.upload(
+        name=bucket_name,
+        source_path=local_path,
+        blob_file_path=remote_path,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Uploaded to {remote_path}", err=True)
+
+
+@files.command(name="download")
+@click.argument("bucket_name")
+@click.argument("remote_path")
+@click.argument("local_path", type=click.Path())
+@common_service_options
+@service_command
+def download_file(
+    ctx, bucket_name, remote_path, local_path, folder_path, folder_key, format, output
+):
+    """Download a file from a bucket.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        REMOTE_PATH: Path to file in bucket
+        LOCAL_PATH: Local destination path
+
+    \b
+    Examples:
+        uipath buckets files download my-bucket data.csv ./downloads/data.csv
+        uipath buckets files download reports monthly/report.pdf ./report.pdf
+    """
+    client = ServiceCommandBase.get_client(ctx)
+
+    click.echo(f"Downloading {remote_path}...", err=True)
+    client.buckets.download(
+        name=bucket_name,
+        blob_file_path=remote_path,
+        destination_path=local_path,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Downloaded to {local_path}", err=True)
+
+
+@files.command(name="delete")
+@click.argument("bucket_name")
+@click.argument("file_path")
+@click.option("--confirm", is_flag=True, help="Skip confirmation prompt")
+@click.option("--dry-run", is_flag=True, help="Show what would be deleted")
+@common_service_options
+@service_command
+def delete_file(
+    ctx,
+    bucket_name,
+    file_path,
+    confirm,
+    dry_run,
+    folder_path,
+    folder_key,
+    format,
+    output,
+):
+    """Delete a file from a bucket.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        FILE_PATH: Path to file in bucket
+
+    \b
+    Examples:
+        uipath buckets files delete my-bucket old-data.csv --confirm
+        uipath buckets files delete reports archive/old.pdf --dry-run
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    if dry_run:
+        click.echo(
+            f"Would delete file: {file_path} from bucket {bucket_name}", err=True
+        )
+        return
+
+    if not confirm:
+        if not click.confirm(f"Delete file '{file_path}' from bucket '{bucket_name}'?"):
+            click.echo("Aborted", err=True)
+            return
+
+    try:
+        client.buckets.delete_file(
+            name=bucket_name,
+            blob_file_path=file_path,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+        click.echo(f"Deleted file '{file_path}' from bucket '{bucket_name}'", err=True)
+    except LookupError:
+        handle_not_found_error("Bucket", bucket_name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("File or Bucket", f"{bucket_name}/{file_path}", e)
+        raise
+
+
+@files.command(name="exists")
+@click.argument("bucket_name")
+@click.argument("file_path")
+@common_service_options
+@service_command
+def file_exists(ctx, bucket_name, file_path, folder_path, folder_key, format, output):
+    """Check if a file exists in a bucket.
+
+    \b
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        FILE_PATH: Path to file in bucket
+
+    \b
+    Examples:
+        uipath buckets files exists my-bucket data.csv
+        uipath buckets files exists reports monthly/report.pdf
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    try:
+        file_exists_result = client.buckets.exists_file(
+            name=bucket_name,
+            blob_file_path=file_path,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        if file_exists_result:
+            click.echo(f"File '{file_path}' exists in bucket '{bucket_name}'", err=True)
+            return {"exists": True, "bucket": bucket_name, "file": file_path}
+        else:
+            click.echo(
+                f"File '{file_path}' does not exist in bucket '{bucket_name}'", err=True
+            )
+            return {"exists": False, "bucket": bucket_name, "file": file_path}
+    except LookupError:
+        handle_not_found_error("Bucket", bucket_name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Bucket", bucket_name, e)
+        raise
+
+
+generator.add_nested_group(buckets, "files", files)
diff --git a/packages/uipath/src/uipath/_cli/services/cli_context_grounding.py b/packages/uipath/src/uipath/_cli/services/cli_context_grounding.py
new file mode 100644
index 000000000..1e25def5e
--- /dev/null
+++ b/packages/uipath/src/uipath/_cli/services/cli_context_grounding.py
@@ -0,0 +1,785 @@
+"""Context Grounding service commands for UiPath CLI.
+
+Context Grounding provides capabilities for indexing, retrieving, and searching
+through contextual information used to enhance AI-enabled automation.
+"""
+# ruff: noqa: D301 - Click uses \b in docstrings for formatting
+
+import json as json_module
+from typing import Any, Optional
+
+import click
+
+from .._utils._service_base import (
+    ServiceCommandBase,
+    common_service_options,
+    handle_not_found_error,
+    service_command,
+)
+
+
+@click.group(name="context-grounding")
+def context_grounding() -> None:
+    """Manage UiPath Context Grounding indexes.
+
+    Context Grounding indexes store and search contextual information
+    used to enhance AI-enabled automation processes.
+
+    \b
+    Two index types:
+        Regular   - Persistent, backed by bucket or connection, created via 'create'
+        Ephemeral - Temporary, no Orchestrator folder, created from local files via 'create-ephemeral'
+
+    \b
+    Examples:
+        uipath context-grounding list --folder-path "Shared"
+    """
+    pass
+
+
+@context_grounding.command(name="list")
+@common_service_options
+@service_command
+def list_indexes(
+    ctx: click.Context,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """List all context grounding indexes.
+
+    \b
+    Examples:
+        uipath context-grounding list --folder-path "Shared"
+    """
+    client = ServiceCommandBase.get_client(ctx)
+    return client.context_grounding.list_indexes(
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+
+@context_grounding.command(name="retrieve")
+@click.option("--index-name", help="Name of the index to retrieve")
+@click.option("--index-id", help="ID of the index to retrieve (ephemeral indexes only)")
+@common_service_options
+@service_command
+def retrieve_index(
+    ctx: click.Context,
+    index_name: Optional[str],
+    index_id: Optional[str],
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Retrieve a context grounding index.
+
+    \b
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    \b
+    Examples:
+        uipath context-grounding retrieve --index-name my-index --folder-path "Shared"
+        uipath context-grounding retrieve --index-id abc-123-def-456 --format json
+    """
+    from httpx import HTTPStatusError
+
+    if not index_name and not index_id:
+        raise click.UsageError("Either --index-name or --index-id must be provided.")
+    if index_name and index_id:
+        raise click.UsageError("Provide either --index-name or --index-id, not both.")
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    if index_id:
+        from uipath.platform.context_grounding import ContextGroundingIndex
+
+        raw = client.context_grounding.retrieve_by_id(
+            index_id,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+        return ContextGroundingIndex.model_validate(raw)
+
+    assert index_name is not None  # validated above
+    name = index_name
+    try:
+        return client.context_grounding.retrieve(
+            name=name,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+    except LookupError:
+        handle_not_found_error("Index", name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Index", name, e)
+        raise
+
+
+@context_grounding.command(name="create")
+@click.option("--index-name", required=True, help="Name of the index to create")
+@click.option(
+    "--source-file",
+    type=click.Path(exists=True),
+    help="JSON file with connection source configuration (Google Drive, OneDrive, Dropbox, Confluence)",
+)
+@click.option(
+    "--bucket-source",
+    help="Bucket name for bucket-backed indexes",
+)
+@click.option("--description", default="", help="Description of the index")
+@click.option(
+    "--extraction-strategy",
+    type=click.Choice(["LLMV4", "NativeV1"]),
+    default="LLMV4",
+    help="Extraction strategy (default: LLMV4)",
+)
+@click.option("--file-type", help="File type filter (e.g., 'pdf', 'txt')")
+@common_service_options
+@service_command
+def create_index(
+    ctx: click.Context,
+    index_name: str,
+    source_file: Optional[str],
+    bucket_source: Optional[str],
+    description: str,
+    extraction_strategy: str,
+    file_type: Optional[str],
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Create a new context grounding index (persistent).
+
+    The created index lives in an Orchestrator folder. Ingestion must be
+    triggered separately after creation.
+
+    \b
+    Two ways to specify the data source:
+        --bucket-source   Bucket name for bucket-backed indexes
+        --source-file     JSON file for connections (use 'source-schema' to see formats)
+
+    \b
+    Examples:
+        uipath context-grounding create --index-name my-index --bucket-source my-bucket
+        uipath context-grounding create --index-name my-index --source-file config.json
+    """
+    if source_file and bucket_source:
+        raise click.UsageError(
+            "Cannot use both --source-file and --bucket-source. Choose one."
+        )
+    if not source_file and not bucket_source:
+        raise click.UsageError(
+            "Either --source-file or --bucket-source must be provided."
+        )
+
+    source: Any
+    if source_file:
+        from pydantic import TypeAdapter
+
+        from uipath.platform.context_grounding import SourceConfig
+
+        with open(source_file) as f:
+            source_data = json_module.load(f)
+
+        source = TypeAdapter(SourceConfig).validate_python(source_data)
+    else:
+        from uipath.platform.context_grounding import BucketSourceConfig
+
+        assert bucket_source is not None  # validated above
+        source = BucketSourceConfig(
+            bucket_name=bucket_source,
+            folder_path=folder_path or "",
+            file_type=file_type,
+        )
+
+    client = ServiceCommandBase.get_client(ctx)
+    result = client.context_grounding.create_index(
+        name=index_name,
+        source=source,
+        description=description,
+        extraction_strategy=extraction_strategy,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+    return result
+
+
+_SOURCE_TYPES = {
+    "google_drive": "GoogleDriveSourceConfig",
+    "onedrive": "OneDriveSourceConfig",
+    "dropbox": "DropboxSourceConfig",
+    "confluence": "ConfluenceSourceConfig",
+}
+
+
+@context_grounding.command(name="source-schema")
+@click.option(
+    "--type",
+    "source_type",
+    type=click.Choice(list(_SOURCE_TYPES.keys())),
+    help="Show schema for a specific source type (omit to show all)",
+)
+def source_schema(source_type: Optional[str]) -> None:
+    """Show JSON source file formats for connection-backed indexes.
+
+    Use this to see the required fields for --source-file when creating
+    an index backed by Google Drive, OneDrive, Dropbox, or Confluence.
+
+    \b
+    Examples:
+        uipath context-grounding source-schema --type google_drive
+    """
+    import json
+
+    from uipath.platform.context_grounding import context_grounding_payloads as payloads
+
+    types_to_show = (
+        {source_type: _SOURCE_TYPES[source_type]} if source_type else _SOURCE_TYPES
+    )
+
+    for type_key, class_name in types_to_show.items():
+        cls = getattr(payloads, class_name)
+        schema = cls.model_json_schema()
+        required = schema.get("required", [])
+        props = schema.get("properties", {})
+        example = {}
+        for field_name, info in props.items():
+            if field_name in required:
+                default = info.get("default")
+                example[field_name] = (
+                    default
+                    if default is not None
+                    else f"<{info.get('description', field_name)}>"
+                )
+        click.echo(f"\n{type_key}:", err=False)
+        click.echo(json.dumps(example, indent=2), err=False)
+
+    click.echo("", err=False)
+
+
+@context_grounding.command(name="create-ephemeral")
+@click.option(
+    "--usage",
+    required=True,
+    type=click.Choice(["DeepRAG", "BatchRAG"]),
+    help="Task type for the ephemeral index",
+)
+@click.option(
+    "--files",
+    multiple=True,
+    required=True,
+    type=click.Path(exists=True),
+    help="Local file paths to upload as attachments (repeatable)",
+)
+@common_service_options
+@service_command
+def create_ephemeral(
+    ctx: click.Context,
+    usage: str,
+    files: tuple[str, ...],
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Create an ephemeral index from local files (temporary).
+
+    Uploads files as attachments and creates a temporary index. Reference it
+    in other commands with --index-id (no folder, no name). Ingestion starts
+    automatically. Poll with 'retrieve --index-id <id>' until
+    lastIngestionStatus is Successful before starting a task.
+
+    \b
+    Supported file types:
+        DeepRAG:  PDF, TXT
+        BatchRAG: CSV
+
+    \b
+    Examples:
+        uipath context-grounding create-ephemeral --usage DeepRAG --files doc1.pdf --files doc2.pdf
+        uipath context-grounding create-ephemeral --usage BatchRAG --files data.csv
+    """
+    from pathlib import Path
+
+    from uipath.platform.context_grounding import EphemeralIndexUsage
+
+    allowed_extensions = {
+        "DeepRAG": {".pdf", ".txt"},
+        "BatchRAG": {".csv"},
+    }
+    allowed = allowed_extensions[usage]
+    for file_path in files:
+        ext = Path(file_path).suffix.lower()
+        if ext not in allowed:
+            raise click.UsageError(
+                f"File '{Path(file_path).name}' has unsupported extension '{ext}' for {usage}. "
+                f"Supported: {', '.join(sorted(allowed))}"
+            )
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    attachment_ids = []
+    for file_path in files:
+        file_name = Path(file_path).name
+        click.echo(f"Uploading '{file_name}'...", err=True)
+        attachment_id = client.attachments.upload(
+            name=file_name,
+            source_path=file_path,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+        attachment_ids.append(str(attachment_id))
+        click.echo(f"Uploaded '{file_name}' (ID: {attachment_id})", err=True)
+
+    click.echo("Creating ephemeral index...", err=True)
+    index = client.context_grounding.create_ephemeral_index(
+        usage=EphemeralIndexUsage(usage),
+        attachments=attachment_ids,
+    )
+    click.echo(f"Ephemeral index created: {index.id}", err=True)
+
+    return index
+
+
+@context_grounding.command(name="delete")
+@click.option("--index-name", required=True, help="Name of the index to delete")
+@click.option("--confirm", is_flag=True, help="Skip confirmation prompt")
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be deleted without deleting"
+)
+@common_service_options
+@service_command
+def delete_index(
+    ctx: click.Context,
+    index_name: str,
+    confirm: bool,
+    dry_run: bool,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Delete a context grounding index.
+
+    \b
+    Examples:
+        uipath context-grounding delete --index-name my-index --confirm
+        uipath context-grounding delete --index-name my-index --dry-run
+    """
+    from httpx import HTTPStatusError
+
+    client = ServiceCommandBase.get_client(ctx)
+
+    # First retrieve to verify index exists
+    try:
+        client.context_grounding.retrieve(
+            name=index_name,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+    except LookupError:
+        handle_not_found_error("Index", index_name)
+    except HTTPStatusError as e:
+        if e.response.status_code == 404:
+            handle_not_found_error("Index", index_name, e)
+        raise
+
+    # Handle dry-run
+    if dry_run:
+        click.echo(f"Would delete index '{index_name}'", err=True)
+        return
+
+    # Handle confirmation
+    if not confirm:
+        if not click.confirm(f"Delete index '{index_name}'?"):
+            click.echo("Deletion cancelled.")
+            return
+
+    # Perform delete
+    client.context_grounding.delete_by_name(
+        name=index_name,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Deleted index '{index_name}'", err=True)
+
+
+@context_grounding.command(name="ingest")
+@click.option("--index-name", required=True, help="Name of the index to ingest")
+@common_service_options
+@service_command
+def ingest_index(
+    ctx: click.Context,
+    index_name: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> None:
+    """Trigger ingestion on a context grounding index.
+
+    Ingestion runs asynchronously. Use 'retrieve' to poll lastIngestionStatus
+    until it reaches Successful or Failed.
+
+    \b
+    Examples:
+        uipath context-grounding ingest --index-name my-index --folder-path "Shared"
+    """
+    client = ServiceCommandBase.get_client(ctx)
+    client.context_grounding.ingest_by_name(
+        name=index_name,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Ingestion triggered for index '{index_name}'", err=True)
+
+
+@context_grounding.command(name="search")
+@click.option("--index-name", required=True, help="Name of the index to search")
+@click.option("--query", required=True, help="Search query in natural language")
+@click.option(
+    "--limit",
+    type=click.IntRange(min=1),
+    default=10,
+    help="Maximum number of results (default: 10)",
+)
+@click.option(
+    "--threshold",
+    type=click.FloatRange(min=0.0, max=1.0),
+    default=0.0,
+    help="Minimum similarity threshold (default: 0.0)",
+)
+@click.option(
+    "--search-mode",
+    type=click.Choice(["Semantic"]),
+    default="Semantic",
+    help="Search mode (default: Semantic)",
+)
+@common_service_options
+@service_command
+def search_index(
+    ctx: click.Context,
+    index_name: str,
+    query: str,
+    limit: int,
+    threshold: float,
+    search_mode: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Search a context grounding index (regular indexes only).
+
+    \b
+    Examples:
+        uipath context-grounding search --index-name my-index --query "What is the revenue?"
+        uipath context-grounding search --index-name my-index --query "results" --limit 5
+    """
+    from uipath.platform.context_grounding import SearchMode
+
+    client = ServiceCommandBase.get_client(ctx)
+    return client.context_grounding.unified_search(
+        name=index_name,
+        query=query,
+        number_of_results=limit,
+        threshold=threshold,
+        search_mode=SearchMode(search_mode),
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+
+# --- Deep RAG nested group ---
+
+
+@click.group(name="deep-rag")
+def deep_rag() -> None:
+    """Manage Deep RAG tasks.
+
+    Deep RAG performs multi-document research and synthesis on context
+    grounding indexes.
+
+    \b
+    Examples:
+        uipath context-grounding deep-rag start --help
+    """
+    pass
+
+
+@deep_rag.command(name="start")
+@click.option("--index-name", help="Name of the context grounding index")
+@click.option(
+    "--index-id", help="ID of the context grounding index (ephemeral indexes only)"
+)
+@click.option("--task-name", required=True, help="Name for the Deep RAG task")
+@click.option("--prompt", required=True, help="Task prompt describing what to research")
+@click.option(
+    "--glob-pattern",
+    default="**",
+    help="Glob pattern to filter files in the index (default: **)",
+)
+@click.option(
+    "--citation-mode",
+    type=click.Choice(["Skip", "Inline"]),
+    default="Skip",
+    help="Citation mode (default: Skip)",
+)
+@common_service_options
+@service_command
+def start_deep_rag(
+    ctx: click.Context,
+    index_name: Optional[str],
+    index_id: Optional[str],
+    task_name: str,
+    prompt: str,
+    glob_pattern: str,
+    citation_mode: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Start a Deep RAG task on an index.
+
+    \b
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    \b
+    Examples:
+        uipath context-grounding deep-rag start --index-name my-index --folder-path Shared --task-name my-task --prompt "Summarize"
+        uipath context-grounding deep-rag start --index-id abc-123 --task-name my-task --prompt "Summarize"
+    """
+    from uipath.platform.context_grounding import CitationMode
+
+    if not index_name and not index_id:
+        raise click.UsageError("Either --index-name or --index-id must be provided.")
+    if index_name and index_id:
+        raise click.UsageError("Provide either --index-name or --index-id, not both.")
+
+    client = ServiceCommandBase.get_client(ctx)
+    result = client.context_grounding.start_deep_rag(
+        name=task_name,
+        prompt=prompt,
+        index_name=index_name,
+        index_id=index_id,
+        glob_pattern=glob_pattern,
+        citation_mode=CitationMode(citation_mode),
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Deep RAG task started: {result.id}", err=True)
+
+    return result
+
+
+@deep_rag.command(name="retrieve")
+@click.option("--task-id", required=True, help="ID of the Deep RAG task")
+@common_service_options
+@service_command
+def retrieve_deep_rag(
+    ctx: click.Context,
+    task_id: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Retrieve a Deep RAG task result (status, summary, citations).
+
+    \b
+    Examples:
+        uipath context-grounding deep-rag retrieve --task-id abc-123-def-456
+    """
+    client = ServiceCommandBase.get_client(ctx)
+    return client.context_grounding.retrieve_deep_rag(id=task_id)
+
+
+context_grounding.add_command(deep_rag)
+
+
+# --- Batch Transform nested group ---
+
+
+@click.group(name="batch-transform")
+def batch_transform() -> None:
+    """Manage Batch Transform tasks.
+
+    Batch Transform processes and transforms CSV files from context
+    grounding indexes.
+
+    \b
+    Examples:
+        uipath context-grounding batch-transform start --help
+    """
+    pass
+
+
+@batch_transform.command(name="start")
+@click.option("--index-name", help="Name of the context grounding index")
+@click.option(
+    "--index-id", help="ID of the context grounding index (ephemeral indexes only)"
+)
+@click.option("--task-name", required=True, help="Name for the Batch Transform task")
+@click.option("--prompt", required=True, help="Task prompt describing what to process")
+@click.option(
+    "--columns-file",
+    required=True,
+    type=click.Path(exists=True),
+    help="JSON file defining output columns (see format above)",
+)
+@click.option("--target-file", help="Specific file name to target in the index")
+@click.option(
+    "--prefix",
+    help="Storage bucket folder path prefix for filtering files",
+)
+@click.option(
+    "--web-search",
+    is_flag=True,
+    help="Enable web search grounding",
+)
+@common_service_options
+@service_command
+def start_batch_transform(
+    ctx: click.Context,
+    index_name: Optional[str],
+    index_id: Optional[str],
+    task_name: str,
+    prompt: str,
+    columns_file: str,
+    target_file: Optional[str],
+    prefix: Optional[str],
+    web_search: bool,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Start a Batch Transform task on an index.
+
+    The index must contain CSV files. Only one file is processed per task.
+
+    \b
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    \b
+    --columns-file is a JSON array defining output columns:
+        [
+          {"name": "entity", "description": "Extracted entity name"},
+          {"name": "category", "description": "Entity category"}
+        ]
+
+    \b
+    Examples:
+        uipath context-grounding batch-transform start --index-name my-index --task-name my-task --prompt "Extract" --columns-file cols.json
+        uipath context-grounding batch-transform start --index-id abc-123 --task-name my-task --prompt "Extract" --columns-file cols.json
+    """
+    from uipath.platform.context_grounding import BatchTransformOutputColumn
+
+    if not index_name and not index_id:
+        raise click.UsageError("Either --index-name or --index-id must be provided.")
+    if index_name and index_id:
+        raise click.UsageError("Provide either --index-name or --index-id, not both.")
+
+    with open(columns_file) as f:
+        columns_data = json_module.load(f)
+
+    output_columns = [BatchTransformOutputColumn(**col) for col in columns_data]
+
+    client = ServiceCommandBase.get_client(ctx)
+    result = client.context_grounding.start_batch_transform(
+        name=task_name,
+        prompt=prompt,
+        index_name=index_name,
+        index_id=index_id,
+        output_columns=output_columns,
+        storage_bucket_folder_path_prefix=prefix,
+        target_file_name=target_file,
+        enable_web_search_grounding=web_search,
+        folder_path=folder_path,
+        folder_key=folder_key,
+    )
+
+    click.echo(f"Batch Transform task started: {result.id}", err=True)
+
+    return result
+
+
+@batch_transform.command(name="retrieve")
+@click.option("--task-id", required=True, help="ID of the Batch Transform task")
+@common_service_options
+@service_command
+def retrieve_batch_transform(
+    ctx: click.Context,
+    task_id: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> Any:
+    """Retrieve a Batch Transform task status.
+
+    \b
+    Examples:
+        uipath context-grounding batch-transform retrieve --task-id abc-123-def-456
+    """
+    client = ServiceCommandBase.get_client(ctx)
+    return client.context_grounding.retrieve_batch_transform(id=task_id)
+
+
+@batch_transform.command(name="download")
+@click.option("--task-id", required=True, help="ID of the Batch Transform task")
+@click.option(
+    "--output-file",
+    required=True,
+    type=click.Path(),
+    help="Local destination path for the result file",
+)
+@common_service_options
+@service_command
+def download_batch_transform(
+    ctx: click.Context,
+    task_id: str,
+    output_file: str,
+    folder_path: Optional[str],
+    folder_key: Optional[str],
+    format: Optional[str],
+    output: Optional[str],
+) -> None:
+    """Download a Batch Transform result file.
+
+    \b
+    Examples:
+        uipath context-grounding batch-transform download --task-id abc-123 --output-file result.csv
+    """
+    client = ServiceCommandBase.get_client(ctx)
+    client.context_grounding.download_batch_transform_result(
+        id=task_id,
+        destination_path=output_file,
+    )
+
+    click.echo(f"Downloaded to '{output_file}'", err=True)
+
+
+context_grounding.add_command(batch_transform)
+
+
+def __getattr__(name: str) -> click.Group:
+    """Allow lazy loading with hyphenated command name."""
+    if name == "context-grounding":
+        return context_grounding
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/src/uipath/_cli/spinner.py b/packages/uipath/src/uipath/_cli/spinner.py
similarity index 93%
rename from src/uipath/_cli/spinner.py
rename to packages/uipath/src/uipath/_cli/spinner.py
index 4d81c3ff1..508e2cdd3 100644
--- a/src/uipath/_cli/spinner.py
+++ b/packages/uipath/src/uipath/_cli/spinner.py
@@ -1,5 +1,3 @@
-from typing import Optional
-
 from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner as RichSpinner
@@ -12,7 +10,7 @@ class Spinner:
     def __init__(self, message: str = ""):
         self.message = message
         self._console = Console()
-        self._live: Optional[Live] = None
+        self._live: Live | None = None
         self._spinner = RichSpinner("dots", Text(message))
 
     def start(self, message: str = "") -> None:
diff --git a/packages/uipath/src/uipath/_resources/AGENTS.md b/packages/uipath/src/uipath/_resources/AGENTS.md
new file mode 100644
index 000000000..b83142f0f
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/AGENTS.md
@@ -0,0 +1,21 @@
+# Agent Code Patterns Reference
+
+This document provides practical code patterns for building UiPath coded agents using the UiPath Python SDK.
+
+---
+
+## Documentation Structure
+
+This documentation is split into multiple files for efficient context loading. Load only the files you need:
+
+1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
+   - **When to load:** Creating a new agent or understanding required patterns
+   - **Contains:** Required Pydantic models (Input, Output), SDK initialization patterns, standard agent template
+
+2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
+   - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
+   - **Contains:** All SDK services and methods with full signatures and type annotations
+
+3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
+   - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
+   - **Contains:** Command syntax, options, usage examples, and workflows
diff --git a/packages/uipath/src/uipath/_resources/CLAUDE.md b/packages/uipath/src/uipath/_resources/CLAUDE.md
new file mode 100644
index 000000000..eef4bd20c
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/_resources/CLI_REFERENCE.md b/packages/uipath/src/uipath/_resources/CLI_REFERENCE.md
new file mode 100644
index 000000000..ff4009b22
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/CLI_REFERENCE.md
@@ -0,0 +1,948 @@
+## CLI Commands Reference
+
+The UiPath Python SDK provides a comprehensive CLI for managing coded agents and automation projects. All commands should be executed with `uv run uipath <command>`.
+
+### Command Overview
+
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| `init` | Initialize agent project | Creating a new agent or updating schema |
+| `run` | Execute agent | Running agent locally or testing |
+| `eval` | Evaluate agent | Testing agent performance with evaluation sets |
+
+---
+
+### `uipath init`
+
+**Description:** Initialize the project.
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `--no-agents-md-override` | flag | false | Won't override existing .agent files and AGENTS.md file. |
+
+**Usage Examples:**
+
+```bash
+# Initialize a new agent project
+uv run uipath init
+
+# Initialize with specific entrypoint
+uv run uipath init main.py
+
+# Initialize and infer bindings from code
+uv run uipath init --infer-bindings
+```
+
+**When to use:** Run this command when you've modified the Input/Output models and need to regenerate the `uipath.json` schema file.
+
+---
+
+### `uipath run`
+
+**Description:** Execute the project.
+
+**Arguments:**
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| `entrypoint` | No | N/A |
+| `input` | No | N/A |
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `--resume` | flag | false | Resume execution from a previous state |
+| `-f`, `--file` | value | `Sentinel.UNSET` | File path for the .json input |
+| `--input-file` | value | `Sentinel.UNSET` | Alias for '-f/--file' arguments |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
+| `--trace-file` | value | `Sentinel.UNSET` | File path where the trace spans will be written (JSON Lines format) |
+| `--state-file` | value | `Sentinel.UNSET` | File path where the state file is stored for persisting execution state. If not provided, a temporary file will be used. |
+| `--debug` | flag | false | Enable debugging with debugpy. The process will wait for a debugger to attach. |
+| `--debug-port` | value | `5678` | Port for the debug server (default: 5678) |
+| `--keep-state-file` | flag | false | Keep the temporary state file even when not resuming and no job id is provided |
+
+**Usage Examples:**
+
+```bash
+# Run agent with inline JSON input
+uv run uipath run main.py '{"query": "What is the weather?"}'
+
+# Run agent with input from file
+uv run uipath run main.py --file input.json
+
+# Run agent and save output to file
+uv run uipath run agent '{"task": "Process data"}' --output-file result.json
+
+# Run agent with debugging enabled
+uv run uipath run main.py '{"input": "test"}' --debug --debug-port 5678
+
+# Resume agent execution from previous state
+uv run uipath run --resume
+```
+
+**When to use:** Run this command to execute your agent locally for development, testing, or debugging. Use `--debug` flag to attach a debugger for step-by-step debugging.
+
+---
+
+### `uipath eval`
+
+**Description:** Run an evaluation set against the agent.
+
+    Args:
+        entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
+        eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
+        eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
+        workers: Number of parallel workers for running evaluations
+        no_report: Do not report the evaluation results
+        enable_mocker_cache: Enable caching for LLM mocker responses
+        report_coverage: Report evaluation coverage
+        model_settings_id: Model settings ID to override agent settings
+        trace_file: File path where traces will be written in JSONL format
+        max_llm_concurrency: Maximum concurrent LLM requests
+        input_overrides: Input field overrides mapping (direct field override with deep merge)
+        resume: Resume execution from a previous suspended state
+    
+
+**Arguments:**
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| `entrypoint` | No | N/A |
+| `eval_set` | No | N/A |
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `--eval-set-run-id` | value | `Sentinel.UNSET` | Custom evaluation set run ID (if not provided, a UUID will be generated) |
+| `--no-report` | flag | false | Do not report the evaluation results |
+| `--workers` | value | `1` | Number of parallel workers for running evaluations (default: 1) |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
+| `--enable-mocker-cache` | flag | false | Enable caching for LLM mocker responses |
+| `--report-coverage` | flag | false | Report evaluation coverage |
+| `--model-settings-id` | value | `"default"` | Model settings ID from evaluation set to override agent settings (default: 'default') |
+| `--trace-file` | value | `Sentinel.UNSET` | File path where traces will be written in JSONL format |
+| `--max-llm-concurrency` | value | `20` | Maximum concurrent LLM requests (default: 20) |
+| `--resume` | flag | false | Resume execution from a previous suspended state |
+| `--verbose` | flag | false | Include agent execution output (trace, result) in the output file |
+
+**Usage Examples:**
+
+```bash
+# Run evaluation with auto-discovered files
+uv run uipath eval
+
+# Run evaluation with specific entrypoint and eval set
+uv run uipath eval main.py eval_set.json
+
+# Run evaluation without reporting results
+uv run uipath eval --no-report
+
+# Run evaluation with custom number of workers
+uv run uipath eval --workers 4
+
+# Save evaluation output to file
+uv run uipath eval --output-file eval_results.json
+```
+
+**When to use:** Run this command to test your agent's performance against a predefined evaluation set. This helps validate agent behavior and measure quality metrics.
+
+---
+
+### Common Workflows
+
+**1. Creating a New Agent:**
+```bash
+# Step 1: Initialize project
+uv run uipath init
+
+# Step 2: Run agent to test
+uv run uipath run main.py '{"input": "test"}'
+
+# Step 3: Evaluate agent performance
+uv run uipath eval
+```
+
+**2. Development & Testing:**
+```bash
+# Run with debugging
+uv run uipath run main.py '{"input": "test"}' --debug
+
+# Test with input file
+uv run uipath run main.py --file test_input.json --output-file test_output.json
+```
+
+**3. Schema Updates:**
+```bash
+# After modifying Input/Output models, regenerate schema
+uv run uipath init --infer-bindings
+```
+
+### Configuration File (uipath.json)
+
+The `uipath.json` file is automatically generated by `uipath init` and defines your agent's schema and bindings.
+
+**Structure:**
+
+```json
+{
+  "entryPoints": [
+    {
+      "filePath": "agent",
+      "uniqueId": "uuid-here",
+      "type": "agent",
+      "input": {
+        "type": "object",
+        "properties": { ... },
+        "description": "Input schema",
+        "required": [ ... ]
+      },
+      "output": {
+        "type": "object",
+        "properties": { ... },
+        "description": "Output schema",
+        "required": [ ... ]
+      }
+    }
+  ],
+  "bindings": {
+    "version": "2.0",
+    "resources": []
+  }
+}
+```
+
+**When to Update:**
+
+1. **After Modifying Input/Output Models**: Run `uv run uipath init --infer-bindings` to regenerate schemas
+2. **Changing Entry Point**: Update `filePath` if you rename or move your main file
+3. **Manual Schema Adjustments**: Edit `input.jsonSchema` or `output.jsonSchema` directly if needed
+4. **Bindings Updates**: The `bindings` section maps the exported graph variable - update if you rename your graph
+
+**Important Notes:**
+
+- The `uniqueId` should remain constant for the same agent
+- Always use `type: "agent"` for LangGraph agents
+- The `jsonSchema` must match your Pydantic models exactly
+- Re-run `uipath init --infer-bindings` instead of manual edits when possible
+
+
+## Service Commands Reference
+
+The UiPath CLI provides commands for interacting with UiPath platform services. These commands allow you to manage buckets, assets, jobs, and other resources.
+
+### `uipath assets`
+
+Manage UiPath assets.
+
+    Assets are key-value pairs that store configuration data, credentials,
+    and settings used by automation processes.
+
+    \b
+    Examples:
+        # List all assets in a folder
+        uipath assets list --folder-path "Shared"
+
+        # List with filter
+        uipath assets list --filter "ValueType eq 'Text'"
+
+        # List with ordering
+        uipath assets list --orderby "Name asc"
+    
+
+**Subcommands:**
+
+**`uipath assets list`**
+
+List assets in a folder.
+
+    \b
+    Examples:
+        uipath assets list
+        uipath assets list --folder-path "Shared"
+        uipath assets list --filter "ValueType eq 'Text'"
+        uipath assets list --filter "Name eq 'MyAsset'"
+        uipath assets list --orderby "Name asc"
+        uipath assets list --top 50 --skip 100
+    
+
+Options:
+- `--filter`: OData $filter expression (default: `Sentinel.UNSET`)
+- `--orderby`: OData $orderby expression (default: `Sentinel.UNSET`)
+- `--top`: Maximum number of items to return (default: 100, max: 1000) (default: `100`)
+- `--skip`: Number of items to skip (default: `0`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+---
+
+### `uipath buckets`
+
+Manage UiPath storage buckets and files.
+
+Buckets are cloud storage containers for files used by automation processes.
+
+
+Bucket Operations:
+    list      - List all buckets
+    create    - Create a new bucket
+    delete    - Delete a bucket
+    retrieve  - Get bucket details
+    exists    - Check if bucket exists
+
+
+File Operations (use 'buckets files' subcommand):
+    files list     - List files in a bucket
+    files search   - Search files using glob patterns
+    files upload   - Upload a file to a bucket
+    files download - Download a file from a bucket
+    files delete   - Delete a file from a bucket
+    files exists   - Check if a file exists
+
+
+Examples:
+    
+    # Bucket operations with explicit folder
+    uipath buckets list --folder-path "Shared"
+    uipath buckets create my-bucket --description "Data storage"
+    uipath buckets exists my-bucket
+    uipath buckets delete my-bucket --confirm
+    
+    # Using environment variable for folder context
+    export UIPATH_FOLDER_PATH="Shared"
+    uipath buckets list
+    uipath buckets create my-bucket --description "Data storage"
+    
+    # File operations
+    uipath buckets files list my-bucket
+    uipath buckets files search my-bucket "*.pdf"
+    uipath buckets files upload my-bucket ./data.csv remote/data.csv
+    uipath buckets files download my-bucket data.csv ./local.csv
+    uipath buckets files delete my-bucket old-data.csv --confirm
+    uipath buckets files exists my-bucket data.csv
+
+
+**Subcommands:**
+
+**`uipath buckets create`**
+
+Create a new Bucket.
+
+Examples:
+    uipath buckets create my-resource
+    uipath buckets create my-resource --folder-path Shared
+
+
+Arguments:
+- `name` (required): N/A
+
+Options:
+- `--description`: Bucket description
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets delete`**
+
+Delete a bucket.
+
+    
+    Examples:
+        uipath buckets delete my-bucket --confirm
+        uipath buckets delete my-bucket --dry-run
+    
+
+Arguments:
+- `name` (required): N/A
+
+Options:
+- `--confirm`: Skip confirmation prompt
+- `--dry-run`: Show what would be deleted without deleting
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets exists`**
+
+Check if a Bucket exists.
+
+Examples:
+    uipath buckets exists my-resource
+    uipath buckets exists my-resource --folder-path Shared
+
+
+Arguments:
+- `name` (required): N/A
+
+Options:
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+#### `uipath buckets files`
+
+Manage files within buckets.
+
+    
+    Examples:
+        
+        # List files in a bucket
+        uipath buckets files list my-bucket
+        
+        # Search for files with glob pattern
+        uipath buckets files search my-bucket "*.pdf"
+        
+        # Upload a file
+        uipath buckets files upload my-bucket ./data.csv remote/data.csv
+        
+        # Download a file
+        uipath buckets files download my-bucket data.csv ./local.csv
+        
+        # Delete a file
+        uipath buckets files delete my-bucket old-data.csv --confirm
+        
+        # Check if file exists
+        uipath buckets files exists my-bucket data.csv
+    
+
+**`uipath buckets files delete`**
+
+Delete a file from a bucket.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        FILE_PATH: Path to file in bucket
+
+    
+    Examples:
+        uipath buckets files delete my-bucket old-data.csv --confirm
+        uipath buckets files delete reports archive/old.pdf --dry-run
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+- `file_path` (required): N/A
+
+Options:
+- `--confirm`: Skip confirmation prompt
+- `--dry-run`: Show what would be deleted
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets files download`**
+
+Download a file from a bucket.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        REMOTE_PATH: Path to file in bucket
+        LOCAL_PATH: Local destination path
+
+    
+    Examples:
+        uipath buckets files download my-bucket data.csv ./downloads/data.csv
+        uipath buckets files download reports monthly/report.pdf ./report.pdf
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+- `remote_path` (required): N/A
+- `local_path` (required): N/A
+
+Options:
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets files exists`**
+
+Check if a file exists in a bucket.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        FILE_PATH: Path to file in bucket
+
+    
+    Examples:
+        uipath buckets files exists my-bucket data.csv
+        uipath buckets files exists reports monthly/report.pdf
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+- `file_path` (required): N/A
+
+Options:
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets files list`**
+
+List files in a bucket.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+
+    
+    Examples:
+        uipath buckets files list my-bucket
+        uipath buckets files list my-bucket --prefix "data/"
+        uipath buckets files list reports --limit 10 --format json
+        uipath buckets files list my-bucket --all
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+
+Options:
+- `--prefix`: Filter files by prefix (default: ``)
+- `--limit`: Maximum number of files to return (default: `Sentinel.UNSET`)
+- `--offset`: Number of files to skip (default: `0`)
+- `--all`: Fetch all files (auto-paginate)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets files search`**
+
+Search for files using glob patterns.
+
+    Uses the GetFiles API which supports glob patterns like *.pdf or data_*.csv.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        PATTERN: Glob pattern to match files (e.g., "*.pdf", "data_*.csv")
+
+    
+    Examples:
+        uipath buckets files search my-bucket "*.pdf"
+        uipath buckets files search reports "*.csv" --recursive
+        uipath buckets files search my-bucket "data_*.json" --prefix "archive/"
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+- `pattern` (required): N/A
+
+Options:
+- `--prefix`: Directory path to search in (default: ``)
+- `--recursive`: Search subdirectories recursively
+- `--limit`: Maximum number of files to return (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets files upload`**
+
+Upload a file to a bucket.
+
+    
+    Arguments:
+        BUCKET_NAME: Name of the bucket
+        LOCAL_PATH: Local file to upload
+        REMOTE_PATH: Destination path in bucket
+
+    
+    Examples:
+        uipath buckets files upload my-bucket ./data.csv remote/data.csv
+        uipath buckets files upload reports ./report.pdf monthly/report.pdf
+    
+
+Arguments:
+- `bucket_name` (required): N/A
+- `local_path` (required): N/A
+- `remote_path` (required): N/A
+
+Options:
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets list`**
+
+List all Buckets.
+
+Examples:
+    uipath buckets list
+    uipath buckets list --folder-path Shared
+
+
+Options:
+- `--limit`: Maximum number of items to return (default: `Sentinel.UNSET`)
+- `--offset`: Number of items to skip (default: `0`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath buckets retrieve`**
+
+Retrieve a bucket by name or key.
+
+    
+    Examples:
+        uipath buckets retrieve --name "my-bucket"
+        uipath buckets retrieve --key "abc-123-def-456" --format json
+    
+
+Options:
+- `--name`: Bucket name (default: `Sentinel.UNSET`)
+- `--key`: Bucket key (UUID) (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+---
+
+### `uipath context-grounding`
+
+Manage UiPath Context Grounding indexes.
+
+    Context Grounding indexes store and search contextual information
+    used to enhance AI-enabled automation processes.
+
+    
+    Two index types:
+        Regular   - Persistent, backed by bucket or connection, created via 'create'
+        Ephemeral - Temporary, no Orchestrator folder, created from local files via 'create-ephemeral'
+
+    
+    Examples:
+        uipath context-grounding list --folder-path "Shared"
+    
+
+**Subcommands:**
+
+#### `uipath context-grounding batch-transform`
+
+Manage Batch Transform tasks.
+
+    Batch Transform processes and transforms CSV files from context
+    grounding indexes.
+
+    
+    Examples:
+        uipath context-grounding batch-transform start --help
+    
+
+**`uipath context-grounding batch-transform download`**
+
+Download a Batch Transform result file.
+
+    
+    Examples:
+        uipath context-grounding batch-transform download --task-id abc-123 --output-file result.csv
+    
+
+Options:
+- `--task-id`: ID of the Batch Transform task (default: `Sentinel.UNSET`)
+- `--output-file`: Local destination path for the result file (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding batch-transform retrieve`**
+
+Retrieve a Batch Transform task status.
+
+    
+    Examples:
+        uipath context-grounding batch-transform retrieve --task-id abc-123-def-456
+    
+
+Options:
+- `--task-id`: ID of the Batch Transform task (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding batch-transform start`**
+
+Start a Batch Transform task on an index.
+
+    The index must contain CSV files. Only one file is processed per task.
+
+    
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    
+    --columns-file is a JSON array defining output columns:
+        [
+          {"name": "entity", "description": "Extracted entity name"},
+          {"name": "category", "description": "Entity category"}
+        ]
+
+    
+    Examples:
+        uipath context-grounding batch-transform start --index-name my-index --task-name my-task --prompt "Extract" --columns-file cols.json
+        uipath context-grounding batch-transform start --index-id abc-123 --task-name my-task --prompt "Extract" --columns-file cols.json
+    
+
+Options:
+- `--index-name`: Name of the context grounding index (default: `Sentinel.UNSET`)
+- `--index-id`: ID of the context grounding index (ephemeral indexes only) (default: `Sentinel.UNSET`)
+- `--task-name`: Name for the Batch Transform task (default: `Sentinel.UNSET`)
+- `--prompt`: Task prompt describing what to process (default: `Sentinel.UNSET`)
+- `--columns-file`: JSON file defining output columns (see format above) (default: `Sentinel.UNSET`)
+- `--target-file`: Specific file name to target in the index (default: `Sentinel.UNSET`)
+- `--prefix`: Storage bucket folder path prefix for filtering files (default: `Sentinel.UNSET`)
+- `--web-search`: Enable web search grounding
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding create`**
+
+Create a new context grounding index (persistent).
+
+    The created index lives in an Orchestrator folder. Ingestion must be
+    triggered separately after creation.
+
+    
+    Two ways to specify the data source:
+        --bucket-source   Bucket name for bucket-backed indexes
+        --source-file     JSON file for connections (use 'source-schema' to see formats)
+
+    
+    Examples:
+        uipath context-grounding create --index-name my-index --bucket-source my-bucket
+        uipath context-grounding create --index-name my-index --source-file config.json
+    
+
+Options:
+- `--index-name`: Name of the index to create (default: `Sentinel.UNSET`)
+- `--source-file`: JSON file with connection source configuration (Google Drive, OneDrive, Dropbox, Confluence) (default: `Sentinel.UNSET`)
+- `--bucket-source`: Bucket name for bucket-backed indexes (default: `Sentinel.UNSET`)
+- `--description`: Description of the index (default: ``)
+- `--extraction-strategy`: Extraction strategy (default: LLMV4) (default: `LLMV4`)
+- `--file-type`: File type filter (e.g., 'pdf', 'txt') (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding create-ephemeral`**
+
+Create an ephemeral index from local files (temporary).
+
+    Uploads files as attachments and creates a temporary index. Reference it
+    in other commands with --index-id (no folder, no name). Ingestion starts
+    automatically. Poll with 'retrieve --index-id <id>' until
+    lastIngestionStatus is Successful before starting a task.
+
+    
+    Supported file types:
+        DeepRAG:  PDF, TXT
+        BatchRAG: CSV
+
+    
+    Examples:
+        uipath context-grounding create-ephemeral --usage DeepRAG --files doc1.pdf --files doc2.pdf
+        uipath context-grounding create-ephemeral --usage BatchRAG --files data.csv
+    
+
+Options:
+- `--usage`: Task type for the ephemeral index (default: `Sentinel.UNSET`)
+- `--files`: Local file paths to upload as attachments (repeatable) (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+#### `uipath context-grounding deep-rag`
+
+Manage Deep RAG tasks.
+
+    Deep RAG performs multi-document research and synthesis on context
+    grounding indexes.
+
+    
+    Examples:
+        uipath context-grounding deep-rag start --help
+    
+
+**`uipath context-grounding deep-rag retrieve`**
+
+Retrieve a Deep RAG task result (status, summary, citations).
+
+    
+    Examples:
+        uipath context-grounding deep-rag retrieve --task-id abc-123-def-456
+    
+
+Options:
+- `--task-id`: ID of the Deep RAG task (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding deep-rag start`**
+
+Start a Deep RAG task on an index.
+
+    
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    
+    Examples:
+        uipath context-grounding deep-rag start --index-name my-index --folder-path Shared --task-name my-task --prompt "Summarize"
+        uipath context-grounding deep-rag start --index-id abc-123 --task-name my-task --prompt "Summarize"
+    
+
+Options:
+- `--index-name`: Name of the context grounding index (default: `Sentinel.UNSET`)
+- `--index-id`: ID of the context grounding index (ephemeral indexes only) (default: `Sentinel.UNSET`)
+- `--task-name`: Name for the Deep RAG task (default: `Sentinel.UNSET`)
+- `--prompt`: Task prompt describing what to research (default: `Sentinel.UNSET`)
+- `--glob-pattern`: Glob pattern to filter files in the index (default: **) (default: `**`)
+- `--citation-mode`: Citation mode (default: Skip) (default: `Skip`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding delete`**
+
+Delete a context grounding index.
+
+    
+    Examples:
+        uipath context-grounding delete --index-name my-index --confirm
+        uipath context-grounding delete --index-name my-index --dry-run
+    
+
+Options:
+- `--index-name`: Name of the index to delete (default: `Sentinel.UNSET`)
+- `--confirm`: Skip confirmation prompt
+- `--dry-run`: Show what would be deleted without deleting
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding ingest`**
+
+Trigger ingestion on a context grounding index.
+
+    Ingestion runs asynchronously. Use 'retrieve' to poll lastIngestionStatus
+    until it reaches Successful or Failed.
+
+    
+    Examples:
+        uipath context-grounding ingest --index-name my-index --folder-path "Shared"
+    
+
+Options:
+- `--index-name`: Name of the index to ingest (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding list`**
+
+List all context grounding indexes.
+
+    
+    Examples:
+        uipath context-grounding list --folder-path "Shared"
+    
+
+Options:
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding retrieve`**
+
+Retrieve a context grounding index.
+
+    
+    Two ways to specify the index:
+        Regular index:   --index-name + --folder-path
+        Ephemeral index: --index-id
+
+    
+    Examples:
+        uipath context-grounding retrieve --index-name my-index --folder-path "Shared"
+        uipath context-grounding retrieve --index-id abc-123-def-456 --format json
+    
+
+Options:
+- `--index-name`: Name of the index to retrieve (default: `Sentinel.UNSET`)
+- `--index-id`: ID of the index to retrieve (ephemeral indexes only) (default: `Sentinel.UNSET`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding search`**
+
+Search a context grounding index (regular indexes only).
+
+    
+    Examples:
+        uipath context-grounding search --index-name my-index --query "What is the revenue?"
+        uipath context-grounding search --index-name my-index --query "results" --limit 5
+    
+
+Options:
+- `--index-name`: Name of the index to search (default: `Sentinel.UNSET`)
+- `--query`: Search query in natural language (default: `Sentinel.UNSET`)
+- `--limit`: Maximum number of results (default: 10) (default: `10`)
+- `--threshold`: Minimum similarity threshold (default: 0.0) (default: `0.0`)
+- `--search-mode`: Search mode (default: Semantic) (default: `Semantic`)
+- `--folder-path`: Folder path (e.g., "Shared"). Can also be set via UIPATH_FOLDER_PATH environment variable. (default: `Sentinel.UNSET`)
+- `--folder-key`: Folder key (UUID) (default: `Sentinel.UNSET`)
+- `--format`: Output format (overrides global) (default: `Sentinel.UNSET`)
+- `--output`, `-o`: Output file (overrides global) (default: `Sentinel.UNSET`)
+
+**`uipath context-grounding source-schema`**
+
+Show JSON source file formats for connection-backed indexes.
+
+    Use this to see the required fields for --source-file when creating
+    an index backed by Google Drive, OneDrive, Dropbox, or Confluence.
+
+    
+    Examples:
+        uipath context-grounding source-schema --type google_drive
+    
+
+Options:
+- `--type`: Show schema for a specific source type (omit to show all) (default: `Sentinel.UNSET`)
+
+---
+
diff --git a/packages/uipath/src/uipath/_resources/REQUIRED_STRUCTURE.md b/packages/uipath/src/uipath/_resources/REQUIRED_STRUCTURE.md
new file mode 100644
index 000000000..832fe51bf
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/REQUIRED_STRUCTURE.md
@@ -0,0 +1,64 @@
+## Required Agent Structure
+
+**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.
+
+### Required Components
+
+Every agent implementation MUST include these two Pydantic models:
+
+```python
+from pydantic import BaseModel
+
+class Input(BaseModel):
+    """Define input fields that the agent accepts"""
+    # Add your input fields here
+    pass
+
+class Output(BaseModel):
+    """Define output fields that the agent returns"""
+    # Add your output fields here
+    pass
+```
+
+### SDK Initialization
+
+```python
+from uipath.platform import UiPath
+
+# Initialize with environment variables
+uipath = UiPath()
+
+# With explicit credentials
+uipath = UiPath(base_url="https://cloud.uipath.com/...", secret="your_token")
+
+# Or with client_id and client_secret
+uipath = UiPath(
+    client_id=UIPATH_CLIENT_ID,
+    client_secret=UIPATH_CLIENT_SECRET,
+    scope=UIPATH_SCOPE,
+    base_url=UIPATH_URL
+)
+```
+
+### Standard Agent Template
+
+Every agent should follow this basic structure:
+
+```python
+from uipath.platform import UiPath
+from pydantic import BaseModel
+
+# 1. Define Input, and Output models
+class Input(BaseModel):
+    field: str
+
+class Output(BaseModel):
+    result: str
+
+# 2. Initialize with environment variables
+uipath = UiPath()
+
+# 3. Define the main function (the main function can be named "main", "run" or "execute")
+def main(input_data: Input) -> Output:
+     pass
+```
diff --git a/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md b/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md
new file mode 100644
index 000000000..02e9c0676
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md
@@ -0,0 +1,996 @@
+## API Reference
+
+This section provides a comprehensive reference for all UiPath SDK services and methods. Each service is documented with complete method signatures, including parameter types and return types.
+
+### SDK Initialization
+
+Initialize the UiPath SDK client
+
+```python
+from uipath.platform import UiPath
+
+# Initialize with environment variables
+sdk = UiPath()
+
+# Or with explicit credentials
+sdk = UiPath(base_url="https://cloud.uipath.com/...", secret="your_token")
+```
+
+### Agenthub
+
+Agenthub service
+
+```python
+# Fetch available models from LLM Gateway discovery endpoint.
+sdk.agenthub.get_available_llm_models(headers: dict[str, Any] | None=None) -> list[uipath.platform.agenthub.agenthub.LlmModel]
+
+# Asynchronously fetch available models from LLM Gateway discovery endpoint.
+sdk.agenthub.get_available_llm_models_async(headers: dict[str, Any] | None=None) -> list[uipath.platform.agenthub.agenthub.LlmModel]
+
+# Start a system agent job.
+sdk.agenthub.invoke_system_agent(agent_name: str, entrypoint: str, input_arguments: dict[str, Any] | None=None, folder_key: str | None=None, folder_path: str | None=None, headers: dict[str, Any] | None=None) -> str
+
+# Asynchronously start a system agent and return the job.
+sdk.agenthub.invoke_system_agent_async(agent_name: str, entrypoint: str, input_arguments: dict[str, Any] | None=None, folder_key: str | None=None, folder_path: str | None=None, headers: dict[str, Any] | None=None) -> str
+
+```
+
+### Api Client
+
+Api Client service
+
+```python
+# Access api_client service methods
+service = sdk.api_client
+
+```
+
+### Assets
+
+Assets service
+
+```python
+# List assets using OData API with offset-based pagination.
+sdk.assets.list(folder_path: Optional[str]=None, folder_key: Optional[str]=None, filter: Optional[str]=None, orderby: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.assets.Asset]
+
+# Asynchronously list assets using OData API with offset-based pagination.
+sdk.assets.list_async(folder_path: Optional[str]=None, folder_key: Optional[str]=None, filter: Optional[str]=None, orderby: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.assets.Asset]
+
+# Retrieve an asset by its name.
+sdk.assets.retrieve(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.orchestrator.assets.UserAsset | uipath.platform.orchestrator.assets.Asset
+
+# Asynchronously retrieve an asset by its name.
+sdk.assets.retrieve_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.orchestrator.assets.UserAsset | uipath.platform.orchestrator.assets.Asset
+
+# Get the decrypted value of a Secret asset.
+sdk.assets.retrieve_credential(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Optional[str]
+
+# Asynchronously get the decrypted value of a Secret asset.
+sdk.assets.retrieve_credential_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Optional[str]
+
+# Get the decrypted value of a Secret asset.
+sdk.assets.retrieve_secret(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Optional[str]
+
+# Asynchronously get the decrypted value of a Secret asset.
+sdk.assets.retrieve_secret_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Optional[str]
+
+# Update an asset's value.
+sdk.assets.update(robot_asset: uipath.platform.orchestrator.assets.UserAsset, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously update an asset's value.
+sdk.assets.update_async(robot_asset: uipath.platform.orchestrator.assets.UserAsset, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+```
+
+### Attachments
+
+Attachments service
+
+```python
+# Delete an attachment.
+sdk.attachments.delete(key: uuid.UUID, folder_key: str | None=None, folder_path: str | None=None) -> None
+
+# Delete an attachment asynchronously.
+sdk.attachments.delete_async(key: uuid.UUID, folder_key: str | None=None, folder_path: str | None=None) -> None
+
+# Download an attachment.
+sdk.attachments.download(key: uuid.UUID, destination_path: str, folder_key: str | None=None, folder_path: str | None=None) -> str
+
+# Download an attachment asynchronously.
+sdk.attachments.download_async(key: uuid.UUID, destination_path: str, folder_key: str | None=None, folder_path: str | None=None) -> str
+
+# Get the BlobFileAccess information for an attachment.
+sdk.attachments.get_blob_file_access_uri(key: uuid.UUID, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.attachments.attachments.BlobFileAccessInfo
+
+# Get the BlobFileAccess information for an attachment asynchronously.
+sdk.attachments.get_blob_file_access_uri_async(key: uuid.UUID, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.attachments.attachments.BlobFileAccessInfo
+
+# Open an attachment.
+sdk.attachments.open(attachment: uipath.platform.attachments.attachments.Attachment, mode: <enum 'AttachmentMode="AttachmentMode.READ", content: Union[str, bytes, Iterable[bytes], AsyncIterable[bytes], NoneType]=None, folder_key: str | None=None, folder_path: str | None=None) -> typing.Iterator[typing.Tuple[uipath.platform.attachments.attachments.Attachment, httpx.Response]]
+
+# Open an attachment asynchronously.
+sdk.attachments.open_async(attachment: uipath.platform.attachments.attachments.Attachment, mode: <enum 'AttachmentMode="AttachmentMode.READ", content: Union[str, bytes, Iterable[bytes], AsyncIterable[bytes], NoneType]=None, folder_key: str | None=None, folder_path: str | None=None) -> typing.AsyncIterator[typing.Tuple[uipath.platform.attachments.attachments.Attachment, httpx.Response]]
+
+# Upload a file or content to UiPath as an attachment.
+sdk.attachments.upload(name: str, content: str | bytes | None=None, source_path: str | None=None, folder_key: str | None=None, folder_path: str | None=None) -> uuid.UUID
+
+# Upload a file or content to UiPath as an attachment asynchronously.
+sdk.attachments.upload_async(name: str, content: str | bytes | None=None, source_path: str | None=None, folder_key: str | None=None, folder_path: str | None=None) -> uuid.UUID
+
+```
+
+### Automation Ops
+
+Automation Ops service
+
+```python
+# Retrieve the deployed policy.
+sdk.automation_ops.get_deployed_policy() -> dict[str, typing.Any]
+
+# Retrieve the deployed policy (async).
+sdk.automation_ops.get_deployed_policy_async() -> dict[str, typing.Any]
+
+```
+
+### Automation Tracker
+
+Automation Tracker service
+
+```python
+# End tracking an operation within a transaction.
+sdk.automation_tracker.end_operation(transaction_id: str, operation_id: str, name: str, fingerprint: str, parent_operation: Optional[str]=None, status: <enum 'OperationStatus="OperationStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# End tracking an operation within a transaction (async).
+sdk.automation_tracker.end_operation_async(transaction_id: str, operation_id: str, name: str, fingerprint: str, parent_operation: Optional[str]=None, status: <enum 'OperationStatus="OperationStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# End tracking a business transaction.
+sdk.automation_tracker.end_transaction(transaction_id: str, name: str, reference: str, fingerprint: str, status: <enum 'TransactionStatus="TransactionStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# End tracking a business transaction (async).
+sdk.automation_tracker.end_transaction_async(transaction_id: str, name: str, reference: str, fingerprint: str, status: <enum 'TransactionStatus="TransactionStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# Start tracking an operation within a transaction.
+sdk.automation_tracker.start_operation(transaction_id: str, operation_id: str, name: str, fingerprint: str, parent_operation: Optional[str]=None, status: <enum 'OperationStatus="OperationStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# Start tracking an operation within a transaction (async).
+sdk.automation_tracker.start_operation_async(transaction_id: str, operation_id: str, name: str, fingerprint: str, parent_operation: Optional[str]=None, status: <enum 'OperationStatus="OperationStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# Start tracking a business transaction.
+sdk.automation_tracker.start_transaction(transaction_id: str, name: str, reference: str, fingerprint: str, status: <enum 'TransactionStatus="TransactionStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+# Start tracking a business transaction (async).
+sdk.automation_tracker.start_transaction_async(transaction_id: str, name: str, reference: str, fingerprint: str, status: <enum 'TransactionStatus="TransactionStatus.UNKNOWN", result: Optional[str]=None, attributes: Optional[Dict[str, str]]=None, timestamp: Optional[datetime.datetime]=None) -> None
+
+```
+
+### Buckets
+
+Buckets service
+
+```python
+# Create a new bucket.
+sdk.buckets.create(name: str, description: Optional[str]=None, identifier: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> uipath.platform.orchestrator.buckets.Bucket
+
+# Async version of create().
+sdk.buckets.create_async(name: str, description: Optional[str]=None, identifier: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> uipath.platform.orchestrator.buckets.Bucket
+
+# Delete a bucket.
+sdk.buckets.delete(name: Optional[str]=None, key: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> None
+
+# Async version of delete().
+sdk.buckets.delete_async(name: Optional[str]=None, key: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> None
+
+# Delete a file from a bucket.
+sdk.buckets.delete_file(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Delete a file from a bucket asynchronously.
+sdk.buckets.delete_file_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Download a file from a bucket.
+sdk.buckets.download(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Download a file from a bucket asynchronously.
+sdk.buckets.download_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Check if bucket exists.
+sdk.buckets.exists(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Async version of exists().
+sdk.buckets.exists_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Check if a file exists in a bucket.
+sdk.buckets.exists_file(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Async version of exists_file().
+sdk.buckets.exists_file_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Get files using OData GetFiles API with offset-based pagination.
+sdk.buckets.get_files(name: Optional[str]=None, key: Optional[str]=None, prefix: str="", recursive: bool=False, file_name_glob: Optional[str]=None, skip: int=0, top: int=500, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.BucketFile]
+
+# Async version of get_files() with offset-based pagination.
+sdk.buckets.get_files_async(name: Optional[str]=None, key: Optional[str]=None, prefix: str="", recursive: bool=False, file_name_glob: Optional[str]=None, skip: int=0, top: int=500, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.BucketFile]
+
+# List buckets using OData API with offset-based pagination.
+sdk.buckets.list(folder_path: Optional[str]=None, folder_key: Optional[str]=None, name: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.Bucket]
+
+# Async version of list() with offset-based pagination.
+sdk.buckets.list_async(folder_path: Optional[str]=None, folder_key: Optional[str]=None, name: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.Bucket]
+
+# List files in a bucket using cursor-based pagination.
+sdk.buckets.list_files(name: Optional[str]=None, key: Optional[str]=None, prefix: str="", take_hint: int=500, continuation_token: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.BucketFile]
+
+# Async version of list_files() with cursor-based pagination.
+sdk.buckets.list_files_async(name: Optional[str]=None, key: Optional[str]=None, prefix: str="", take_hint: int=500, continuation_token: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.buckets.BucketFile]
+
+# Retrieve bucket information by its name.
+sdk.buckets.retrieve(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.orchestrator.buckets.Bucket
+
+# Asynchronously retrieve bucket information by its name.
+sdk.buckets.retrieve_async(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.orchestrator.buckets.Bucket
+
+# Upload a file to a bucket.
+sdk.buckets.upload(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Upload a file to a bucket asynchronously.
+sdk.buckets.upload_async(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+```
+
+### Connections
+
+Connections service
+
+```python
+# Invoke an activity synchronously.
+sdk.connections.invoke_activity(activity_metadata: uipath.platform.connections.connections.ActivityMetadata, connection_id: str, activity_input: Dict[str, Any]) -> typing.Any
+
+# Invoke an activity asynchronously.
+sdk.connections.invoke_activity_async(activity_metadata: uipath.platform.connections.connections.ActivityMetadata, connection_id: str, activity_input: Dict[str, Any]) -> typing.Any
+
+# Lists all connections with optional filtering.
+sdk.connections.list(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.platform.connections.connections.Connection]
+
+# Asynchronously lists all connections with optional filtering.
+sdk.connections.list_async(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.platform.connections.connections.Connection]
+
+# Synchronously retrieve connection API metadata.
+sdk.connections.metadata(element_instance_id: int, connector_key: str, tool_path: str, parameters: Optional[Dict[str, str]]=None, schema_mode: bool=True, max_jit_depth: int=5) -> uipath.platform.connections.connections.ConnectionMetadata
+
+# Asynchronously retrieve connection API metadata.
+sdk.connections.metadata_async(element_instance_id: int, connector_key: str, tool_path: str, parameters: Optional[Dict[str, str]]=None, schema_mode: bool=True, max_jit_depth: int=5) -> uipath.platform.connections.connections.ConnectionMetadata
+
+# Retrieve connection details by its key.
+sdk.connections.retrieve(key: str) -> uipath.platform.connections.connections.Connection
+
+# Asynchronously retrieve connection details by its key.
+sdk.connections.retrieve_async(key: str) -> uipath.platform.connections.connections.Connection
+
+# Retrieve event payload from UiPath Integration Service.
+sdk.connections.retrieve_event_payload(event_args: uipath.platform.connections.connections.EventArguments) -> typing.Dict[str, typing.Any]
+
+# Retrieve event payload from UiPath Integration Service.
+sdk.connections.retrieve_event_payload_async(event_args: uipath.platform.connections.connections.EventArguments) -> typing.Dict[str, typing.Any]
+
+# Retrieve an authentication token for a connection.
+sdk.connections.retrieve_token(key: str, token_type: <enum 'ConnectionTokenType="ConnectionTokenType.DIRECT") -> uipath.platform.connections.connections.ConnectionToken
+
+# Asynchronously retrieve an authentication token for a connection.
+sdk.connections.retrieve_token_async(key: str, token_type: <enum 'ConnectionTokenType="ConnectionTokenType.DIRECT") -> uipath.platform.connections.connections.ConnectionToken
+
+```
+
+### Context Grounding
+
+Context Grounding service
+
+```python
+# Add content to the index.
+sdk.context_grounding.add_to_index(name: str, blob_file_path: str, content_type: Optional[str]=None, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, ingest_data: bool=True) -> None
+
+# Asynchronously add content to the index.
+sdk.context_grounding.add_to_index_async(name: str, blob_file_path: str, content_type: Optional[str]=None, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, ingest_data: bool=True) -> None
+
+# Create a new ephemeral context grounding index.
+sdk.context_grounding.create_ephemeral_index(usage: <enum 'EphemeralIndexUsage, attachments: List[str], folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Create a new ephemeral context grounding index.
+sdk.context_grounding.create_ephemeral_index_async(usage: <enum 'EphemeralIndexUsage, attachments: List[str], folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Create a new context grounding index.
+sdk.context_grounding.create_index(name: str, source: Union[uipath.platform.context_grounding.context_grounding_payloads.BucketSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.GoogleDriveSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.DropboxSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.OneDriveSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.ConfluenceSourceConfig], description: Optional[str]=None, extraction_strategy: Optional[str]=None, embeddings_enabled: Optional[bool]=None, is_encrypted: Optional[bool]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Create a new context grounding index.
+sdk.context_grounding.create_index_async(name: str, source: Union[uipath.platform.context_grounding.context_grounding_payloads.BucketSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.GoogleDriveSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.DropboxSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.OneDriveSourceConfig, uipath.platform.context_grounding.context_grounding_payloads.ConfluenceSourceConfig], description: Optional[str]=None, extraction_strategy: Optional[str]=None, embeddings_enabled: Optional[bool]=None, is_encrypted: Optional[bool]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Delete a context grounding index by its name.
+sdk.context_grounding.delete_by_name(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Asynchronously delete a context grounding index by its name.
+sdk.context_grounding.delete_by_name_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Delete a context grounding index.
+sdk.context_grounding.delete_index(index: uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Asynchronously delete a context grounding index.
+sdk.context_grounding.delete_index_async(index: uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Downloads the Batch Transform result file to the specified path.
+sdk.context_grounding.download_batch_transform_result(id: str, destination_path: str, validate_status: bool=True, index_name: str | None=None) -> None
+
+# Asynchronously downloads the Batch Transform result file to the specified path.
+sdk.context_grounding.download_batch_transform_result_async(id: str, destination_path: str, validate_status: bool=True, index_name: str | None=None) -> None
+
+# Trigger ingestion on a context grounding index by its name.
+sdk.context_grounding.ingest_by_name(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Asynchronously trigger ingestion on a context grounding index by its name.
+sdk.context_grounding.ingest_by_name_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Ingest data into the context grounding index.
+sdk.context_grounding.ingest_data(index: uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Asynchronously ingest data into the context grounding index.
+sdk.context_grounding.ingest_data_async(index: uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# List all context grounding indexes in a folder.
+sdk.context_grounding.list(folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# Asynchronously list all context grounding indexes in a folder.
+sdk.context_grounding.list_async(folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# List all context grounding indexes in a folder.
+sdk.context_grounding.list_indexes(folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# Asynchronously list all context grounding indexes in a folder.
+sdk.context_grounding.list_indexes_async(folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# Retrieve context grounding index information by its name.
+sdk.context_grounding.retrieve(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None, include_system_indexes: bool=False) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Retrieve all context grounding indexes across all folders.
+sdk.context_grounding.retrieve_across_folders(name: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# Asynchronously retrieve all context grounding indexes across all folders.
+sdk.context_grounding.retrieve_across_folders_async(name: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex]
+
+# Asynchronously retrieve context grounding index information by its name.
+sdk.context_grounding.retrieve_async(name: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None, include_system_indexes: bool=False) -> uipath.platform.context_grounding.context_grounding_index.ContextGroundingIndex
+
+# Retrieves a Batch Transform task status.
+sdk.context_grounding.retrieve_batch_transform(id: str, index_name: str | None=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformResponse
+
+# Asynchronously retrieves a Batch Transform task status.
+sdk.context_grounding.retrieve_batch_transform_async(id: str, index_name: str | None=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformResponse
+
+# Retrieve context grounding index information by its ID.
+sdk.context_grounding.retrieve_by_id(id: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Any
+
+# Retrieve asynchronously context grounding index information by its ID.
+sdk.context_grounding.retrieve_by_id_async(id: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.Any
+
+# Retrieves a Deep RAG task.
+sdk.context_grounding.retrieve_deep_rag(id: str, index_name: str | None=None) -> uipath.platform.context_grounding.context_grounding.DeepRagResponse
+
+# Asynchronously retrieves a Deep RAG task.
+sdk.context_grounding.retrieve_deep_rag_async(id: str, index_name: str | None=None) -> uipath.platform.context_grounding.context_grounding.DeepRagResponse
+
+# Search for contextual information within a specific index.
+sdk.context_grounding.search(name: str, query: str, number_of_results: int=10, threshold: Optional[float]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding.ContextGroundingQueryResponse]
+
+# Search asynchronously for contextual information within a specific index.
+sdk.context_grounding.search_async(name: str, query: str, number_of_results: int=10, threshold: Optional[float]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[uipath.platform.context_grounding.context_grounding.ContextGroundingQueryResponse]
+
+# Starts a Batch Transform, task on the targeted index.
+sdk.context_grounding.start_batch_transform(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], output_columns: List[uipath.platform.context_grounding.context_grounding.BatchTransformOutputColumn], storage_bucket_folder_path_prefix: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, target_file_name: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, enable_web_search_grounding: bool=False, index_name: str | None=None, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformCreationResponse
+
+# Asynchronously starts a Batch Transform, task on the targeted index.
+sdk.context_grounding.start_batch_transform_async(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], output_columns: List[uipath.platform.context_grounding.context_grounding.BatchTransformOutputColumn], storage_bucket_folder_path_prefix: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, target_file_name: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, enable_web_search_grounding: bool=False, index_name: str | None=None, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformCreationResponse
+
+# Asynchronously starts a Batch Transform, task on the targeted index.
+sdk.context_grounding.start_batch_transform_ephemeral(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], output_columns: List[uipath.platform.context_grounding.context_grounding.BatchTransformOutputColumn], storage_bucket_folder_path_prefix: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, enable_web_search_grounding: bool=False, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformCreationResponse
+
+# Asynchronously starts a Batch Transform, task on the targeted index.
+sdk.context_grounding.start_batch_transform_ephemeral_async(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], output_columns: List[uipath.platform.context_grounding.context_grounding.BatchTransformOutputColumn], storage_bucket_folder_path_prefix: Annotated[str | None, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]=None, enable_web_search_grounding: bool=False, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None) -> uipath.platform.context_grounding.context_grounding.BatchTransformCreationResponse
+
+# Starts a Deep RAG task on the targeted index.
+sdk.context_grounding.start_deep_rag(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], glob_pattern: Annotated[str, FieldInfo(annotation=NoneType, required=False, default='*', metadata=[MaxLen(max_length=512)])]="**", citation_mode: <enum 'CitationMode="CitationMode.SKIP", index_name: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding.DeepRagCreationResponse
+
+# Asynchronously starts a Deep RAG task on the targeted index.
+sdk.context_grounding.start_deep_rag_async(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], glob_pattern: Annotated[str, FieldInfo(annotation=NoneType, required=False, default='*', metadata=[MaxLen(max_length=512)])]="**", citation_mode: <enum 'CitationMode="CitationMode.SKIP", index_name: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None, folder_key: str | None=None, folder_path: str | None=None) -> uipath.platform.context_grounding.context_grounding.DeepRagCreationResponse
+
+# Asynchronously starts a Deep RAG task on the targeted index.
+sdk.context_grounding.start_deep_rag_ephemeral(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], glob_pattern: Annotated[str, FieldInfo(annotation=NoneType, required=False, default='*', metadata=[MaxLen(max_length=512)])]="**", citation_mode: <enum 'CitationMode="CitationMode.SKIP", index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None) -> uipath.platform.context_grounding.context_grounding.DeepRagCreationResponse
+
+# Asynchronously starts a Deep RAG task on the targeted index.
+sdk.context_grounding.start_deep_rag_ephemeral_async(name: str, prompt: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=250000)])], glob_pattern: Annotated[str, FieldInfo(annotation=NoneType, required=False, default='*', metadata=[MaxLen(max_length=512)])]="**", citation_mode: <enum 'CitationMode="CitationMode.SKIP", index_id: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=512)])]]=None) -> uipath.platform.context_grounding.context_grounding.DeepRagCreationResponse
+
+# Perform a unified search on a context grounding index.
+sdk.context_grounding.unified_search(name: str, query: str, search_mode: <enum 'SearchMode="SearchMode.SEMANTIC", number_of_results: int=10, threshold: float=0.0, scope: Optional[uipath.platform.context_grounding.context_grounding.UnifiedSearchScope]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, include_system_indexes: bool=False) -> uipath.platform.context_grounding.context_grounding.UnifiedQueryResult
+
+# Asynchronously perform a unified search on a context grounding index.
+sdk.context_grounding.unified_search_async(name: str, query: str, search_mode: <enum 'SearchMode="SearchMode.SEMANTIC", number_of_results: int=10, threshold: float=0.0, scope: Optional[uipath.platform.context_grounding.context_grounding.UnifiedSearchScope]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, include_system_indexes: bool=False) -> uipath.platform.context_grounding.context_grounding.UnifiedQueryResult
+
+```
+
+### Conversational
+
+Conversational service
+
+```python
+# Access conversational service methods
+service = sdk.conversational
+
+```
+
+### Documents
+
+Documents service
+
+```python
+# Classify a document using a DU Modern project.
+sdk.documents.classify(project_type: <enum 'ProjectType, tag: Optional[str]=None, version: Optional[int]=None, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> typing.List[uipath.platform.documents.documents.ClassificationResult]
+
+# Asynchronously version of the [`classify`][uipath.platform.documents._documents_service.DocumentsService.classify] method.
+sdk.documents.classify_async(project_type: <enum 'ProjectType, tag: Optional[str]=None, version: Optional[int]=None, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> typing.List[uipath.platform.documents.documents.ClassificationResult]
+
+# Create a validate classification action for a document based on the classification results. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-classifications).
+sdk.documents.create_validate_classification_action(classification_results: List[uipath.platform.documents.documents.ClassificationResult], action_title: str, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_catalog: Optional[str]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.ValidateClassificationAction
+
+# Asynchronous version of the [`create_validation_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_classification_action] method.
+sdk.documents.create_validate_classification_action_async(classification_results: List[uipath.platform.documents.documents.ClassificationResult], action_title: str, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_catalog: Optional[str]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.ValidateClassificationAction
+
+# Create a validate extraction action for a document based on the extraction response. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-extractions).
+sdk.documents.create_validate_extraction_action(extraction_response: uipath.platform.documents.documents.ExtractionResponse, action_title: str, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_catalog: Optional[str]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.ValidateExtractionAction
+
+# Asynchronous version of the [`create_validation_action`][uipath.platform.documents._documents_service.DocumentsService.create_validate_extraction_action] method.
+sdk.documents.create_validate_extraction_action_async(extraction_response: uipath.platform.documents.documents.ExtractionResponse, action_title: str, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_catalog: Optional[str]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.ValidateExtractionAction
+
+# Extract predicted data from a document using an DU Modern/IXP project.
+sdk.documents.extract(tag: Optional[str]=None, version: Optional[int]=None, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, classification_result: Optional[uipath.platform.documents.documents.ClassificationResult]=None, project_type: Optional[uipath.platform.documents.documents.ProjectType]=None, document_type_name: Optional[str]=None) -> typing.Union[uipath.platform.documents.documents.ExtractionResponse, uipath.platform.documents.documents.ExtractionResponseIXP]
+
+# Asynchronously version of the [`extract`][uipath.platform.documents._documents_service.DocumentsService.extract] method.
+sdk.documents.extract_async(tag: Optional[str]=None, version: Optional[int]=None, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, classification_result: Optional[uipath.platform.documents.documents.ClassificationResult]=None, project_type: Optional[uipath.platform.documents.documents.ProjectType]=None, document_type_name: Optional[str]=None) -> typing.Union[uipath.platform.documents.documents.ExtractionResponse, uipath.platform.documents.documents.ExtractionResponseIXP]
+
+# Get the result of a validate classification action.
+sdk.documents.get_validate_classification_result(validation_action: uipath.platform.documents.documents.ValidateClassificationAction) -> typing.List[uipath.platform.documents.documents.ClassificationResult]
+
+# Asynchronous version of the [`get_validation_result`][uipath.platform.documents._documents_service.DocumentsService.get_validate_classification_result] method.
+sdk.documents.get_validate_classification_result_async(validation_action: uipath.platform.documents.documents.ValidateClassificationAction) -> typing.List[uipath.platform.documents.documents.ClassificationResult]
+
+# Get the result of a validate extraction action.
+sdk.documents.get_validate_extraction_result(validation_action: uipath.platform.documents.documents.ValidateExtractionAction) -> typing.Union[uipath.platform.documents.documents.ExtractionResponse, uipath.platform.documents.documents.ExtractionResponseIXP]
+
+# Asynchronous version of the [`get_validation_result`][uipath.platform.documents._documents_service.DocumentsService.get_validate_extraction_result] method.
+sdk.documents.get_validate_extraction_result_async(validation_action: uipath.platform.documents.documents.ValidateExtractionAction) -> typing.Union[uipath.platform.documents.documents.ExtractionResponse, uipath.platform.documents.documents.ExtractionResponseIXP]
+
+# Retrieve the result of an IXP extraction operation (single-shot, non-blocking).
+sdk.documents.retrieve_ixp_extraction_result(project_id: str, tag: str, operation_id: str) -> uipath.platform.documents.documents.ExtractionResponseIXP
+
+# Asynchronous version of the [`retrieve_ixp_extraction_result`][uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_result] method.
+sdk.documents.retrieve_ixp_extraction_result_async(project_id: str, tag: str, operation_id: str) -> uipath.platform.documents.documents.ExtractionResponseIXP
+
+# Retrieve the result of an IXP create validate extraction action operation (single-shot, non-blocking).
+sdk.documents.retrieve_ixp_extraction_validation_result(project_id: str, tag: str, operation_id: str) -> uipath.platform.documents.documents.ValidateExtractionAction
+
+# Asynchronous version of the [`retrieve_ixp_extraction_validation_result`][uipath.platform.documents._documents_service.DocumentsService.retrieve_ixp_extraction_validation_result] method.
+sdk.documents.retrieve_ixp_extraction_validation_result_async(project_id: str, tag: str, operation_id: str) -> uipath.platform.documents.documents.ValidateExtractionAction
+
+# Start an IXP extraction process without waiting for results (non-blocking).
+sdk.documents.start_ixp_extraction(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> uipath.platform.documents.documents.StartExtractionResponse
+
+# Asynchronous version of the [`start_ixp_extraction`][uipath.platform.documents._documents_service.DocumentsService.start_ixp_extraction] method.
+sdk.documents.start_ixp_extraction_async(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> uipath.platform.documents.documents.StartExtractionResponse
+
+# Start an IXP extraction validation action without waiting for results (non-blocking).
+sdk.documents.start_ixp_extraction_validation(extraction_response: uipath.platform.documents.documents.ExtractionResponseIXP, action_title: str, action_catalog: Optional[str]=None, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.StartExtractionValidationResponse
+
+# Asynchronous version of the [`start_ixp_extraction_validation`][uipath.platform.documents._documents_service.DocumentsService.start_ixp_extraction_validation] method.
+sdk.documents.start_ixp_extraction_validation_async(extraction_response: uipath.platform.documents.documents.ExtractionResponseIXP, action_title: str, action_catalog: Optional[str]=None, action_priority: Optional[uipath.platform.documents.documents.ActionPriority]=None, action_folder: Optional[str]=None, storage_bucket_name: Optional[str]=None, storage_bucket_directory_path: Optional[str]=None) -> uipath.platform.documents.documents.StartExtractionValidationResponse
+
+```
+
+### Entities
+
+Entities service
+
+```python
+# Create a new entity with the given schema and return its id.
+sdk.entities.create_entity(name: str, fields: List[uipath.platform.entities.entities.EntityCreateFieldOptions], options: Optional[uipath.platform.entities.entities.EntityCreateOptions]=None) -> str
+
+# Asynchronously create a new entity with the given schema.
+sdk.entities.create_entity_async(name: str, fields: List[uipath.platform.entities.entities.EntityCreateFieldOptions], options: Optional[uipath.platform.entities.entities.EntityCreateOptions]=None) -> str
+
+# Remove the file attached to a File-type field on a record.
+sdk.entities.delete_attachment(entity_id: str, record_id: str, field_name: str, expansion_level: Optional[int]=None) -> typing.Dict[str, typing.Any]
+
+# Asynchronously remove the file attached to a File-type field.
+sdk.entities.delete_attachment_async(entity_id: str, record_id: str, field_name: str, expansion_level: Optional[int]=None) -> typing.Dict[str, typing.Any]
+
+# Delete an entity and all of its records.
+sdk.entities.delete_entity(entity_id: str) -> None
+
+# Asynchronously delete an entity and all of its records.
+sdk.entities.delete_entity_async(entity_id: str) -> None
+
+# Delete a single record by id.
+sdk.entities.delete_record(entity_key: str, record_id: str) -> None
+
+# Asynchronously delete a single record by id.
+sdk.entities.delete_record_async(entity_key: str, record_id: str) -> None
+
+# Delete multiple records from an entity in a single batch operation.
+sdk.entities.delete_records(entity_key: str, record_ids: List[str], fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# Asynchronously delete multiple records from an entity in a single batch operation.
+sdk.entities.delete_records_async(entity_key: str, record_ids: List[str], fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# Download a file attached to a record and return its raw bytes.
+sdk.entities.download_attachment(entity_id: str, record_id: str, field_name: str) -> bytes
+
+# Asynchronously download a file attached to a record.
+sdk.entities.download_attachment_async(entity_id: str, record_id: str, field_name: str) -> bytes
+
+# Get the values of a choice set by its ID.
+sdk.entities.get_choiceset_values(choiceset_id: str, start: Optional[int]=None, limit: Optional[int]=None) -> typing.List[uipath.platform.entities.entities.ChoiceSetValue]
+
+# Asynchronously get the values of a choice set by its ID.
+sdk.entities.get_choiceset_values_async(choiceset_id: str, start: Optional[int]=None, limit: Optional[int]=None) -> typing.List[uipath.platform.entities.entities.ChoiceSetValue]
+
+# Fetch a single entity record by its id.
+sdk.entities.get_record(entity_key: str, record_id: str, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Asynchronously fetch a single entity record by its id.
+sdk.entities.get_record_async(entity_key: str, record_id: str, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Bulk-import records into an entity from a CSV file.
+sdk.entities.import_records(entity_id: str, file: Union[bytes, bytearray, memoryview, NoneType]=None, file_path: Optional[str]=None) -> uipath.platform.entities.entities.EntityImportRecordsResponse
+
+# Asynchronously bulk-import records into an entity from a CSV file.
+sdk.entities.import_records_async(entity_id: str, file: Union[bytes, bytearray, memoryview, NoneType]=None, file_path: Optional[str]=None) -> uipath.platform.entities.entities.EntityImportRecordsResponse
+
+# Insert a single record into an entity and return the inserted row.
+sdk.entities.insert_record(entity_key: str, data: Any, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Asynchronously insert a single record into an entity.
+sdk.entities.insert_record_async(entity_key: str, data: Any, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Insert multiple records into an entity in a single batch operation.
+sdk.entities.insert_records(entity_key: str, records: List[Any], schema: Optional[Type[Any]]=None, expansion_level: Optional[int]=None, fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# Asynchronously insert multiple records into an entity in a single batch operation.
+sdk.entities.insert_records_async(entity_key: str, records: List[Any], schema: Optional[Type[Any]]=None, expansion_level: Optional[int]=None, fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# List all choice sets in Data Service.
+sdk.entities.list_choicesets() -> typing.List[uipath.platform.entities.entities.Entity]
+
+# Asynchronously list all choice sets in Data Service.
+sdk.entities.list_choicesets_async() -> typing.List[uipath.platform.entities.entities.Entity]
+
+# List all entities in Data Service.
+sdk.entities.list_entities() -> typing.List[uipath.platform.entities.entities.Entity]
+
+# Asynchronously list all entities in the Data Service.
+sdk.entities.list_entities_async() -> typing.List[uipath.platform.entities.entities.Entity]
+
+# List records from an entity with optional pagination and schema validation.
+sdk.entities.list_records(entity_key: str, schema: Optional[Type[Any]]=None, start: Optional[int]=None, limit: Optional[int]=None, expansion_level: Optional[int]=None, filter: Optional[str]=None, orderby: Optional[str]=None, select: Optional[List[str]]=None, expand: Optional[List[str]]=None) -> uipath.platform.entities.entities.EntityRecordsListResponse
+
+# Asynchronously list records from an entity with optional pagination and schema validation.
+sdk.entities.list_records_async(entity_key: str, schema: Optional[Type[Any]]=None, start: Optional[int]=None, limit: Optional[int]=None, expansion_level: Optional[int]=None, filter: Optional[str]=None, orderby: Optional[str]=None, select: Optional[List[str]]=None, expand: Optional[List[str]]=None) -> uipath.platform.entities.entities.EntityRecordsListResponse
+
+# Query entity records using a validated SQL query.
+sdk.entities.query_entity_records(sql_query: str) -> typing.List[typing.Dict[str, typing.Any]]
+
+# Asynchronously query entity records using a validated SQL query.
+sdk.entities.query_entity_records_async(sql_query: str) -> typing.List[typing.Dict[str, typing.Any]]
+
+# Resolve an agent entity set, applying resource overwrites.
+sdk.entities.resolve_entity_set(items: List[uipath.platform.entities.entities.DataFabricEntityItem]) -> uipath.platform.entities.entities.EntitySetResolution
+
+# Resolve an agent entity set, applying resource overwrites.
+sdk.entities.resolve_entity_set_async(items: List[uipath.platform.entities.entities.DataFabricEntityItem]) -> uipath.platform.entities.entities.EntitySetResolution
+
+# Retrieve an entity by its key.
+sdk.entities.retrieve(entity_key: str) -> uipath.platform.entities.entities.Entity
+
+# Asynchronously retrieve an entity by its key.
+sdk.entities.retrieve_async(entity_key: str) -> uipath.platform.entities.entities.Entity
+
+# Retrieve an entity by its name.
+sdk.entities.retrieve_by_name(entity_name: str, folder_key: Optional[str]=None) -> uipath.platform.entities.entities.Entity
+
+# Asynchronously retrieve an entity by its name.
+sdk.entities.retrieve_by_name_async(entity_name: str, folder_key: Optional[str]=None) -> uipath.platform.entities.entities.Entity
+
+# Retrieve records with structured filters, sorting, expansion, joins, and aggregates.
+sdk.entities.retrieve_records(entity_key: str, filter_group: Optional[uipath.platform.entities.entities.EntityQueryFilterGroup]=None, sort_options: Optional[List[uipath.platform.entities.entities.EntityQuerySortOption]]=None, selected_fields: Optional[List[str]]=None, expansions: Optional[List[Any]]=None, expansion_level: Optional[int]=None, aggregates: Optional[List[uipath.platform.entities.entities.EntityAggregate]]=None, group_by: Optional[List[str]]=None, joins: Optional[List[uipath.platform.entities.entities.EntityJoin]]=None, binnings: Optional[List[uipath.platform.entities.entities.EntityBinning]]=None, start: Optional[int]=None, limit: Optional[int]=None) -> uipath.platform.entities.entities.RetrieveEntityRecordsResponse
+
+# Asynchronously retrieve records with structured filters, sorting, expansion, joins, and aggregates.
+sdk.entities.retrieve_records_async(entity_key: str, filter_group: Optional[uipath.platform.entities.entities.EntityQueryFilterGroup]=None, sort_options: Optional[List[uipath.platform.entities.entities.EntityQuerySortOption]]=None, selected_fields: Optional[List[str]]=None, expansions: Optional[List[Any]]=None, expansion_level: Optional[int]=None, aggregates: Optional[List[uipath.platform.entities.entities.EntityAggregate]]=None, group_by: Optional[List[str]]=None, joins: Optional[List[uipath.platform.entities.entities.EntityJoin]]=None, binnings: Optional[List[uipath.platform.entities.entities.EntityBinning]]=None, start: Optional[int]=None, limit: Optional[int]=None) -> uipath.platform.entities.entities.RetrieveEntityRecordsResponse
+
+# Update an entity's display name, description, and/or RBAC flag.
+sdk.entities.update_entity_metadata(entity_id: str, metadata: Union[uipath.platform.entities.entities.EntityMetadataUpdateOptions, Dict[str, Any]]) -> None
+
+# Asynchronously update an entity's display name, description, and/or RBAC flag.
+sdk.entities.update_entity_metadata_async(entity_id: str, metadata: Union[uipath.platform.entities.entities.EntityMetadataUpdateOptions, Dict[str, Any]]) -> None
+
+# Update a single record by id and return the updated row.
+sdk.entities.update_record(entity_key: str, record_id: str, data: Any, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Asynchronously update a single record by id.
+sdk.entities.update_record_async(entity_key: str, record_id: str, data: Any, expansion_level: Optional[int]=None) -> uipath.platform.entities.entities.EntityRecord
+
+# Update multiple records in an entity in a single batch operation.
+sdk.entities.update_records(entity_key: str, records: List[Any], schema: Optional[Type[Any]]=None, expansion_level: Optional[int]=None, fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# Asynchronously update multiple records in an entity in a single batch operation.
+sdk.entities.update_records_async(entity_key: str, records: List[Any], schema: Optional[Type[Any]]=None, expansion_level: Optional[int]=None, fail_on_first: Optional[bool]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+# Upload a file attachment to a File-type field on a record.
+sdk.entities.upload_attachment(entity_id: str, record_id: str, field_name: str, file: Union[bytes, bytearray, memoryview, NoneType]=None, file_path: Optional[str]=None, expansion_level: Optional[int]=None) -> typing.Dict[str, typing.Any]
+
+# Asynchronously upload a file attachment to a File-type field on a record.
+sdk.entities.upload_attachment_async(entity_id: str, record_id: str, field_name: str, file: Union[bytes, bytearray, memoryview, NoneType]=None, file_path: Optional[str]=None, expansion_level: Optional[int]=None) -> typing.Dict[str, typing.Any]
+
+# Parse a batch response, optionally validating success records against ``schema``.
+sdk.entities.validate_entity_batch(batch_response: httpx.Response, schema: Optional[Type[Any]]=None) -> uipath.platform.entities.entities.EntityRecordsBatchResponse
+
+```
+
+### Folders
+
+Folders service
+
+```python
+# Retrieve the personal workspace folder for the current user.
+sdk.folders.get_personal_workspace() -> uipath.platform.orchestrator.folder.PersonalWorkspace
+
+# Asynchronously retrieve the personal workspace folder for the current user.
+sdk.folders.get_personal_workspace_async() -> uipath.platform.orchestrator.folder.PersonalWorkspace
+
+# Resolve a folder path to its corresponding folder key.
+sdk.folders.retrieve_folder_key(folder_path: str | None) -> str | None
+
+# Asynchronously resolve a folder path to its corresponding folder key.
+sdk.folders.retrieve_folder_key_async(folder_path: str | None) -> str | None
+
+# Retrieve the folder key by folder path with pagination support.
+sdk.folders.retrieve_key(folder_path: str) -> typing.Optional[str]
+
+# Retrieve the folder key by folder path with pagination support.
+sdk.folders.retrieve_key_async(folder_path: str) -> typing.Optional[str]
+
+```
+
+### Guardrails
+
+Guardrails service
+
+```python
+# Validate input text using the provided guardrail.
+sdk.guardrails.evaluate_guardrail(input_data: str | dict[str, Any], guardrail: uipath.platform.guardrails.guardrails.BuiltInValidatorGuardrail) -> uipath.core.guardrails.guardrails.GuardrailValidationResult
+
+```
+
+### Jobs
+
+Jobs service
+
+```python
+# Create and upload an attachment, optionally linking it to a job.
+sdk.jobs.create_attachment(name: str, content: Union[str, bytes, NoneType]=None, source_path: Union[str, pathlib.Path, NoneType]=None, job_key: Union[str, uuid.UUID, NoneType]=None, category: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
+
+# Create and upload an attachment asynchronously, optionally linking it to a job.
+sdk.jobs.create_attachment_async(name: str, content: Union[str, bytes, NoneType]=None, source_path: Union[str, pathlib.Path, NoneType]=None, job_key: Union[str, uuid.UUID, NoneType]=None, category: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
+
+# Check if job exists.
+sdk.jobs.exists(job_key: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Async version of exists().
+sdk.jobs.exists_async(job_key: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> bool
+
+# Get the actual output data, downloading from attachment if necessary.
+sdk.jobs.extract_output(job: uipath.platform.orchestrator.job.Job) -> typing.Optional[str]
+
+# Asynchronously fetch the actual output data, downloading from attachment if necessary.
+sdk.jobs.extract_output_async(job: uipath.platform.orchestrator.job.Job) -> typing.Optional[str]
+
+# Link an attachment to a job.
+sdk.jobs.link_attachment(attachment_key: uuid.UUID, job_key: uuid.UUID, category: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None)
+
+# Link an attachment to a job asynchronously.
+sdk.jobs.link_attachment_async(attachment_key: uuid.UUID, job_key: uuid.UUID, category: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None)
+
+# List jobs using OData API with offset-based pagination.
+sdk.jobs.list(folder_path: Optional[str]=None, folder_key: Optional[str]=None, filter: Optional[str]=None, orderby: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.job.Job]
+
+# Async version of list() with offset-based pagination.
+sdk.jobs.list_async(folder_path: Optional[str]=None, folder_key: Optional[str]=None, filter: Optional[str]=None, orderby: Optional[str]=None, skip: int=0, top: int=100) -> uipath.platform.common.paging.PagedResult[uipath.platform.orchestrator.job.Job]
+
+# List attachments associated with a specific job.
+sdk.jobs.list_attachments(job_key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[str]
+
+# List attachments associated with a specific job asynchronously.
+sdk.jobs.list_attachments_async(job_key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> typing.List[str]
+
+# Restart a completed or failed job.
+sdk.jobs.restart(job_key: str, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> uipath.platform.orchestrator.job.Job
+
+# Async version of restart().
+sdk.jobs.restart_async(job_key: str, folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> uipath.platform.orchestrator.job.Job
+
+# Sends a payload to resume a paused job waiting for input, identified by its inbox ID.
+sdk.jobs.resume(inbox_id: Optional[str]=None, job_id: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, payload: Any) -> None
+
+# Asynchronously sends a payload to resume a paused job waiting for input, identified by its inbox ID.
+sdk.jobs.resume_async(inbox_id: Optional[str]=None, job_id: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, payload: Any) -> None
+
+# Retrieve a job identified by its key.
+sdk.jobs.retrieve(job_key: str, folder_key: str | None=None, folder_path: str | None=None, process_name: str | None=None) -> uipath.platform.orchestrator.job.Job
+
+# Fetch payload data for API triggers.
+sdk.jobs.retrieve_api_payload(inbox_id: str) -> typing.Any
+
+# Asynchronously fetch payload data for API triggers.
+sdk.jobs.retrieve_api_payload_async(inbox_id: str) -> typing.Any
+
+# Asynchronously retrieve a job identified by its key.
+sdk.jobs.retrieve_async(job_key: str, folder_key: str | None=None, folder_path: str | None=None, process_name: str | None=None) -> uipath.platform.orchestrator.job.Job
+
+# Fetch payload data for Integration Services (Inbox) triggers.
+sdk.jobs.retrieve_inbox_payload(inbox_id: str) -> typing.Any
+
+# Asynchronously fetch payload data for Integration Services (Inbox) triggers.
+sdk.jobs.retrieve_inbox_payload_async(inbox_id: str) -> typing.Any
+
+# Stop one or more jobs with specified strategy.
+sdk.jobs.stop(job_keys: List[str], strategy: str="SoftStop", folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> None
+
+# Async version of stop().
+sdk.jobs.stop_async(job_keys: List[str], strategy: str="SoftStop", folder_path: Optional[str]=None, folder_key: Optional[str]=None) -> None
+
+```
+
+### Llm
+
+Llm service
+
+```python
+# Generate chat completions using UiPath's normalized LLM Gateway API.
+sdk.llm.chat_completions(messages: list[dict[str, str]] | list[tuple[str, str]], model: str="gpt-4.1-mini-2025-04-14", max_tokens: int=4096, temperature: float=0, n: int=1, frequency_penalty: float=0, presence_penalty: float=0, top_p: float | None=1, top_k: int | None=None, tools: list[uipath.platform.chat.llm_gateway.ToolDefinition | dict[str, Any]] | None=None, tool_choice: Union[uipath.platform.chat.llm_gateway.AutoToolChoice, uipath.platform.chat.llm_gateway.RequiredToolChoice, uipath.platform.chat.llm_gateway.SpecificToolChoice, Literal['auto', 'none'], NoneType]=None, response_format: dict[str, Any] | type[pydantic.main.BaseModel] | None=None, api_version: str="2024-08-01-preview")
+
+```
+
+### Llm Openai
+
+Llm Openai service
+
+```python
+# Generate chat completions using UiPath's LLM Gateway service.
+sdk.llm_openai.chat_completions(messages: list[dict[str, str]], model: str="gpt-4.1-mini-2025-04-14", max_tokens: int=4096, temperature: float=0, response_format: dict[str, Any] | type[pydantic.main.BaseModel] | None=None, api_version: str="2024-10-21")
+
+# Generate text embeddings using UiPath's LLM Gateway service.
+sdk.llm_openai.embeddings(input: str, embedding_model: str="text-embedding-ada-002", openai_api_version: str="2024-10-21")
+
+```
+
+### Mcp
+
+Mcp service
+
+```python
+# List all MCP servers.
+sdk.mcp.list(folder_path: str | None=None) -> typing.List[uipath.platform.orchestrator.mcp.McpServer]
+
+# Asynchronously list all MCP servers.
+sdk.mcp.list_async(folder_path: str | None=None) -> typing.List[uipath.platform.orchestrator.mcp.McpServer]
+
+# Retrieve a specific MCP server by its slug.
+sdk.mcp.retrieve(slug: str, folder_path: str | None=None) -> uipath.platform.orchestrator.mcp.McpServer
+
+# Asynchronously retrieve a specific MCP server by its slug.
+sdk.mcp.retrieve_async(slug: str, folder_path: str | None=None) -> uipath.platform.orchestrator.mcp.McpServer
+
+```
+
+### Memory
+
+Memory service
+
+```python
+# Create a new memory space.
+sdk.memory.create(name: str, description: Optional[str]=None, is_encrypted: Optional[bool]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySpace
+
+# Asynchronously create a new memory space.
+sdk.memory.create_async(name: str, description: Optional[str]=None, is_encrypted: Optional[bool]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySpace
+
+# Ingest a resolved escalation outcome into memory.
+sdk.memory.escalation_ingest(memory_space_id: str, request: uipath.platform.memory.memory.EscalationMemoryIngestRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Asynchronously ingest a resolved escalation outcome into memory.
+sdk.memory.escalation_ingest_async(memory_space_id: str, request: uipath.platform.memory.memory.EscalationMemoryIngestRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
+
+# Search escalation memory for previously resolved outcomes.
+sdk.memory.escalation_search(memory_space_id: str, request: uipath.platform.memory.memory.MemorySearchRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.EscalationMemorySearchResponse
+
+# Asynchronously search escalation memory for previously resolved outcomes.
+sdk.memory.escalation_search_async(memory_space_id: str, request: uipath.platform.memory.memory.MemorySearchRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.EscalationMemorySearchResponse
+
+# List memory spaces with optional OData query parameters.
+sdk.memory.list(filter: Optional[str]=None, orderby: Optional[str]=None, top: Optional[int]=None, skip: Optional[int]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySpaceListResponse
+
+# Asynchronously list memory spaces.
+sdk.memory.list_async(filter: Optional[str]=None, orderby: Optional[str]=None, top: Optional[int]=None, skip: Optional[int]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySpaceListResponse
+
+# Search a memory space via LLMOps.
+sdk.memory.search(memory_space_id: str, request: uipath.platform.memory.memory.MemorySearchRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySearchResponse
+
+# Asynchronously search a memory space via LLMOps.
+sdk.memory.search_async(memory_space_id: str, request: uipath.platform.memory.memory.MemorySearchRequest, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.platform.memory.memory.MemorySearchResponse
+
+```
+
+### Orchestrator Setup
+
+Orchestrator Setup service
+
+```python
+# Fire-and-forget POST requests to enable first run for StudioWeb.
+sdk.orchestrator_setup.enable_first_run() -> None
+
+# Fire-and-forget POST requests to enable first run for StudioWeb.
+sdk.orchestrator_setup.enable_first_run_async() -> None
+
+```
+
+### Pii Detection
+
+Pii Detection service
+
+```python
+# Detect PII in the provided documents and/or files.
+sdk.pii_detection.detect_pii(request: uipath.platform.pii_detection.pii_detection.PiiDetectionRequest) -> uipath.platform.pii_detection.pii_detection.PiiDetectionResponse
+
+# Detect PII in the provided documents and/or files (async).
+sdk.pii_detection.detect_pii_async(request: uipath.platform.pii_detection.pii_detection.PiiDetectionRequest) -> uipath.platform.pii_detection.pii_detection.PiiDetectionResponse
+
+```
+
+### Processes
+
+Processes service
+
+```python
+# Start execution of a process by its name.
+sdk.processes.invoke(name: str, input_arguments: Optional[Dict[str, Any]]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, attachments: Optional[list[uipath.platform.attachments.attachments.Attachment]]=None, parent_operation_id: Optional[str]=None, run_as_me: Optional[bool]=None, **kwargs) -> uipath.platform.orchestrator.job.Job
+
+# Asynchronously start execution of a process by its name.
+sdk.processes.invoke_async(name: str, input_arguments: Optional[Dict[str, Any]]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None, attachments: Optional[list[uipath.platform.attachments.attachments.Attachment]]=None, parent_operation_id: Optional[str]=None, run_as_me: Optional[bool]=None, **kwargs) -> uipath.platform.orchestrator.job.Job
+
+```
+
+### Queues
+
+Queues service
+
+```python
+# Completes a transaction item with the specified result.
+sdk.queues.complete_transaction_item(transaction_key: str, result: Union[Dict[str, Any], uipath.platform.orchestrator.queues.TransactionItemResult], queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously completes a transaction item with the specified result.
+sdk.queues.complete_transaction_item_async(transaction_key: str, result: Union[Dict[str, Any], uipath.platform.orchestrator.queues.TransactionItemResult], queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Creates a new queue item in the Orchestrator.
+sdk.queues.create_item(item: Union[Dict[str, Any], uipath.platform.orchestrator.queues.QueueItem], queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously creates a new queue item in the Orchestrator.
+sdk.queues.create_item_async(item: Union[Dict[str, Any], uipath.platform.orchestrator.queues.QueueItem], queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Creates multiple queue items in bulk.
+sdk.queues.create_items(items: List[Union[Dict[str, Any], uipath.platform.orchestrator.queues.QueueItem]], queue_name: str, commit_type: <enum 'CommitType, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously creates multiple queue items in bulk.
+sdk.queues.create_items_async(items: List[Union[Dict[str, Any], uipath.platform.orchestrator.queues.QueueItem]], queue_name: str, commit_type: <enum 'CommitType, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Creates a new transaction item in a queue.
+sdk.queues.create_transaction_item(item: Union[Dict[str, Any], uipath.platform.orchestrator.queues.TransactionItem], queue_name: Optional[str]=None, no_robot: bool=False, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously creates a new transaction item in a queue.
+sdk.queues.create_transaction_item_async(item: Union[Dict[str, Any], uipath.platform.orchestrator.queues.TransactionItem], queue_name: Optional[str]=None, no_robot: bool=False, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Retrieves a list of queue items from the Orchestrator.
+sdk.queues.list_items(queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously retrieves a list of queue items from the Orchestrator.
+sdk.queues.list_items_async(queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Updates the progress of a transaction item.
+sdk.queues.update_progress_of_transaction_item(transaction_key: str, progress: str, queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+# Asynchronously updates the progress of a transaction item.
+sdk.queues.update_progress_of_transaction_item_async(transaction_key: str, progress: str, queue_name: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> httpx.Response
+
+```
+
+### Remote A2A
+
+Remote A2A service
+
+```python
+# List Remote A2A agents.
+sdk.remote_a2a.list(top: int | None=None, skip: int | None=None, search: str | None=None, folder_path: str | None=None) -> typing.List[uipath.platform.agenthub.remote_a2a.RemoteA2aAgent]
+
+# Asynchronously list Remote A2A agents.
+sdk.remote_a2a.list_async(top: int | None=None, skip: int | None=None, search: str | None=None, folder_path: str | None=None) -> typing.List[uipath.platform.agenthub.remote_a2a.RemoteA2aAgent]
+
+# Retrieve a specific Remote A2A agent by slug.
+sdk.remote_a2a.retrieve(slug: str, folder_path: str | None=None) -> uipath.platform.agenthub.remote_a2a.RemoteA2aAgent
+
+# Asynchronously retrieve a specific Remote A2A agent by slug.
+sdk.remote_a2a.retrieve_async(slug: str, folder_path: str | None=None) -> uipath.platform.agenthub.remote_a2a.RemoteA2aAgent
+
+```
+
+### Resource Catalog
+
+Resource Catalog service
+
+```python
+# Get tenant scoped resources and folder scoped resources (accessible to the user).
+sdk.resource_catalog.list(resource_types: Optional[List[uipath.platform.resource_catalog.resource_catalog.ResourceType]]=None, resource_sub_types: Optional[List[str]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, page_size: int=20) -> typing.Iterator[uipath.platform.resource_catalog.resource_catalog.Resource]
+
+# Asynchronously get tenant scoped resources and folder scoped resources (accessible to the user).
+sdk.resource_catalog.list_async(resource_types: Optional[List[uipath.platform.resource_catalog.resource_catalog.ResourceType]]=None, resource_sub_types: Optional[List[str]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, page_size: int=20) -> typing.AsyncGenerator[uipath.platform.resource_catalog.resource_catalog.Resource, NoneType]
+
+# Get resources of a specific type (tenant scoped or folder scoped).
+sdk.resource_catalog.list_by_type(resource_type: <enum 'ResourceType, name: Optional[str]=None, resource_sub_types: Optional[List[str]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, page_size: int=20) -> typing.Iterator[uipath.platform.resource_catalog.resource_catalog.Resource]
+
+# Asynchronously get resources of a specific type (tenant scoped or folder scoped).
+sdk.resource_catalog.list_by_type_async(resource_type: <enum 'ResourceType, name: Optional[str]=None, resource_sub_types: Optional[List[str]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, page_size: int=20) -> typing.AsyncGenerator[uipath.platform.resource_catalog.resource_catalog.Resource, NoneType]
+
+# Search for tenant scoped resources and folder scoped resources (accessible to the user).
+sdk.resource_catalog.search(name: Optional[str]=None, resource_types: Optional[List[uipath.platform.resource_catalog.resource_catalog.ResourceType]]=None, resource_sub_types: Optional[List[str]]=None, page_size: int=20) -> typing.Iterator[uipath.platform.resource_catalog.resource_catalog.Resource]
+
+# Asynchronously search for tenant scoped resources and folder scoped resources (accessible to the user).
+sdk.resource_catalog.search_async(name: Optional[str]=None, resource_types: Optional[List[uipath.platform.resource_catalog.resource_catalog.ResourceType]]=None, resource_sub_types: Optional[List[str]]=None, page_size: int=20) -> typing.AsyncGenerator[uipath.platform.resource_catalog.resource_catalog.Resource, NoneType]
+
+```
+
+### Semantic Proxy
+
+Semantic Proxy service
+
+```python
+# Detect PII in the provided documents and/or files.
+sdk.semantic_proxy.detect_pii(request: uipath.platform.semantic_proxy.semantic_proxy.PiiDetectionRequest) -> uipath.platform.semantic_proxy.semantic_proxy.PiiDetectionResponse
+
+# Detect PII in the provided documents and/or files (async).
+sdk.semantic_proxy.detect_pii_async(request: uipath.platform.semantic_proxy.semantic_proxy.PiiDetectionRequest) -> uipath.platform.semantic_proxy.semantic_proxy.PiiDetectionResponse
+
+```
+
+### Tasks
+
+Tasks service
+
+```python
+# Creates a new task synchronously.
+sdk.tasks.create(title: str, data: Optional[Dict[str, Any]]=None, app_name: Optional[str]=None, app_key: Optional[str]=None, app_folder_path: Optional[str]=None, app_folder_key: Optional[str]=None, assignee: Optional[str]=None, recipient: Optional[uipath.platform.action_center.tasks.TaskRecipient]=None, priority: Optional[str]=None, labels: Optional[List[str]]=None, is_actionable_message_enabled: Optional[bool]=None, actionable_message_metadata: Optional[Dict[str, Any]]=None, source_name: str="Agent") -> uipath.platform.action_center.tasks.Task
+
+# Creates a new action asynchronously.
+sdk.tasks.create_async(title: str, data: Optional[Dict[str, Any]]=None, app_name: Optional[str]=None, app_key: Optional[str]=None, app_folder_path: Optional[str]=None, app_folder_key: Optional[str]=None, assignee: Optional[str]=None, recipient: Optional[uipath.platform.action_center.tasks.TaskRecipient]=None, priority: Optional[str]=None, labels: Optional[List[str]]=None, is_actionable_message_enabled: Optional[bool]=None, actionable_message_metadata: Optional[Dict[str, Any]]=None, source_name: str="Agent") -> uipath.platform.action_center.tasks.Task
+
+# Create a new QuickForm task synchronously.
+sdk.tasks.create_quickform(title: str, task_schema_key: str, schema: Dict[str, Any], data: Optional[Dict[str, Any]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, assignee: Optional[str]=None, recipient: Optional[uipath.platform.action_center.tasks.TaskRecipient]=None, priority: Optional[str]=None, labels: Optional[List[str]]=None, is_actionable_message_enabled: Optional[bool]=None, actionable_message_metadata: Optional[Dict[str, Any]]=None, creator_job_key: Optional[str]=None, source_name: str="Agent") -> uipath.platform.action_center.tasks.Task
+
+# Creates a new QuickForm task asynchronously.
+sdk.tasks.create_quickform_async(title: str, task_schema_key: str, schema: Dict[str, Any], data: Optional[Dict[str, Any]]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, assignee: Optional[str]=None, recipient: Optional[uipath.platform.action_center.tasks.TaskRecipient]=None, priority: Optional[str]=None, labels: Optional[List[str]]=None, is_actionable_message_enabled: Optional[bool]=None, actionable_message_metadata: Optional[Dict[str, Any]]=None, creator_job_key: Optional[str]=None, source_name: str="Agent") -> uipath.platform.action_center.tasks.Task
+
+# Retrieves a task by its key synchronously.
+sdk.tasks.retrieve(action_key: str, app_folder_path: Optional[str]=None, app_folder_key: Optional[str]=None, app_name: str | None=None) -> uipath.platform.action_center.tasks.Task
+
+# Retrieves a task by its key asynchronously.
+sdk.tasks.retrieve_async(action_key: str, app_folder_path: Optional[str]=None, app_folder_key: Optional[str]=None, app_name: str | None=None) -> uipath.platform.action_center.tasks.Task
+
+```
+
diff --git a/packages/uipath/src/uipath/_resources/eval.md b/packages/uipath/src/uipath/_resources/eval.md
new file mode 100644
index 000000000..15fa04f7c
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/eval.md
@@ -0,0 +1,287 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create and run agent evaluations
+---
+
+I'll help you create and run evaluations for your UiPath agent.
+
+## Step 1: Check project setup
+
+Let me check your project structure:
+
+!ls -la evaluations/ entry-points.json 2>/dev/null || echo "NEEDS_SETUP"
+
+# Check if schemas might be stale (main.py newer than entry-points.json)
+!if [ -f main.py ] && [ -f entry-points.json ] && [ main.py -nt entry-points.json ]; then echo "SCHEMAS_MAY_BE_STALE"; fi
+
+### If NEEDS_SETUP
+
+If `entry-points.json` doesn't exist, initialize the project first:
+
+!uv run uipath init
+
+Then re-run this skill.
+
+### If SCHEMAS_MAY_BE_STALE
+
+Your `main.py` is newer than `entry-points.json`. Refresh schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 2: What would you like to do?
+
+1. **Create new eval set** - Set up evaluations from scratch
+2. **Add test case** - Add a test to existing eval set
+3. **Run evaluations** - Execute tests and see results
+4. **Analyze failures** - Debug failing tests
+
+---
+
+## Creating an Eval Set
+
+First, create the directory structure:
+
+!mkdir -p evaluations/eval-sets evaluations/evaluators
+
+Read the agent's Input/Output schema from entry-points.json to understand the data types.
+
+### Evaluator Selection Guide
+
+| If your output is... | Use this evaluator | evaluatorTypeId |
+|---------------------|-------------------|-----------------|
+| Exact string/number | `ExactMatchEvaluator` | `uipath-exact-match` |
+| Contains key phrases | `ContainsEvaluator` | `uipath-contains` |
+| Semantically correct | `LLMJudgeOutputEvaluator` | `uipath-llm-judge-output-semantic-similarity` |
+| JSON with numbers | `JsonSimilarityEvaluator` | `uipath-json-similarity` |
+
+### Step 1: Create Evaluator Config Files
+
+**Each evaluator needs a JSON config file** in `evaluations/evaluators/`.
+
+**ExactMatchEvaluator** (`evaluations/evaluators/exact-match.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ExactMatchEvaluator",
+  "name": "ExactMatchEvaluator",
+  "description": "Checks for exact output match",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ExactMatchEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**LLMJudgeOutputEvaluator** (`evaluations/evaluators/llm-judge-output.json`):
+```json
+{
+  "version": "1.0",
+  "id": "LLMJudgeOutputEvaluator",
+  "name": "LLMJudgeOutputEvaluator",
+  "description": "Uses LLM to judge semantic similarity",
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfig": {
+    "name": "LLMJudgeOutputEvaluator",
+    "model": "gpt-4o-mini-2024-07-18"
+  }
+}
+```
+
+**JsonSimilarityEvaluator** (`evaluations/evaluators/json-similarity.json`):
+```json
+{
+  "version": "1.0",
+  "id": "JsonSimilarityEvaluator",
+  "name": "JsonSimilarityEvaluator",
+  "description": "Compares JSON structures",
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfig": {
+    "name": "JsonSimilarityEvaluator",
+    "targetOutputKey": "*"
+  }
+}
+```
+
+**ContainsEvaluator** (`evaluations/evaluators/contains.json`):
+```json
+{
+  "version": "1.0",
+  "id": "ContainsEvaluator",
+  "name": "ContainsEvaluator",
+  "description": "Checks if output contains text",
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfig": {
+    "name": "ContainsEvaluator"
+  }
+}
+```
+
+### Step 2: Create Eval Set
+
+**Eval Set Template** (`evaluations/eval-sets/default.json`):
+```json
+{
+  "version": "1.0",
+  "id": "default-eval-set",
+  "name": "Default Evaluation Set",
+  "evaluatorRefs": ["ExactMatchEvaluator"],
+  "evaluations": [
+    {
+      "id": "test-1",
+      "name": "Test description",
+      "inputs": {
+        "field": "value"
+      },
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "result": "expected value"
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+**Important notes:**
+- `evaluatorRefs` must list ALL evaluators used in any test case
+- Each evaluator in `evaluatorRefs` needs a matching JSON config in `evaluations/evaluators/`
+- `evaluationCriterias` keys must match entries in `evaluatorRefs`
+- Use `expectedOutput` for most evaluators
+- LLM evaluators need `model` in their config. Available models are defined in the SDK's `ChatModels` class (`uipath.platform.chat.ChatModels`):
+  - `gpt-4o-mini-2024-07-18` (recommended for cost-efficiency)
+  - `gpt-4o-2024-08-06` (higher quality, higher cost)
+  - `o3-mini-2025-01-31` (latest reasoning model)
+  - Model availability varies by region and tenant configuration
+  - Check your UiPath Automation Cloud portal under AI Trust Layer for available models in your region
+
+---
+
+## Adding a Test Case
+
+When adding a test to an existing eval set:
+
+1. Read the existing eval set
+2. Check which evaluators are in `evaluatorRefs`
+3. Add the new test to `evaluations` array
+4. If using a new evaluator, add it to `evaluatorRefs`
+
+### Test Case Template
+
+```json
+{
+  "id": "test-{n}",
+  "name": "Description of what this tests",
+  "inputs": { },
+  "evaluationCriterias": {
+    "EvaluatorName": {
+      "expectedOutput": { }
+    }
+  }
+}
+```
+
+---
+
+## Running Evaluations
+
+First, read entry-points.json to get the entrypoint name (e.g., `main`):
+
+!uv run uipath eval main evaluations/eval-sets/default.json --output-file eval-results.json
+
+**Note:** Replace `main` with your actual entrypoint from entry-points.json.
+
+### Analyze Results
+
+After running, read `eval-results.json` and show:
+- Pass/fail summary table
+- For failures: expected vs actual output
+- Suggestions for fixing or changing evaluators
+
+### Results Format
+
+```json
+{
+  "evaluationSetResults": [{
+    "evaluationRunResults": [
+      {
+        "evaluationId": "test-1",
+        "evaluatorId": "ExactMatchEvaluator",
+        "result": { "score": 1.0 },
+        "errorMessage": null
+      }
+    ]
+  }]
+}
+```
+
+- Score 1.0 = PASS
+- Score < 1.0 = FAIL (show expected vs actual)
+- errorMessage present = ERROR (show message)
+
+---
+
+## Evaluator Reference
+
+### Deterministic Evaluators
+
+**ExactMatchEvaluator** - Exact output matching
+```json
+"ExactMatchEvaluator": {
+  "expectedOutput": { "result": "exact value" }
+}
+```
+
+**ContainsEvaluator** - Output contains substring
+```json
+"ContainsEvaluator": {
+  "searchText": "must contain this"
+}
+```
+
+**JsonSimilarityEvaluator** - JSON comparison with tolerance
+```json
+"JsonSimilarityEvaluator": {
+  "expectedOutput": { "value": 10.0 }
+}
+```
+
+### LLM-Based Evaluators
+
+**LLMJudgeOutputEvaluator** - Semantic correctness
+```json
+"LLMJudgeOutputEvaluator": {
+  "expectedOutput": { "summary": "Expected semantic meaning" }
+}
+```
+
+**LLMJudgeTrajectoryEvaluator** - Validate agent reasoning
+```json
+"LLMJudgeTrajectoryEvaluator": {
+  "expectedAgentBehavior": "The agent should first fetch data, then process it"
+}
+```
+
+---
+
+## Common Issues
+
+### "No evaluations found"
+- Check `evaluations/eval-sets/` directory exists
+- Verify JSON file is valid
+
+### Evaluator not found
+- Each evaluator needs a JSON config file in `evaluations/evaluators/`
+- Config file must have correct `evaluatorTypeId` (see templates above)
+- Config file must have `name` field at root level
+- LLM evaluators need `model` in `evaluatorConfig`
+
+### Evaluator skipped
+- Ensure evaluator is listed in root `evaluatorRefs` array
+- Check evaluator config file exists in `evaluations/evaluators/`
+
+### Schema mismatch
+- Run `uv run uipath init --no-agents-md-override` to refresh schemas
+- Check `entry-points.json` matches your Input/Output models
diff --git a/packages/uipath/src/uipath/_resources/new-agent.md b/packages/uipath/src/uipath/_resources/new-agent.md
new file mode 100644
index 000000000..b1d051866
--- /dev/null
+++ b/packages/uipath/src/uipath/_resources/new-agent.md
@@ -0,0 +1,103 @@
+---
+allowed-tools: Bash, Read, Write, Edit, Glob
+description: Create a new UiPath coded agent from a description
+---
+
+I'll help you create a new UiPath coded agent.
+
+## Step 1: Check existing project
+
+Let me check if this is an existing UiPath project:
+
+!ls uipath.json main.py 2>/dev/null || echo "NEW_PROJECT"
+
+## Step 2: Gather requirements
+
+**What should this agent do?**
+
+Please describe:
+
+-   What inputs it needs (e.g., "a file path and bucket name")
+-   What it should accomplish (e.g., "process CSV data")
+-   What outputs it should return (e.g., "total count and status")
+
+I'll generate the agent structure based on your description.
+
+## Step 3: Generate agent
+
+After you describe the agent, I will:
+
+1. Create `main.py` with Input/Output Pydantic models and `async def main()`
+2. Add entrypoint to `uipath.json` under `"functions": {"agent_name": "main.py:main"}`
+3. Run `uv run uipath init --no-agents-md-override` to generate schemas
+
+**Template structure** (from .agent/REQUIRED_STRUCTURE.md):
+
+```python
+from pydantic import BaseModel
+from uipath.platform import UiPath
+
+class Input(BaseModel):
+    """Input fields for the agent."""
+    # Fields based on your description
+    pass
+
+
+class Output(BaseModel):
+    """Output fields returned by the agent."""
+    # Fields based on your description
+    pass
+
+
+async def main(input: Input) -> Output:
+    """Main entry point for the agent.
+
+    Args:
+        input: The input data for the agent.
+
+    Returns:
+        The output data from the agent.
+    """
+
+    uipath = UiPath()
+
+    # TODO: Implement agent logic
+    return Output()
+```
+
+**Important notes:**
+
+-   Use `async def main` - many SDK methods are async
+-   Initialize `UiPath()` inside the function, not at module level
+-   After creating main.py, add entrypoint to `uipath.json` under `"functions"`
+
+## Step 4: Update entry-point schemas
+
+After creating main.py, regenerate the schemas:
+
+!uv run uipath init --no-agents-md-override
+
+## Step 5: Verify
+
+Quick test to verify the setup:
+
+!uv run uipath run main '{}' 2>&1 | head -30
+
+## Summary
+
+Once complete, you'll have:
+
+| File                | Purpose                             |
+| ------------------- | ----------------------------------- |
+| `main.py`           | Agent code with Input/Output models |
+| `uipath.json`       | Project configuration               |
+| `entry-points.json` | Entry point schemas                 |
+| `bindings.json`     | Resource bindings                   |
+| `.agent/`           | SDK and CLI reference docs          |
+
+**Next steps:**
+
+1. Implement your logic in `main()`
+2. Test: `uv run uipath run main '{"field": "value"}'`
+3. Create `eval_set.json` for evaluations
+4. Evaluate: `uv run uipath eval`
diff --git a/src/uipath/_utils/__init__.py b/packages/uipath/src/uipath/_utils/__init__.py
similarity index 70%
rename from src/uipath/_utils/__init__.py
rename to packages/uipath/src/uipath/_utils/__init__.py
index 443cdb8da..3dba85eeb 100644
--- a/src/uipath/_utils/__init__.py
+++ b/packages/uipath/src/uipath/_utils/__init__.py
@@ -1,19 +1,21 @@
+from uipath.platform.common import resource_override
+
 from ._endpoint import Endpoint
-from ._infer_bindings import get_inferred_bindings_names, infer_bindings
 from ._logs import setup_logging
 from ._request_override import header_folder
 from ._request_spec import RequestSpec
 from ._url import UiPathUrl
 from ._user_agent import header_user_agent, user_agent_value
+from .validation import validate_pagination_params
 
 __all__ = [
     "Endpoint",
     "setup_logging",
     "RequestSpec",
     "header_folder",
-    "get_inferred_bindings_names",
-    "infer_bindings",
+    "resource_override",
     "header_user_agent",
     "user_agent_value",
     "UiPathUrl",
+    "validate_pagination_params",
 ]
diff --git a/src/uipath/_cli/_auth/_utils.py b/packages/uipath/src/uipath/_utils/_auth.py
similarity index 51%
rename from src/uipath/_cli/_auth/_utils.py
rename to packages/uipath/src/uipath/_utils/_auth.py
index b29c0749b..6f83fd0a2 100644
--- a/src/uipath/_cli/_auth/_utils.py
+++ b/packages/uipath/src/uipath/_utils/_auth.py
@@ -1,27 +1,17 @@
 import base64
 import json
-import os
+from os import environ as env
 from pathlib import Path
 from typing import Optional
 
-from ._models import AccessTokenData, TokenData
+from .constants import (
+    ENV_BASE_URL,
+    ENV_UIPATH_ACCESS_TOKEN,
+    ENV_UNATTENDED_USER_ACCESS_TOKEN,
+)
 
 
-def update_auth_file(token_data: TokenData):
-    os.makedirs(Path.cwd() / ".uipath", exist_ok=True)
-    auth_file = Path.cwd() / ".uipath" / ".auth.json"
-    with open(auth_file, "w") as f:
-        json.dump(token_data, f)
-
-
-def get_auth_data() -> TokenData:
-    auth_file = Path.cwd() / ".uipath" / ".auth.json"
-    if not auth_file.exists():
-        raise Exception("No authentication file found")
-    return json.load(open(auth_file))
-
-
-def parse_access_token(access_token: str) -> AccessTokenData:
+def parse_access_token(access_token: str):
     token_parts = access_token.split(".")
     if len(token_parts) < 2:
         raise Exception("Invalid access token")
@@ -31,12 +21,6 @@ def parse_access_token(access_token: str) -> AccessTokenData:
     return json.loads(payload)
 
 
-def get_parsed_token_data(token_data: Optional[TokenData] = None) -> AccessTokenData:
-    if not token_data:
-        token_data = get_auth_data()
-    return parse_access_token(token_data["access_token"])
-
-
 def update_env_file(env_contents):
     env_path = Path.cwd() / ".env"
     if env_path.exists():
@@ -49,3 +33,17 @@ def update_env_file(env_contents):
     lines = [f"{key}={value}\n" for key, value in env_contents.items()]
     with open(env_path, "w") as f:
         f.writelines(lines)
+
+
+def resolve_config_from_env(
+    base_url: Optional[str],
+    secret: Optional[str],
+):
+    """Simple config resolution from environment variables."""
+    base_url_value = base_url or env.get(ENV_BASE_URL)
+    secret_value = (
+        secret
+        or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
+        or env.get(ENV_UIPATH_ACCESS_TOKEN)
+    )
+    return base_url_value, secret_value
diff --git a/src/uipath/_utils/_endpoint.py b/packages/uipath/src/uipath/_utils/_endpoint.py
similarity index 100%
rename from src/uipath/_utils/_endpoint.py
rename to packages/uipath/src/uipath/_utils/_endpoint.py
diff --git a/packages/uipath/src/uipath/_utils/_logs.py b/packages/uipath/src/uipath/_utils/_logs.py
new file mode 100644
index 000000000..dbc5ef084
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/_logs.py
@@ -0,0 +1,21 @@
+import logging
+from typing import Optional
+
+logger: logging.Logger = logging.getLogger("uipath")
+
+
+def setup_logging(should_debug: Optional[bool] = None) -> None:
+    """Configure logging for the CLI."""
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(
+            logging.Formatter(
+                fmt="%(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+        )
+        logger.addHandler(handler)
+        logger.setLevel(logging.DEBUG if should_debug else logging.INFO)
+
+        # Prevent propagation to root logger to avoid duplicate logs
+        logger.propagate = False
diff --git a/packages/uipath/src/uipath/_utils/_request_override.py b/packages/uipath/src/uipath/_utils/_request_override.py
new file mode 100644
index 000000000..07d5e2ebc
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/_request_override.py
@@ -0,0 +1,34 @@
+from base64 import b64encode
+from typing import Optional
+
+from .constants import HEADER_FOLDER_KEY, HEADER_FOLDER_PATH, HEADER_FOLDER_PATH_ENCODED
+
+
+def folder_path_header(folder_path: str) -> dict[str, str]:
+    """Return the appropriate folder path header.
+
+    Uses the encoded header variant when the path contains non-ASCII
+    characters, since HTTP headers require ASCII values. The Orchestrator
+    expects Base64(UTF-16LE) in the encoded header.
+    """
+    try:
+        folder_path.encode("ascii")
+        return {HEADER_FOLDER_PATH: folder_path}
+    except UnicodeEncodeError:
+        encoded = b64encode(folder_path.encode("utf-16-le")).decode("ascii")
+        return {HEADER_FOLDER_PATH_ENCODED: encoded}
+
+
+def header_folder(
+    folder_key: Optional[str], folder_path: Optional[str]
+) -> dict[str, str]:
+    if folder_key is not None and folder_path is not None:
+        raise ValueError("Only one of folder_key or folder_path can be provided")
+
+    headers = {}
+    if folder_key is not None and folder_key != "":
+        headers[HEADER_FOLDER_KEY] = folder_key
+    if folder_path is not None and folder_path != "":
+        headers.update(folder_path_header(folder_path))
+
+    return headers
diff --git a/src/uipath/_utils/_request_spec.py b/packages/uipath/src/uipath/_utils/_request_spec.py
similarity index 94%
rename from src/uipath/_utils/_request_spec.py
rename to packages/uipath/src/uipath/_utils/_request_spec.py
index 43959dfe3..90353ccb4 100644
--- a/src/uipath/_utils/_request_spec.py
+++ b/packages/uipath/src/uipath/_utils/_request_spec.py
@@ -20,4 +20,5 @@ class RequestSpec:
     content: Optional[Any] = None
     json: Optional[Any] = None
     data: Optional[Any] = None
+    files: Optional[dict[str, Any]] = None
     timeout: Optional[Union[int, float]] = None
diff --git a/src/uipath/_utils/_ssl_context.py b/packages/uipath/src/uipath/_utils/_ssl_context.py
similarity index 55%
rename from src/uipath/_utils/_ssl_context.py
rename to packages/uipath/src/uipath/_utils/_ssl_context.py
index 7e6dc692b..66df6712d 100644
--- a/src/uipath/_utils/_ssl_context.py
+++ b/packages/uipath/src/uipath/_utils/_ssl_context.py
@@ -1,6 +1,7 @@
 import os
 import ssl
-from typing import Any, Dict
+
+from uipath.platform.common import get_httpx_client_kwargs
 
 
 def expand_path(path):
@@ -34,21 +35,4 @@ def create_ssl_context():
         )
 
 
-def get_httpx_client_kwargs() -> Dict[str, Any]:
-    """Get standardized httpx client configuration."""
-    client_kwargs: Dict[str, Any] = {"follow_redirects": True, "timeout": 30.0}
-
-    # Check environment variable to disable SSL verification
-    disable_ssl_env = os.environ.get("UIPATH_DISABLE_SSL_VERIFY", "").lower()
-    disable_ssl_from_env = disable_ssl_env in ("1", "true", "yes", "on")
-
-    if disable_ssl_from_env:
-        client_kwargs["verify"] = False
-    else:
-        # Use system certificates with truststore fallback
-        client_kwargs["verify"] = create_ssl_context()
-
-    # Auto-detect proxy from environment variables (httpx handles this automatically)
-    # HTTP_PROXY, HTTPS_PROXY, NO_PROXY are read by httpx by default
-
-    return client_kwargs
+__all__ = ["create_ssl_context", "get_httpx_client_kwargs"]
diff --git a/packages/uipath/src/uipath/_utils/_url.py b/packages/uipath/src/uipath/_utils/_url.py
new file mode 100644
index 000000000..4776120cd
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/_url.py
@@ -0,0 +1,102 @@
+from typing import Literal
+from urllib.parse import urlparse
+
+
+class UiPathUrl:
+    """A class that represents a UiPath URL.
+
+    This class is used to parse and manipulate UiPath URLs.
+
+    >>> url = UiPathUrl("https://test.uipath.com/org/tenant")
+    >>> url.base_url
+    'https://test.uipath.com'
+    >>> url.org_name
+    'org'
+    >>> url.tenant_name
+    'tenant'
+
+    Args:
+        url (str): The URL to parse.
+    """
+
+    def __init__(self, url: str):
+        self._url = url
+
+    def __str__(self):
+        return self._url
+
+    def __repr__(self):
+        return f"UiPathUrl({self._url})"
+
+    def __eq__(self, other: object):
+        if not isinstance(other, UiPathUrl):
+            return NotImplemented
+
+        return self._url == str(other)
+
+    def __ne__(self, other: object):
+        if not isinstance(other, UiPathUrl):
+            return NotImplemented
+
+        return self._url != str(other)
+
+    def __hash__(self):
+        return hash(self._url)
+
+    @property
+    def base_url(self):
+        parsed = urlparse(self._url)
+
+        return f"{parsed.scheme}://{parsed.hostname}{f':{parsed.port}' if parsed.port else ''}"
+
+    @property
+    def org_name(self):
+        return self._org_tenant_names[0]
+
+    @property
+    def tenant_name(self):
+        return self._org_tenant_names[1]
+
+    def scope_url(self, url: str, scoped: Literal["org", "tenant"] = "tenant") -> str:
+        if not self._is_relative_url(url):
+            return url
+
+        parts = [self.org_name]
+        if scoped == "tenant":
+            parts.append(self.tenant_name)
+        parts.append(url.strip("/"))
+
+        return "/".join(parts)
+
+    @property
+    def _org_tenant_names(self):
+        parsed = urlparse(self._url)
+
+        try:
+            org_name, tenant_name = parsed.path.strip("/").split("/")
+        except ValueError:
+            return "", ""
+
+        return org_name, tenant_name
+
+    def _is_relative_url(self, url: str) -> bool:
+        # Empty URLs are considered relative
+        if not url:
+            return True
+
+        parsed = urlparse(url)
+
+        # Protocol-relative URLs (starting with //) are not relative
+        if url.startswith("//"):
+            return False
+
+        # URLs with schemes are not relative (http:, https:, mailto:, etc.)
+        if parsed.scheme:
+            return False
+
+        # URLs with network locations are not relative
+        if parsed.netloc:
+            return False
+
+        # If we've passed all the checks, it's a relative URL
+        return True
diff --git a/packages/uipath/src/uipath/_utils/_user_agent.py b/packages/uipath/src/uipath/_utils/_user_agent.py
new file mode 100644
index 000000000..dcf28d3e0
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/_user_agent.py
@@ -0,0 +1,19 @@
+import importlib
+
+from .constants import HEADER_USER_AGENT
+
+
+def user_agent_value(specific_component: str) -> str:
+    product = "UiPath.Python.Sdk"
+    product_component = f"UiPath.Python.Sdk.Activities.{specific_component}"
+
+    try:
+        version = importlib.metadata.version("uipath")
+    except importlib.metadata.PackageNotFoundError:
+        version = "unknown"
+
+    return f"{product}/{product_component}/{version}"
+
+
+def header_user_agent(specific_component: str) -> dict[str, str]:
+    return {HEADER_USER_AGENT: user_agent_value(specific_component)}
diff --git a/packages/uipath/src/uipath/_utils/constants.py b/packages/uipath/src/uipath/_utils/constants.py
new file mode 100644
index 000000000..e5a2c06da
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/constants.py
@@ -0,0 +1,89 @@
+# Environment variables
+DOTENV_FILE = ".env"
+ENV_BASE_URL = "UIPATH_URL"
+ENV_EVAL_BACKEND_URL = "UIPATH_EVAL_BACKEND_URL"
+ENV_UNATTENDED_USER_ACCESS_TOKEN = "UNATTENDED_USER_ACCESS_TOKEN"
+ENV_UIPATH_ACCESS_TOKEN = "UIPATH_ACCESS_TOKEN"
+ENV_FOLDER_KEY = "UIPATH_FOLDER_KEY"
+ENV_FOLDER_PATH = "UIPATH_FOLDER_PATH"
+ENV_JOB_KEY = "UIPATH_JOB_KEY"
+ENV_JOB_ID = "UIPATH_JOB_ID"
+ENV_ROBOT_KEY = "UIPATH_ROBOT_KEY"
+ENV_TENANT_ID = "UIPATH_TENANT_ID"
+ENV_TENANT_NAME = "UIPATH_TENANT_NAME"
+ENV_ORGANIZATION_ID = "UIPATH_ORGANIZATION_ID"
+ENV_TELEMETRY_ENABLED = "UIPATH_TELEMETRY_ENABLED"
+ENV_TRACING_ENABLED = "UIPATH_TRACING_ENABLED"
+ENV_UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
+ENV_PROJECT_KEY = "PROJECT_KEY"
+ENV_PROCESS_KEY = "UIPATH_PROCESS_KEY"
+ENV_UIPATH_PROCESS_UUID = "UIPATH_PROCESS_UUID"
+ENV_UIPATH_TRACE_ID = "UIPATH_TRACE_ID"
+ENV_UIPATH_PROCESS_VERSION = "UIPATH_PROCESS_VERSION"
+
+# Headers
+HEADER_AGENTHUB_CONFIG = "x-uipath-agenthub-config"
+HEADER_FOLDER_KEY = "x-uipath-folderkey"
+HEADER_FOLDER_PATH = "x-uipath-folderpath"
+HEADER_FOLDER_PATH_ENCODED = "x-uipath-folderpath-encoded"
+HEADER_INTERNAL_ACCOUNT_ID = "x-uipath-internal-accountid"
+HEADER_INTERNAL_TENANT_ID = "x-uipath-internal-tenantid"
+HEADER_JOB_KEY = "x-uipath-jobkey"
+HEADER_LLMGATEWAY_BYO_CONNECTION_ID = "x-uipath-llmgateway-byoisconnectionid"
+HEADER_PROCESS_KEY = "x-uipath-processkey"
+HEADER_SW_LOCK_KEY = "x-uipath-sw-lockkey"
+HEADER_TENANT_ID = "x-uipath-tenantid"
+HEADER_TRACE_ID = "x-uipath-traceid"
+HEADER_USER_AGENT = "x-uipath-user-agent"
+
+# Data sources (request types)
+ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
+)
+CONFLUENCE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSourceRequest"
+)
+DROPBOX_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSourceRequest"
+)
+GOOGLE_DRIVE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSourceRequest"
+)
+ONEDRIVE_DATA_SOURCE_REQUEST = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSourceRequest"
+)
+
+# Data sources
+ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSource"
+)
+CONFLUENCE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSource"
+DROPBOX_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSource"
+GOOGLE_DRIVE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSource"
+ONEDRIVE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSource"
+
+# Preprocessing request types
+LLMV3Mini_REQUEST = "#UiPath.Vdbs.Domain.Api.V20Models.LLMV3MiniPreProcessingRequest"
+LLMV4_REQUEST = "#UiPath.Vdbs.Domain.Api.V20Models.LLMV4PreProcessingRequest"
+NativeV1_REQUEST = "#UiPath.Vdbs.Domain.Api.V20Models.NativeV1PreProcessingRequest"
+
+
+# Local storage
+TEMP_ATTACHMENTS_FOLDER = "uipath_attachments"
+
+# LLM models
+COMMUNITY_agents_SUFFIX = "-community-agents"
+
+# File names
+PYTHON_CONFIGURATION_FILE = "pyproject.toml"
+UIPATH_CONFIG_FILE = "uipath.json"
+UIPATH_BINDINGS_FILE = "bindings.json"
+ENTRY_POINTS_FILE = "entry-points.json"
+STUDIO_METADATA_FILE = "studio_metadata.json"
+
+
+# Folder names
+LEGACY_EVAL_FOLDER = "evals"
+EVALS_FOLDER = "evaluations"
+# Evaluators
+CUSTOM_EVALUATOR_PREFIX = "file://"
diff --git a/packages/uipath/src/uipath/_utils/validation.py b/packages/uipath/src/uipath/_utils/validation.py
new file mode 100644
index 000000000..2fa2b111c
--- /dev/null
+++ b/packages/uipath/src/uipath/_utils/validation.py
@@ -0,0 +1,43 @@
+"""Validation utilities for SDK services."""
+
+
+def validate_pagination_params(
+    skip: int,
+    top: int,
+    max_skip: int = 10000,
+    max_top: int = 1000,
+) -> None:
+    """Validate pagination parameters for OData queries.
+
+    This validator is used across multiple services (BucketsService, JobsService, etc.)
+    to ensure consistent pagination behavior.
+
+    Args:
+        skip: Number of items to skip (must be >= 0 and <= max_skip)
+        top: Maximum items per page (must be >= 1 and <= max_top)
+        max_skip: Maximum allowed skip value (default: 10000)
+        max_top: Maximum allowed top value (default: 1000)
+
+    Raises:
+        ValueError: If parameters are invalid
+
+    Examples:
+        >>> validate_pagination_params(skip=0, top=100)
+        >>> validate_pagination_params(skip=5000, top=500)
+        >>> validate_pagination_params(skip=-1, top=100)  # Raises ValueError
+        >>> validate_pagination_params(skip=0, top=2000)  # Raises ValueError
+    """
+    if skip < 0:
+        raise ValueError("skip must be >= 0")
+    if skip > max_skip:
+        raise ValueError(
+            f"skip must be <= {max_skip} (requested: {skip}). "
+            f"Use filters to narrow results or manual pagination."
+        )
+    if top < 1:
+        raise ValueError("top must be >= 1")
+    if top > max_top:
+        raise ValueError(
+            f"top must be <= {max_top} (requested: {top}). "
+            f"Use pagination with skip and top parameters."
+        )
diff --git a/packages/uipath/src/uipath/agent/__init__.py b/packages/uipath/src/uipath/agent/__init__.py
new file mode 100644
index 000000000..b3ee47f72
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/__init__.py
@@ -0,0 +1,6 @@
+"""UiPath Agent module.
+
+This module provides agent-related functionality for UiPath.
+"""
+
+__all__ = []
diff --git a/packages/uipath/src/uipath/agent/models/_legacy.py b/packages/uipath/src/uipath/agent/models/_legacy.py
new file mode 100644
index 000000000..3d82968f8
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/models/_legacy.py
@@ -0,0 +1,91 @@
+"""Legacy backwards compatibility for flat AgentDefinition formats.
+
+Converts legacy flat fields into the unified format before Pydantic validation runs.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def normalize_legacy_format(data: dict[str, Any]) -> dict[str, Any]:
+    """Normalize a legacy flat agent definition into the unified format.
+
+    Mutates and returns *data*.  Safe to call on already-modern payloads
+    (existing messages and resources are never overwritten).
+    """
+    _normalize_messages(data)
+    _normalize_legacy_resources(data)
+    _cleanup_legacy_fields(data)
+    return data
+
+
+def _normalize_messages(data: dict[str, Any]) -> None:
+    messages = data.get("messages")
+    if messages:
+        return
+
+    system_prompt = data.get("systemPrompt")
+    user_prompt = data.get("userPrompt")
+
+    if system_prompt is None and user_prompt is None:
+        return
+
+    built: list[dict[str, Any]] = []
+
+    if system_prompt is not None:
+        if isinstance(system_prompt, dict):
+            built.append({"role": "system", **system_prompt})
+        else:
+            built.append({"role": "system", "content": str(system_prompt)})
+
+    if user_prompt is not None:
+        if isinstance(user_prompt, dict):
+            built.append({"role": "user", **user_prompt})
+        else:
+            built.append({"role": "user", "content": str(user_prompt)})
+
+    data["messages"] = built
+
+
+def _normalize_legacy_resources(data: dict[str, Any]) -> None:
+    resources = data.get("resources")
+    if resources:
+        return
+
+    built: list[dict[str, Any]] = []
+
+    for item in data.get("tools") or []:
+        if isinstance(item, dict):
+            item.setdefault("$resourceType", "tool")
+            item.setdefault("isEnabled", True)
+        built.append(item)
+
+    for item in data.get("contexts") or []:
+        if isinstance(item, dict):
+            item.setdefault("$resourceType", "context")
+        built.append(item)
+
+    for item in data.get("escalations") or []:
+        if isinstance(item, dict):
+            item.setdefault("$resourceType", "escalation")
+        built.append(item)
+
+    if built:
+        data["resources"] = built
+
+
+_LEGACY_KEYS = frozenset(
+    [
+        "systemPrompt",
+        "userPrompt",
+        "tools",
+        "contexts",
+        "escalations",
+    ]
+)
+
+
+def _cleanup_legacy_fields(data: dict[str, Any]) -> None:
+    for key in _LEGACY_KEYS:
+        data.pop(key, None)
diff --git a/packages/uipath/src/uipath/agent/models/agent.py b/packages/uipath/src/uipath/agent/models/agent.py
new file mode 100644
index 000000000..916417c94
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/models/agent.py
@@ -0,0 +1,1575 @@
+"""Agent Models."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import (
+    Annotated,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+from pydantic import (
+    BaseModel,
+    BeforeValidator,
+    ConfigDict,
+    Discriminator,
+    Field,
+    Tag,
+    model_validator,
+)
+
+from uipath.agent.models._legacy import normalize_legacy_format
+from uipath.core.guardrails import (
+    BaseGuardrail,
+    FieldReference,
+    SpecificFieldsSelector,
+    UniversalRule,
+)
+from uipath.eval.mocks import ExampleCall
+from uipath.platform.connections import Connection
+from uipath.platform.entities import DataFabricEntityItem
+from uipath.platform.guardrails import (
+    BuiltInValidatorGuardrail,
+)
+
+EMPTY_SCHEMA = {"type": "object", "properties": {}}
+
+
+EnumT = TypeVar("EnumT", bound=Enum)
+
+
+def _match_enum_case_insensitive(enum: type[EnumT], value: str) -> EnumT | None:
+    """Find the corresponding enum value, ignoring case."""
+    for enum_value in enum:
+        if (
+            isinstance(enum_value.value, str)
+            and enum_value.value.lower() == value.lower()
+        ):
+            return enum_value
+    return None
+
+
+def _case_insensitive_enum_validator(
+    field_name: str,
+    enum_cls: type[Enum],
+    alias: str | Iterable[str] = (),
+) -> BeforeValidator:
+    """Create a BeforeValidator for case-insensitive enum normalization."""
+
+    def normalizer(v: Any) -> Any:
+        if not isinstance(v, dict):
+            return v
+
+        aliases = [alias] if isinstance(alias, str) else list(alias)
+        for key in [field_name, *aliases]:
+            value = v.get(key)
+            if isinstance(value, str):
+                match = _match_enum_case_insensitive(enum_cls, value)
+                if match is not None:
+                    v[key] = match.value
+                    break
+        return v
+
+    return BeforeValidator(normalizer)
+
+
+class CaseInsensitiveEnum(Enum):
+    """Base class for case-insensitive enums."""
+
+    @classmethod
+    def _missing_(cls, value: Any) -> Enum | None:
+        """Called when enum value is not found during lookup."""
+        if isinstance(value, str):
+            match = _match_enum_case_insensitive(cls, value)
+            if match is not None:
+                return match
+        return None
+
+
+class AgentResourceType(str, CaseInsensitiveEnum):
+    """Agent resource type enumeration."""
+
+    TOOL = "tool"
+    CONTEXT = "context"
+    ESCALATION = "escalation"
+    MCP = "mcp"
+    A2A = "a2a"
+    UNKNOWN = "unknown"  # fallback branch discriminator
+
+
+class AgentToolType(str, CaseInsensitiveEnum):
+    """Agent tool type enumeration."""
+
+    AGENT = "Agent"
+    PROCESS = "Process"
+    API = "Api"
+    PROCESS_ORCHESTRATION = "ProcessOrchestration"
+    FLOW = "Flow"
+    FUNCTION = "Function"
+    INTEGRATION = "Integration"
+    INTERNAL = "Internal"
+    IXP = "Ixp"
+    CLIENT_SIDE = "ClientSide"
+    UNKNOWN = "Unknown"  # fallback branch discriminator
+
+
+class AgentInternalToolType(str, CaseInsensitiveEnum):
+    """Agent internal tool type enumeration."""
+
+    ANALYZE_FILES = "analyze-attachments"
+    DEEP_RAG = "deep-rag"
+    BATCH_TRANSFORM = "batch-transform"
+
+
+class AgentEscalationRecipientType(str, CaseInsensitiveEnum):
+    """Agent escalation recipient type enumeration."""
+
+    USER_ID = "UserId"
+    GROUP_ID = "GroupId"
+    USER_EMAIL = "UserEmail"
+    ASSET_USER_EMAIL = "AssetUserEmail"
+    GROUP_NAME = "GroupName"
+    ASSET_GROUP_NAME = "AssetGroupName"
+    ARGUMENT_EMAIL = "ArgumentEmail"
+    ARGUMENT_GROUP_NAME = "ArgumentGroupName"
+    WORKLOAD = "Workload"
+    ROUND_ROBIN = "RoundRobin"
+    CUSTOM_ASSIGNEES = "CustomAssignees"
+
+
+class AgentEscalationChannelType(str, CaseInsensitiveEnum):
+    """Agent escalation channel type enumeration."""
+
+    ACTION_CENTER = "actionCenter"
+    ACTION_CENTER_QUICK_FORM = "actionCenterQuickForm"
+
+
+class AgentContextRetrievalMode(str, CaseInsensitiveEnum):
+    """Agent context retrieval mode enumeration."""
+
+    SEMANTIC = "Semantic"
+    STRUCTURED = "Structured"
+    DEEP_RAG = "DeepRAG"
+    BATCH_TRANSFORM = "BatchTransform"
+    DATA_FABRIC = "DataFabric"
+    UNKNOWN = "Unknown"  # fallback branch discriminator
+
+
+class AgentContextType(str, CaseInsensitiveEnum):
+    """Agent context type enumeration."""
+
+    INDEX = "index"
+    ATTACHMENTS = "attachments"
+    DATA_FABRIC_ENTITY_SET = "datafabricentityset"
+
+
+class AgentMessageRole(str, CaseInsensitiveEnum):
+    """Agent message role enumeration."""
+
+    SYSTEM = "system"
+    USER = "user"
+
+
+class AgentVariant(str, CaseInsensitiveEnum):
+    """Agent variant enumeration."""
+
+    CASE_MANAGER = "caseManager"
+
+
+class AgentGuardrailActionType(str, CaseInsensitiveEnum):
+    """Agent guardrail action type enumeration."""
+
+    BLOCK = "block"
+    ESCALATE = "escalate"
+    FILTER = "filter"
+    LOG = "log"
+    UNKNOWN = "unknown"  # fallback branch discriminator
+
+
+class AgentToolArgumentPropertiesVariant(str, CaseInsensitiveEnum):
+    """Agent tool argument properties variant enumeration."""
+
+    DYNAMIC = "dynamic"
+    ARGUMENT = "argument"
+    STATIC = "static"
+    TEXT_BUILDER = "textBuilder"
+    ARRAY_BUILDER = "arrayBuilder"
+
+
+class TextTokenType(str, CaseInsensitiveEnum):
+    """Text token type enumeration."""
+
+    SIMPLE_TEXT = "simpleText"
+    VARIABLE = "variable"
+    EXPRESSION = "expression"
+
+
+class CitationMode(str, CaseInsensitiveEnum):
+    """Citation mode enumeration."""
+
+    INLINE = "Inline"
+    SKIP = "Skip"
+
+
+class DeepRagFileExtension(str, CaseInsensitiveEnum):
+    """File extension enumeration for DeepRAG."""
+
+    PDF = "pdf"
+    TXT = "txt"
+
+
+class BatchTransformFileExtension(str, CaseInsensitiveEnum):
+    """File extension enumeration for Batch Transform."""
+
+    CSV = "csv"
+
+
+class BatchTransformWebSearchGrounding(str, CaseInsensitiveEnum):
+    """Batch Transform web search grounding enumeration."""
+
+    ENABLED = "Enabled"
+    DISABLED = "Disabled"
+
+
+class BaseCfg(BaseModel):
+    """Base configuration model with common settings."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class TextToken(BaseCfg):
+    """Text token model."""
+
+    type: TextTokenType
+    raw_string: str = Field(alias="rawString")
+
+
+class BaseAgentToolArgumentProperties(BaseCfg):
+    """Base tool argument properties model."""
+
+    variant: AgentToolArgumentPropertiesVariant
+    is_sensitive: bool = Field(alias="isSensitive")
+
+
+class AgentToolStaticArgumentProperties(BaseAgentToolArgumentProperties):
+    """Static tool argument properties model."""
+
+    variant: Literal[AgentToolArgumentPropertiesVariant.STATIC] = Field(
+        default=AgentToolArgumentPropertiesVariant.STATIC, frozen=True
+    )
+    value: Optional[Any]
+
+
+class AgentToolArgumentArgumentProperties(BaseAgentToolArgumentProperties):
+    """Agent argument argument properties model."""
+
+    variant: Literal[AgentToolArgumentPropertiesVariant.ARGUMENT] = Field(
+        default=AgentToolArgumentPropertiesVariant.ARGUMENT,
+        frozen=True,
+    )
+    argument_path: str = Field(alias="argumentPath")
+
+
+class AgentToolTextBuilderArgumentProperties(BaseAgentToolArgumentProperties):
+    """Agent text builder argument properties model."""
+
+    variant: Literal[AgentToolArgumentPropertiesVariant.TEXT_BUILDER] = Field(
+        default=AgentToolArgumentPropertiesVariant.TEXT_BUILDER,
+        frozen=True,
+    )
+    tokens: List[TextToken]
+
+
+class AgentToolArrayBuilderArgumentProperties(BaseCfg):
+    """Agent array builder argument properties model."""
+
+    variant: Literal[AgentToolArgumentPropertiesVariant.ARRAY_BUILDER] = Field(
+        default=AgentToolArgumentPropertiesVariant.ARRAY_BUILDER,
+        frozen=True,
+    )
+
+
+AgentToolArgumentProperties = Annotated[
+    Union[
+        AgentToolStaticArgumentProperties,
+        AgentToolArgumentArgumentProperties,
+        AgentToolTextBuilderArgumentProperties,
+        AgentToolArrayBuilderArgumentProperties,
+    ],
+    Field(discriminator="variant"),
+    _case_insensitive_enum_validator("variant", AgentToolArgumentPropertiesVariant),
+]
+
+
+class BaseResourceProperties(BaseCfg):
+    """Base resource properties model."""
+
+    example_calls: Optional[list[ExampleCall]] = Field(None, alias="exampleCalls")
+    require_conversational_confirmation: bool = Field(
+        default=False, alias="requireConversationalConfirmation"
+    )
+
+
+class AgentToolSettings(BaseCfg):
+    """Agent tool settings model."""
+
+    max_attempts: Optional[int] = Field(None, alias="maxAttempts")
+    retry_delay: Optional[int] = Field(None, alias="retryDelay")
+    timeout: Optional[int] = Field(None)
+
+
+class BaseAgentResourceConfig(BaseCfg):
+    """Base agent resource configuration model."""
+
+    name: str
+    description: str
+    is_enabled: bool = Field(default=True, alias="isEnabled")
+    # NOTE: this is the union discriminator; don't attach validators here.
+    resource_type: Literal[
+        AgentResourceType.TOOL,
+        AgentResourceType.CONTEXT,
+        AgentResourceType.ESCALATION,
+        AgentResourceType.MCP,
+        AgentResourceType.A2A,
+        AgentResourceType.UNKNOWN,
+    ] = Field(alias="$resourceType")
+
+
+class AgentUnknownResourceConfig(BaseAgentResourceConfig):
+    """Fallback for unknown or future resource types."""
+
+    resource_type: Literal[AgentResourceType.UNKNOWN] = Field(
+        alias="$resourceType", default=AgentResourceType.UNKNOWN, frozen=True
+    )
+
+
+class AgentContextQuerySetting(BaseCfg):
+    """Agent context query setting model."""
+
+    value: str | None = Field(default=None)
+    description: str | None = Field(default=None)
+    variant: AgentToolArgumentPropertiesVariant | None = Field(default=None)
+
+
+class AgentContextValueSetting(BaseCfg):
+    """Agent context value setting model."""
+
+    value: Any = Field(...)
+
+
+class DeepRagCitationModeSetting(BaseCfg):
+    """DeepRAG citation mode setting model."""
+
+    value: CitationMode = Field(...)
+
+
+class DeepRagFileExtensionSetting(BaseCfg):
+    """DeepRAG file extension setting model."""
+
+    value: DeepRagFileExtension = Field(...)
+
+
+class BatchTransformFileExtensionSetting(BaseCfg):
+    """Batch Transform file extension setting model."""
+
+    value: BatchTransformFileExtension = Field(...)
+
+
+class BatchTransformWebSearchGroundingSetting(BaseCfg):
+    """DeepRAG file extension setting model."""
+
+    value: BatchTransformWebSearchGrounding = Field(...)
+
+
+class AgentContextOutputColumn(BaseCfg):
+    """Agent context output column model."""
+
+    name: str = Field(...)
+    description: Optional[str] = Field(None)
+
+
+class AgentContextSettings(BaseCfg):
+    """Agent context settings model."""
+
+    result_count: int = Field(alias="resultCount")
+    # Allow Unknown explicitly so we can serialize deterministically
+    retrieval_mode: AgentContextRetrievalMode = Field(alias="retrievalMode")
+    threshold: float = Field(default=0)
+    query: AgentContextQuerySetting = Field(
+        default_factory=lambda: AgentContextQuerySetting(
+            variant=AgentToolArgumentPropertiesVariant.DYNAMIC
+        )
+    )
+    folder_path_prefix: Optional[AgentContextQuerySetting] = Field(
+        None, alias="folderPathPrefix"
+    )
+    file_extension: Optional[AgentContextValueSetting] = Field(
+        None, alias="fileExtension"
+    )
+    citation_mode: Optional[AgentContextValueSetting] = Field(
+        None, alias="citationMode"
+    )
+    web_search_grounding: Optional[AgentContextValueSetting] = Field(
+        None, alias="webSearchGrounding"
+    )
+    output_columns: Optional[List[AgentContextOutputColumn]] = Field(
+        None, alias="outputColumns"
+    )
+
+
+class AgentContextResourceConfig(BaseAgentResourceConfig):
+    """Agent context resource configuration model."""
+
+    resource_type: Literal[AgentResourceType.CONTEXT] = Field(
+        alias="$resourceType", default=AgentResourceType.CONTEXT, frozen=True
+    )
+    context_type: Optional[AgentContextType] = Field(None, alias="contextType")
+    folder_path: Optional[str] = Field(None, alias="folderPath")
+    index_name: Optional[str] = Field(None, alias="indexName")
+    settings: Optional[AgentContextSettings] = Field(
+        None, description="Context settings"
+    )
+    entity_set: Optional[List[DataFabricEntityItem]] = Field(None, alias="entitySet")
+    argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
+        {}, alias="argumentProperties"
+    )
+
+    @property
+    def is_datafabric(self) -> bool:
+        """Check if this context is a Data Fabric entity set resource."""
+        return self.context_type == AgentContextType.DATA_FABRIC_ENTITY_SET
+
+    @property
+    def datafabric_entity_identifiers(self) -> list[str]:
+        """Extract entity identifiers from entitySet."""
+        if self.entity_set:
+            return [item.id for item in self.entity_set]
+        return []
+
+
+class AgentMcpTool(BaseCfg):
+    """Agent MCP tool model."""
+
+    name: str = Field(..., alias="name")
+    description: str = Field(..., alias="description")
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
+    output_schema: Optional[Dict[str, Any]] = Field(None, alias="outputSchema")
+    argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
+        {}, alias="argumentProperties"
+    )
+
+
+class DynamicToolsMode(str, CaseInsensitiveEnum):
+    """Dynamic tools mode enumeration.
+
+    Deprecated: kept for backwards compatibility with older ``agent.json`` files
+    that still serialize the ``dynamicTools`` field. New code should use
+    :class:`ToolsConfiguration` (see ``AgentMcpResourceConfig.tools_configuration``).
+    """
+
+    NONE = "none"
+    SCHEMA = "schema"
+    ALL = "all"
+
+
+class CachedToolsConfig(BaseCfg):
+    """Cached tools configuration: use the tools saved in the agent definition snapshot.
+
+    When ``refresh_schema_before_call`` is true, the live tool schema is fetched
+    from the MCP server immediately before a tool is invoked. The agent still uses
+    the cached schema to decide which tool to call; the fresh schema is applied only
+    at invocation time.
+    """
+
+    type: Literal["cached"] = Field(default="cached", frozen=True)
+    refresh_schema_before_call: bool = Field(
+        default=True, alias="refreshSchemaBeforeCall"
+    )
+
+
+class DynamicToolsConfig(BaseCfg):
+    """Dynamic tools configuration: fetch the tool list from the MCP server at runtime.
+
+    When ``allow_all`` is true, every tool the server exposes is forwarded
+    to the agent. When false, the live list is filtered by the snapshot's
+    ``available_tools`` allowlist (live schemas, curated tool set).
+    """
+
+    type: Literal["dynamic"] = Field(default="dynamic", frozen=True)
+    allow_all: bool = Field(alias="allowAll")
+
+
+DiscoveryMode = Annotated[
+    Union[CachedToolsConfig, DynamicToolsConfig],
+    Field(discriminator="type"),
+]
+
+
+class ToolsConfiguration(BaseCfg):
+    """Configuration describing how tools are sourced for an MCP resource."""
+
+    discovery_mode: DiscoveryMode = Field(alias="discoveryMode")
+
+
+class AgentMcpResourceConfig(BaseAgentResourceConfig):
+    """Agent MCP resource configuration model."""
+
+    resource_type: Literal[AgentResourceType.MCP] = Field(
+        alias="$resourceType", default=AgentResourceType.MCP, frozen=True
+    )
+    folder_path: str = Field(alias="folderPath")
+    slug: str = Field(..., alias="slug")
+    available_tools: List[AgentMcpTool] = Field(..., alias="availableTools")
+    tools_configuration: Optional[ToolsConfiguration] = Field(
+        default=None, alias="toolsConfiguration"
+    )
+
+
+class AgentA2aResourceConfig(BaseAgentResourceConfig):
+    """Agent A2A resource configuration model."""
+
+    resource_type: Literal[AgentResourceType.A2A] = Field(
+        alias="$resourceType", default=AgentResourceType.A2A, frozen=True
+    )
+    id: str
+    slug: str = Field(..., alias="slug")
+    folder_path: str = Field(alias="folderPath")
+    cached_agent_card: Optional[Dict[str, Any]] = Field(
+        default=None, alias="cachedAgentCard"
+    )
+
+
+_RECIPIENT_TYPE_NORMALIZED_MAP: Mapping[int | str, AgentEscalationRecipientType] = {
+    1: AgentEscalationRecipientType.USER_ID,
+    2: AgentEscalationRecipientType.GROUP_ID,
+    3: AgentEscalationRecipientType.USER_EMAIL,
+    4: AgentEscalationRecipientType.ASSET_USER_EMAIL,
+    5: AgentEscalationRecipientType.GROUP_NAME,
+    "staticgroupname": AgentEscalationRecipientType.GROUP_NAME,
+    6: AgentEscalationRecipientType.ASSET_GROUP_NAME,
+    7: AgentEscalationRecipientType.ARGUMENT_EMAIL,
+    8: AgentEscalationRecipientType.ARGUMENT_GROUP_NAME,
+    9: AgentEscalationRecipientType.WORKLOAD,
+    10: AgentEscalationRecipientType.ROUND_ROBIN,
+    11: AgentEscalationRecipientType.CUSTOM_ASSIGNEES,
+}
+
+
+def _normalize_recipient_type(recipient: Any) -> Any:
+    """Normalize recipient type from integer or string to enum before discrimination."""
+    if not isinstance(recipient, dict):
+        return recipient
+    recipient_type = recipient.get("type")
+
+    normalized: AgentEscalationRecipientType | None = None
+    if isinstance(recipient_type, int):
+        normalized = _RECIPIENT_TYPE_NORMALIZED_MAP.get(recipient_type)
+    elif isinstance(recipient_type, str):
+        normalized = _RECIPIENT_TYPE_NORMALIZED_MAP.get(recipient_type.lower())
+        if normalized is None:
+            normalized = _match_enum_case_insensitive(
+                AgentEscalationRecipientType, recipient_type
+            )
+
+    if normalized is not None:
+        recipient["type"] = normalized.value
+
+    return recipient
+
+
+class BaseEscalationRecipient(BaseCfg):
+    """Base class for escalation recipients."""
+
+    type: Union[AgentEscalationRecipientType, str] = Field(..., alias="type")
+
+
+class StandardRecipient(BaseEscalationRecipient):
+    """Standard recipient with value field."""
+
+    type: Literal[
+        AgentEscalationRecipientType.USER_ID,
+        AgentEscalationRecipientType.GROUP_ID,
+        AgentEscalationRecipientType.USER_EMAIL,
+        AgentEscalationRecipientType.GROUP_NAME,
+    ] = Field(..., alias="type")
+    value: str = Field(..., alias="value")
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+
+
+class AssetRecipient(BaseEscalationRecipient):
+    """Asset recipient with assetName and folderPath."""
+
+    type: Literal[
+        AgentEscalationRecipientType.ASSET_USER_EMAIL,
+        AgentEscalationRecipientType.ASSET_GROUP_NAME,
+    ] = Field(..., alias="type")
+    asset_name: str = Field(..., alias="assetName")
+    folder_path: str = Field(..., alias="folderPath")
+
+
+class ArgumentEmailRecipient(BaseEscalationRecipient):
+    """Argument email recipient resolved from a named input argument.
+
+    The argument_path supports dot-notation for nested input fields (e.g. "user.email").
+    """
+
+    type: Literal[AgentEscalationRecipientType.ARGUMENT_EMAIL,] = Field(
+        ..., alias="type"
+    )
+    argument_path: str = Field(..., alias="argumentName")
+
+
+class ArgumentGroupNameRecipient(BaseEscalationRecipient):
+    """Argument group name recipient resolved from a named input argument.
+
+    The argument_path supports dot-notation for nested input fields (e.g. "team.groupName").
+    """
+
+    type: Literal[AgentEscalationRecipientType.ARGUMENT_GROUP_NAME,] = Field(
+        ..., alias="type"
+    )
+    argument_path: str = Field(..., alias="argumentName")
+
+
+class WorkloadRecipient(BaseEscalationRecipient):
+    """Workload-based group assignment.
+
+    The Action Center distributes tasks to the group member with the lightest workload.
+    """
+
+    type: Literal[AgentEscalationRecipientType.WORKLOAD,] = Field(..., alias="type")
+    value: str = Field(..., alias="value")
+    display_name: str = Field(..., alias="displayName")
+
+
+class RoundRobinRecipient(BaseEscalationRecipient):
+    """Round-robin group assignment.
+
+    The Action Center cycles through group members in order on each new task.
+    """
+
+    type: Literal[AgentEscalationRecipientType.ROUND_ROBIN,] = Field(..., alias="type")
+    value: str = Field(..., alias="value")
+    display_name: str = Field(..., alias="displayName")
+
+
+class CustomAssigneesRecipient(BaseEscalationRecipient):
+    """Custom multi-user assignment.
+
+    A channel can carry multiple instances, one per assignee email. All are passed
+    to Action Center together using a Workload assignment criteria.
+    """
+
+    type: Literal[AgentEscalationRecipientType.CUSTOM_ASSIGNEES,] = Field(
+        ..., alias="type"
+    )
+    value: str = Field(..., alias="value")
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+
+
+class ToolOutputRecipient(BaseEscalationRecipient):
+    """Recipient whose value is resolved at runtime from a named tool's output.
+
+    Instead of a literal value entered at design time, this binding points at a
+    field within a named tool's output. The runtime walks the agent's message
+    history, finds the most recent ToolMessage matching `tool_name`, parses its
+    content as JSON, and extracts `output_path` (a top-level field for v1).
+
+    Only the assignment-criteria recipient types that accept a runtime-computed
+    value are supported: USER_ID, GROUP_ID, WORKLOAD, ROUND_ROBIN,
+    CUSTOM_ASSIGNEES. The asset/static/argument types do not participate in
+    tool-output binding (they have their own design-time resolution rules).
+    """
+
+    type: Literal[
+        AgentEscalationRecipientType.USER_ID,
+        AgentEscalationRecipientType.GROUP_ID,
+        AgentEscalationRecipientType.WORKLOAD,
+        AgentEscalationRecipientType.ROUND_ROBIN,
+        AgentEscalationRecipientType.CUSTOM_ASSIGNEES,
+    ] = Field(..., alias="type")
+    source: Literal["toolOutput"] = Field(..., alias="source")
+    tool_name: str = Field(..., alias="toolName")
+    output_path: str = Field(..., alias="outputPath")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# AgentEscalationRecipient — Union ordering & invariants
+# ──────────────────────────────────────────────────────────────────────────────
+# Pydantic evaluates Union members left-to-right and stops at the first
+# successful match, so member order determines which class a payload resolves
+# to when multiple members share the same `type` value (e.g. WORKLOAD is valid
+# on both WorkloadRecipient and ToolOutputRecipient).
+#
+# How dispatching works:
+#   - Payload with `source: "toolOutput"` → matches ToolOutputRecipient
+#     (it is the only class declaring `source` as a required Literal field).
+#   - Payload without `source` → ToolOutputRecipient validation fails
+#     (`source` missing), so it falls through to the literal class below
+#     that owns its `type`.
+#
+# Why we don't use `Field(discriminator="type")`:
+#   The `type` values are NOT unique across the Union — both WorkloadRecipient
+#   and ToolOutputRecipient declare `type=WORKLOAD`, same for the other
+#   tool-output-capable criteria. A typed discriminator requires unique
+#   discriminator values across members, which this union violates by design.
+#
+# Critical invariants (any of these breaking causes silent mis-typing):
+#   1. ToolOutputRecipient remains the FIRST member of the Union.
+#   2. ToolOutputRecipient.source remains a required `Literal["toolOutput"]`
+#      (NOT `Optional`, NOT a default value).
+#   3. No literal class below it gains an optional `source` field.
+AgentEscalationRecipient = Annotated[
+    Union[
+        ToolOutputRecipient,
+        StandardRecipient,
+        AssetRecipient,
+        ArgumentEmailRecipient,
+        ArgumentGroupNameRecipient,
+        WorkloadRecipient,
+        RoundRobinRecipient,
+        CustomAssigneesRecipient,
+    ],
+    BeforeValidator(_normalize_recipient_type),
+]
+
+
+class TaskTitleType(str, CaseInsensitiveEnum):
+    """Task title type enumeration."""
+
+    DYNAMIC = "dynamic"
+    TEXT_BUILDER = "textBuilder"
+
+
+class BaseTaskTitle(BaseCfg):
+    """Base class for task titles."""
+
+    type: Union[TaskTitleType, str] = Field(..., alias="type")
+
+
+class DynamicTaskTitle(BaseTaskTitle):
+    """Dynamic task title with argument path."""
+
+    type: Literal[TaskTitleType.DYNAMIC] = Field(..., alias="type")
+    argument_path: str = Field(..., alias="argumentPath")
+
+
+class TextBuilderTaskTitle(BaseTaskTitle):
+    """Text builder task title with tokens."""
+
+    type: Literal[TaskTitleType.TEXT_BUILDER] = Field(..., alias="type")
+    tokens: List[TextToken]
+
+
+TaskTitle = Annotated[
+    Union[DynamicTaskTitle, TextBuilderTaskTitle],
+    Field(discriminator="type"),
+]
+
+
+def _resolve_task_title(v: Any) -> Any:
+    """Resolve taskTitleV2 and taskTitle into a single task_title field."""
+    if not isinstance(v, dict):
+        return v
+
+    task_title_v2 = v.get("taskTitleV2")
+    task_title = v.get("taskTitle")
+
+    # Priority 1: Use taskTitleV2 if present
+    if task_title_v2 is not None:
+        task_title_type = task_title_v2.get("type")
+        if task_title_type is not None:
+            normalized_type = _match_enum_case_insensitive(
+                TaskTitleType, task_title_type
+            )
+            if normalized_type is not None:
+                task_title_v2["type"] = normalized_type.value
+        v["taskTitle"] = task_title_v2
+        v.pop("taskTitleV2")
+    # Priority 2: Use taskTitle if present (legacy string support)
+    elif task_title is not None:
+        pass
+    else:
+        v["taskTitle"] = "Escalation Task"
+    return v
+
+
+class BaseEscalationChannelProperties(BaseResourceProperties):
+    """Fields shared by every escalation channel's properties."""
+
+    is_actionable_message_enabled: Optional[bool] = Field(
+        None, alias="isActionableMessageEnabled"
+    )
+    actionable_message_meta_data: Optional[Any] = Field(
+        None, alias="actionableMessageMetaData"
+    )
+
+
+class AgentEscalationChannelProperties(BaseEscalationChannelProperties):
+    """Action Center app-task channel properties (channel type ``actionCenter``)."""
+
+    app_name: str | None = Field(default=None, alias="appName")
+    app_version: int = Field(..., alias="appVersion")
+    folder_name: Optional[str] = Field(None, alias="folderName")
+    resource_key: str | None = Field(default=None, alias="resourceKey")
+
+
+class AgentQuickFormChannelProperties(BaseEscalationChannelProperties):
+    """Quick Form channel properties (channel type ``actionCenterQuickForm``)."""
+
+    form_schema: Dict[str, Any] = Field(..., alias="schema")
+
+    @property
+    def schema_id(self) -> str | None:
+        """Return the schema id nested inside the form schema body."""
+        return self.form_schema.get("schemaId")
+
+
+class BaseAgentEscalationChannel(BaseCfg):
+    """Fields shared by every escalation channel variant."""
+
+    id: Optional[str] = Field(None, alias="id")
+    name: str = Field(..., alias="name")
+    description: str = Field(..., alias="description")
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
+    output_schema: Dict[str, Any] = Field(EMPTY_SCHEMA, alias="outputSchema")
+    argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
+        {}, alias="argumentProperties"
+    )
+    outcome_mapping: Optional[Dict[str, str]] = Field(None, alias="outcomeMapping")
+    recipients: List[AgentEscalationRecipient] = Field(..., alias="recipients")
+    task_title: Optional[Union[str, TaskTitle]] = Field(
+        default="Escalation Task", alias="taskTitle"
+    )
+    priority: Optional[str] = None
+    labels: List[str] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _apply_task_title_resolution(cls, v: Any) -> Any:
+        """Apply task title resolution."""
+        return _resolve_task_title(v)
+
+
+class AgentEscalationChannel(BaseAgentEscalationChannel):
+    """Action Center app-task escalation channel (channel type ``actionCenter``)."""
+
+    type: Literal[AgentEscalationChannelType.ACTION_CENTER] = Field(
+        default=AgentEscalationChannelType.ACTION_CENTER, alias="type"
+    )
+    properties: AgentEscalationChannelProperties = Field(..., alias="properties")
+
+
+class AgentQuickFormEscalationChannel(BaseAgentEscalationChannel):
+    """Quick Form escalation channel; FormLib schema lives in ``properties.form_schema``."""
+
+    type: Literal[AgentEscalationChannelType.ACTION_CENTER_QUICK_FORM] = Field(
+        default=AgentEscalationChannelType.ACTION_CENTER_QUICK_FORM, alias="type"
+    )
+    properties: AgentQuickFormChannelProperties = Field(..., alias="properties")
+
+
+EscalationChannel = Annotated[
+    Union[
+        AgentEscalationChannel,
+        AgentQuickFormEscalationChannel,
+    ],
+    Field(discriminator="type"),
+    _case_insensitive_enum_validator("type", AgentEscalationChannelType),
+]
+
+
+class AgentEscalationResourceConfig(BaseAgentResourceConfig):
+    """Agent escalation resource configuration model."""
+
+    id: Optional[str] = Field(None, alias="id")
+    resource_type: Literal[AgentResourceType.ESCALATION] = Field(
+        alias="$resourceType", default=AgentResourceType.ESCALATION, frozen=True
+    )
+    channels: List[EscalationChannel] = Field(alias="channels")
+    is_agent_memory_enabled: bool = Field(default=False, alias="isAgentMemoryEnabled")
+    escalation_type: Literal[0] = Field(default=0, alias="escalationType")
+
+
+class AgentIxpVsEscalationProperties(BaseCfg):
+    """VS escalation properties model."""
+
+    ixp_tool_id: str = Field(..., alias="ixpToolId")
+    storage_bucket_name: str = Field(..., alias="storageBucketName")
+    storage_bucket_folder_path: str = Field(..., alias="storageBucketFolderPath")
+
+
+class AgentIxpVsEscalationResourceConfig(BaseAgentResourceConfig):
+    """VS Agent escalation resource configuration model (escalationType=1)."""
+
+    id: Optional[str] = Field(None, alias="id")
+    resource_type: Literal[AgentResourceType.ESCALATION] = Field(
+        alias="$resourceType", default=AgentResourceType.ESCALATION, frozen=True
+    )
+    channels: List[EscalationChannel] = Field(alias="channels")
+    is_agent_memory_enabled: bool = Field(default=False, alias="isAgentMemoryEnabled")
+    escalation_type: Literal[1] = Field(default=1, alias="escalationType")
+    vs_escalation_properties: AgentIxpVsEscalationProperties = Field(
+        ..., alias="vsEscalationProperties"
+    )
+
+
+class BaseAgentToolResourceConfig(BaseAgentResourceConfig):
+    """Base agent tool resource configuration model."""
+
+    resource_type: Literal[AgentResourceType.TOOL] = Field(
+        alias="$resourceType", default=AgentResourceType.TOOL, frozen=True
+    )
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
+
+
+class AgentProcessToolProperties(BaseResourceProperties):
+    """Agent process tool properties model."""
+
+    folder_path: Optional[str] = Field(None, alias="folderPath")
+    process_name: Optional[str] = Field(None, alias="processName")
+
+
+class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
+    """Agent process tool resource configuration model."""
+
+    type: Literal[
+        AgentToolType.AGENT,
+        AgentToolType.PROCESS,
+        AgentToolType.API,
+        AgentToolType.PROCESS_ORCHESTRATION,
+        AgentToolType.FLOW,
+        AgentToolType.FUNCTION,
+    ]
+    output_schema: Dict[str, Any] = Field(EMPTY_SCHEMA, alias="outputSchema")
+    properties: AgentProcessToolProperties
+    settings: AgentToolSettings = Field(default_factory=AgentToolSettings)
+    arguments: Dict[str, Any] = Field(default_factory=dict)
+    argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
+        {}, alias="argumentProperties"
+    )
+
+
+class AgentIxpExtractionToolProperties(BaseResourceProperties):
+    """Agent process tool properties model."""
+
+    project_name: str | None = Field(None, alias="projectName")
+    version_tag: str | None = Field(None, alias="versionTag")
+
+
+class AgentIxpExtractionResourceConfig(BaseAgentToolResourceConfig):
+    """Agent ixp extraction tool resource configuration model."""
+
+    type: Literal[AgentToolType.IXP] = AgentToolType.IXP
+    output_schema: dict[str, Any] = Field(EMPTY_SCHEMA, alias="outputSchema")
+    settings: AgentToolSettings = Field(default_factory=AgentToolSettings)
+    properties: AgentIxpExtractionToolProperties
+
+
+class AgentIntegrationToolParameter(BaseCfg):
+    """Agent integration tool parameter model."""
+
+    name: str = Field(..., alias="name")
+    type: str = Field(..., alias="type")
+    value: Optional[Any] = Field(None, alias="value")
+    field_location: str = Field(..., alias="fieldLocation")
+
+    # Optional metadata
+    display_name: Optional[str] = Field(None, alias="displayName")
+    display_value: Optional[str] = Field(None, alias="displayValue")
+    description: Optional[str] = Field(None, alias="description")
+    position: Optional[str] = Field(None, alias="position")
+    field_variant: Optional[str] = Field(None, alias="fieldVariant")
+    dynamic: Optional[bool] = Field(None, alias="dynamic")
+    is_cascading: Optional[bool] = Field(None, alias="isCascading")
+    sort_order: Optional[int] = Field(None, alias="sortOrder")
+    required: Optional[bool] = Field(None, alias="required")
+
+
+class AgentIntegrationToolProperties(BaseResourceProperties):
+    """Agent integration tool properties model."""
+
+    tool_path: str = Field(..., alias="toolPath")
+    object_name: str = Field(..., alias="objectName")
+    tool_display_name: str = Field(..., alias="toolDisplayName")
+    tool_description: str = Field(..., alias="toolDescription")
+    method: str = Field(..., alias="method")
+    connection: Connection = Field(..., alias="connection")
+    body_structure: Optional[dict[str, Any]] = Field(None, alias="bodyStructure")
+    parameters: List[AgentIntegrationToolParameter] = Field(
+        default_factory=list, alias="parameters"
+    )
+
+
+class AgentInternalAnalyzeFilesToolProperties(BaseResourceProperties):
+    """Agent internal analyze files tool properties model."""
+
+    tool_type: Literal[AgentInternalToolType.ANALYZE_FILES] = Field(
+        alias="toolType", default=AgentInternalToolType.ANALYZE_FILES, frozen=True
+    )
+
+
+class AgentInternalDeepRagToolProperties(BaseResourceProperties):
+    """Agent internal DeepRAG tool properties model."""
+
+    tool_type: Literal[AgentInternalToolType.DEEP_RAG] = Field(
+        alias="toolType", default=AgentInternalToolType.DEEP_RAG, frozen=True
+    )
+    settings: AgentInternalDeepRagSettings = Field(..., alias="settings")
+
+
+class AgentInternalBatchTransformToolProperties(BaseResourceProperties):
+    """Agent internal Batch Tranform tool properties model."""
+
+    tool_type: Literal[AgentInternalToolType.BATCH_TRANSFORM] = Field(
+        alias="toolType", default=AgentInternalToolType.BATCH_TRANSFORM, frozen=True
+    )
+    settings: AgentInternalBatchTransformSettings = Field(..., alias="settings")
+
+
+AgentInternalToolProperties = Annotated[
+    Union[
+        AgentInternalAnalyzeFilesToolProperties,
+        AgentInternalDeepRagToolProperties,
+        AgentInternalBatchTransformToolProperties,
+    ],
+    Field(discriminator="tool_type"),
+    _case_insensitive_enum_validator("tool_type", AgentInternalToolType, "toolType"),
+]
+
+
+class AgentInternalDeepRagSettings(BaseCfg):
+    """Agent internal DeepRAG tool settings model."""
+
+    context_type: str = Field(..., alias="contextType")
+    query: AgentContextQuerySetting = Field(...)
+    folder_path_prefix: AgentContextQuerySetting | None = Field(
+        default=None, alias="folderPathPrefix"
+    )
+    citation_mode: DeepRagCitationModeSetting = Field(..., alias="citationMode")
+    file_extension: DeepRagFileExtensionSetting = Field(..., alias="fileExtension")
+
+
+class AgentInternalBatchTransformSettings(BaseCfg):
+    """Agent internal Batch Transform tool settings model."""
+
+    context_type: str = Field(..., alias="contextType")
+    query: AgentContextQuerySetting = Field(...)
+    folder_path_prefix: AgentContextQuerySetting | None = Field(
+        default=None, alias="folderPathPrefix"
+    )
+    file_extension: BatchTransformFileExtensionSetting = Field(
+        ..., alias="fileExtension"
+    )
+    output_columns: List[AgentContextOutputColumn] = Field(..., alias="outputColumns")
+    web_search_grounding: BatchTransformWebSearchGroundingSetting = Field(
+        ..., alias="webSearchGrounding"
+    )
+
+
+class AgentIntegrationToolResourceConfig(BaseAgentToolResourceConfig):
+    """Agent integration tool resource configuration model."""
+
+    type: Literal[AgentToolType.INTEGRATION] = AgentToolType.INTEGRATION
+    properties: AgentIntegrationToolProperties
+    settings: Optional[AgentToolSettings] = Field(None)
+    arguments: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    # is output schemas were only recently added so they will be missing in some resources
+    output_schema: Optional[Dict[str, Any]] = Field(None, alias="outputSchema")
+
+
+class AgentInternalToolResourceConfig(BaseAgentToolResourceConfig):
+    """Agent internal tool resource configuration model."""
+
+    type: Literal[AgentToolType.INTERNAL] = AgentToolType.INTERNAL
+    properties: AgentInternalToolProperties
+    settings: Optional[AgentToolSettings] = Field(None)
+    arguments: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    output_schema: Dict[str, Any] = Field(EMPTY_SCHEMA, alias="outputSchema")
+    argument_properties: Dict[str, AgentToolArgumentProperties] = Field(
+        {}, alias="argumentProperties"
+    )
+
+
+class AgentClientSideToolResourceConfig(BaseAgentToolResourceConfig):
+    """Resource config for client-side tools executed by the client SDK."""
+
+    type: Literal[AgentToolType.CLIENT_SIDE] = AgentToolType.CLIENT_SIDE
+    properties: BaseResourceProperties = Field(default_factory=BaseResourceProperties)
+    output_schema: Optional[Dict[str, Any]] = Field(None, alias="outputSchema")
+    arguments: Optional[Dict[str, Any]] = Field(default_factory=dict)
+
+
+class AgentUnknownToolResourceConfig(BaseAgentToolResourceConfig):
+    """Fallback for unknown tool types (parent normalizer sets type='Unknown')."""
+
+    type: Literal[AgentToolType.UNKNOWN] = AgentToolType.UNKNOWN
+    arguments: Optional[Dict[str, Any]] = Field(default_factory=dict)
+
+
+ToolResourceConfig = Annotated[
+    Union[
+        AgentProcessToolResourceConfig,
+        AgentIntegrationToolResourceConfig,
+        AgentInternalToolResourceConfig,
+        AgentIxpExtractionResourceConfig,
+        AgentClientSideToolResourceConfig,
+        AgentUnknownToolResourceConfig,  # when parent sets type="Unknown"
+    ],
+    Field(discriminator="type"),
+]
+
+
+EscalationResourceConfig = Annotated[
+    Union[
+        Annotated[AgentEscalationResourceConfig, Tag(0)],
+        Annotated[AgentIxpVsEscalationResourceConfig, Tag(1)],
+    ],
+    Discriminator(lambda v: v.get("escalation_type") or v.get("escalationType") or 0),
+]
+
+AgentResourceConfig = Annotated[
+    Union[
+        ToolResourceConfig,  # nested discrim on 'type'
+        AgentContextResourceConfig,
+        EscalationResourceConfig,  # nested discrim on 'escalation_type'
+        AgentMcpResourceConfig,
+        AgentA2aResourceConfig,
+        AgentUnknownResourceConfig,  # when parent sets resource_type="Unknown"
+    ],
+    Field(discriminator="resource_type"),
+]
+
+
+class AgentGuardrailBlockAction(BaseModel):
+    """Agent guardrail block action model."""
+
+    action_type: Literal[AgentGuardrailActionType.BLOCK] = Field(
+        alias="$actionType", default=AgentGuardrailActionType.BLOCK, frozen=True
+    )
+    reason: str
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailFilterAction(BaseModel):
+    """Agent guardrail filter action model."""
+
+    action_type: Literal[AgentGuardrailActionType.FILTER] = Field(
+        alias="$actionType", default=AgentGuardrailActionType.FILTER, frozen=True
+    )
+    fields: List[FieldReference]
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailSeverityLevel(str, CaseInsensitiveEnum):
+    """Severity level enumeration."""
+
+    ERROR = "Error"
+    INFO = "Info"
+    WARNING = "Warning"
+
+
+class AgentGuardrailLogAction(BaseModel):
+    """Agent guardrail log action model."""
+
+    action_type: Literal[AgentGuardrailActionType.LOG] = Field(
+        alias="$actionType", default=AgentGuardrailActionType.LOG, frozen=True
+    )
+    message: Optional[str] = Field(None, alias="message")
+    severity_level: AgentGuardrailSeverityLevel = Field(alias="severityLevel")
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailEscalateActionApp(BaseModel):
+    """Agent guardrail escalate action app model."""
+
+    id: Optional[str] = None
+    version: int
+    name: str
+    folder_id: Optional[str] = Field(None, alias="folderId")
+    folder_name: str = Field(alias="folderName")
+    app_process_key: Optional[str] = Field(None, alias="appProcessKey")
+    runtime: Optional[str] = None
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailEscalateAction(BaseModel):
+    """Agent guardrail escalate action model."""
+
+    action_type: Literal[AgentGuardrailActionType.ESCALATE] = Field(
+        alias="$actionType", default=AgentGuardrailActionType.ESCALATE, frozen=True
+    )
+    app: AgentGuardrailEscalateActionApp
+    recipient: "AgentEscalationRecipient"  # forward ref ok
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailUnknownAction(BaseModel):
+    """Fallback for unknown guardrail actions."""
+
+    action_type: Literal[AgentGuardrailActionType.UNKNOWN] = Field(
+        alias="$actionType", default=AgentGuardrailActionType.UNKNOWN, frozen=True
+    )
+    # Accept arbitrary payload for forward-compat
+    details: Optional[Dict[str, Any]] = None
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+GuardrailAction = Annotated[
+    Union[
+        AgentGuardrailBlockAction,
+        AgentGuardrailFilterAction,
+        AgentGuardrailLogAction,
+        AgentGuardrailEscalateAction,
+        AgentGuardrailUnknownAction,  # when parent sets $actionType="unknown"
+    ],
+    Field(discriminator="action_type"),
+    _case_insensitive_enum_validator(
+        "action_type", AgentGuardrailActionType, "$actionType"
+    ),
+]
+
+
+class AgentBuiltInValidatorGuardrail(BuiltInValidatorGuardrail):
+    """Agent built-in validator guardrail with action capabilities."""
+
+    action: GuardrailAction = Field(
+        ..., description="Action to take when guardrail is triggered"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentWordOperator(str, CaseInsensitiveEnum):
+    """Word operator enumeration."""
+
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "doesNotContain"
+    DOES_NOT_END_WITH = "doesNotEndWith"
+    DOES_NOT_EQUAL = "doesNotEqual"
+    DOES_NOT_START_WITH = "doesNotStartWith"
+    ENDS_WITH = "endsWith"
+    EQUALS = "equals"
+    IS_EMPTY = "isEmpty"
+    IS_NOT_EMPTY = "isNotEmpty"
+    MATCHES_REGEX = "matchesRegex"
+    STARTS_WITH = "startsWith"
+
+
+class AgentWordRule(BaseModel):
+    """Word rule model."""
+
+    rule_type: Literal["word"] = Field(alias="$ruleType")
+    field_selector: AgentFieldSelector = Field(alias="fieldSelector")
+    operator: AgentWordOperator
+    value: str | None = None
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentAllFieldsSelector(BaseModel):
+    """All fields selector."""
+
+    selector_type: Literal["all"] = Field(alias="$selectorType")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+AgentFieldSelector = Annotated[
+    AgentAllFieldsSelector | SpecificFieldsSelector,
+    Field(discriminator="selector_type"),
+]
+
+
+class AgentNumberOperator(str, CaseInsensitiveEnum):
+    """Number operator enumeration."""
+
+    DOES_NOT_EQUAL = "doesNotEqual"
+    EQUALS = "equals"
+    GREATER_THAN = "greaterThan"
+    GREATER_THAN_OR_EQUAL = "greaterThanOrEqual"
+    LESS_THAN = "lessThan"
+    LESS_THAN_OR_EQUAL = "lessThanOrEqual"
+
+
+class AgentNumberRule(BaseModel):
+    """Number rule model."""
+
+    rule_type: Literal["number"] = Field(alias="$ruleType")
+    field_selector: AgentFieldSelector = Field(alias="fieldSelector")
+    operator: AgentNumberOperator
+    value: float
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentBooleanOperator(str, CaseInsensitiveEnum):
+    """Boolean operator enumeration."""
+
+    EQUALS = "equals"
+
+
+class AgentBooleanRule(BaseModel):
+    """Boolean rule model."""
+
+    rule_type: Literal["boolean"] = Field(alias="$ruleType")
+    field_selector: AgentFieldSelector = Field(alias="fieldSelector")
+    operator: AgentBooleanOperator
+    value: bool
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+AgentRule = Annotated[
+    AgentWordRule | AgentNumberRule | AgentBooleanRule | UniversalRule,
+    Field(discriminator="rule_type"),
+]
+
+
+class AgentCustomGuardrail(BaseGuardrail):
+    """Agent custom guardrail with action capabilities."""
+
+    guardrail_type: Literal["custom"] = Field(alias="$guardrailType")
+    rules: list[AgentRule]
+
+    action: GuardrailAction = Field(
+        ..., description="Action to take when guardrail is triggered"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentUnknownGuardrail(BaseCfg):
+    """Fallback wrapper for unknown guardrail kinds."""
+
+    guardrail_type: Literal["unknown"] = Field(
+        alias="$guardrailType", default="unknown", frozen=True
+    )
+    # store the original payload under 'raw' for round-trip/debug
+    raw: Dict[str, Any]
+
+
+AgentGuardrail = Annotated[
+    Union[
+        # known kinds from SDK
+        AgentCustomGuardrail,
+        AgentBuiltInValidatorGuardrail,
+        # unknown kind fallback
+        AgentUnknownGuardrail,
+    ],
+    Field(discriminator="guardrail_type"),
+]
+
+
+class AgentMetadata(BaseCfg):
+    """Agent metadata model."""
+
+    is_conversational: bool = Field(alias="isConversational")
+    variant: Optional[AgentVariant] = Field(default=None, alias="variant")
+    storage_version: str = Field(alias="storageVersion")
+
+
+class AgentMessage(BaseCfg):
+    """Agent message model."""
+
+    role: AgentMessageRole
+    content: str
+    content_tokens: Optional[List[TextToken]] = Field(None, alias="contentTokens")
+
+
+class AgentByomProperties(BaseCfg):
+    """Agent byom properties model."""
+
+    connection_id: str = Field(alias="connectionId")
+    connector_key: str = Field(alias="connectorKey")
+
+
+class AgentSettings(BaseCfg):
+    """Agent settings model."""
+
+    engine: str
+    model: str
+    max_tokens: int = Field(..., alias="maxTokens")
+    temperature: float
+    byom_properties: Optional[AgentByomProperties] = Field(None, alias="byomProperties")
+    max_iterations: Optional[int] = Field(None, alias="maxIterations")
+    persona: Optional[str] = Field(None, alias="persona")
+
+
+class AgentDefinition(BaseModel):
+    """Unified agent definition with parent-level normalization for guardrails and resources."""
+
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
+    output_schema: Dict[str, Any] = Field(..., alias="outputSchema")
+    guardrails: Optional[List[AgentGuardrail]] = Field(None)
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    metadata: Optional[AgentMetadata] = None
+    messages: List[AgentMessage]
+
+    version: str = "1.0.0"
+    resources: List[AgentResourceConfig] = Field(default_factory=list)
+    features: List[Any] = Field(default_factory=list)
+    settings: AgentSettings
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+    @property
+    def is_conversational(self) -> bool:
+        """Checks the settings.engine property to determine if the agent is conversational."""
+        if hasattr(self, "metadata") and self.metadata:
+            metadata = self.metadata
+            if hasattr(metadata, "is_conversational"):
+                return metadata.is_conversational
+        return False
+
+    @property
+    def is_case_manager(self) -> bool:
+        """Checks if the agent is a case manager agent."""
+        if not self.metadata:
+            return False
+        return self.metadata.variant == AgentVariant.CASE_MANAGER
+
+    @staticmethod
+    def _normalize_guardrails(v: Dict[str, Any]) -> None:
+        guards = v.get("guardrails")
+        if not isinstance(guards, list):
+            return
+
+        normalized = []
+        for g in guards:
+            if not isinstance(g, dict):
+                normalized.append(g)
+                continue
+
+            gt = g.get("$guardrailType") or g.get("guardrail_type")
+            # Normalize to the expected discriminator values
+            if isinstance(gt, str):
+                gt_lower = gt.lower()
+                if gt_lower == "custom":
+                    g["$guardrailType"] = "custom"
+                elif gt_lower == "builtinvalidator":
+                    g["$guardrailType"] = "builtInValidator"
+                else:
+                    # Unknown guardrail type
+                    normalized.append({"guardrail_type": "unknown", "raw": g})
+                    continue
+            else:
+                # Non-string guardrail type
+                normalized.append({"guardrail_type": "unknown", "raw": g})
+                continue
+
+            # Normalize the action if present
+            action = g.get("action")
+            if isinstance(action, dict):
+                at = action.get("$actionType")
+                if isinstance(at, str):
+                    at_lower = at.lower()
+                    if at_lower in {"block", "filter", "log", "escalate"}:
+                        # Valid action type, keep as-is or normalize case if needed
+                        g["action"]["$actionType"] = at_lower
+                    else:
+                        # Unknown action type
+                        g["action"] = {"$actionType": "unknown", "details": action}
+                else:
+                    # Non-string action type
+                    g["action"] = {"$actionType": "unknown", "details": action}
+
+            normalized.append(g)
+
+        v["guardrails"] = normalized
+
+    @staticmethod
+    def _normalize_resources(v: Dict[str, Any]) -> None:
+        KNOWN_RES = {"tool", "context", "escalation", "mcp", "a2a"}
+        TOOL_MAP = {
+            "agent": "Agent",
+            "process": "Process",
+            "api": "Api",
+            "processorchestration": "ProcessOrchestration",
+            "flow": "Flow",
+            "function": "Function",
+            "integration": "Integration",
+            "internal": "Internal",
+            "ixp": "Ixp",
+            "clientside": "ClientSide",
+            "unknown": "Unknown",
+        }
+        CONTEXT_MODE_MAP = {
+            "semantic": "Semantic",
+            "structured": "Structured",
+            "deeprag": "DeepRAG",
+            "batchtransform": "BatchTransform",
+            "datafabric": "DataFabric",
+            "unknown": "Unknown",
+        }
+
+        res_list = v.get("resources")
+        if not isinstance(res_list, list):
+            return
+
+        out = []
+        for res in res_list:
+            if not isinstance(res, dict):
+                out.append(res)
+                continue
+
+            rt = res.get("$resourceType") or res.get("resource_type")
+            res["$resourceType"] = (
+                rt.lower()
+                if isinstance(rt, str) and rt.lower() in KNOWN_RES
+                else "unknown"
+            )
+
+            if res["$resourceType"] == "tool":
+                t = res.get("type")
+                res["type"] = (
+                    TOOL_MAP.get(t.lower(), "Unknown")
+                    if isinstance(t, str)
+                    else "Unknown"
+                )
+
+            if res["$resourceType"] == "context":
+                settings = res.get("settings")
+                if settings is not None:
+                    rm = settings.get("retrievalMode") or settings.get("retrieval_mode")
+                    settings["retrievalMode"] = (
+                        CONTEXT_MODE_MAP.get(rm.lower(), "Unknown")
+                        if isinstance(rm, str)
+                        else "Unknown"
+                    )
+                    res["settings"] = settings
+
+            out.append(res)
+
+        v["resources"] = out
+
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_all(cls, v: Any) -> Any:
+        if not isinstance(v, dict):
+            return v
+        normalize_legacy_format(v)
+        cls._normalize_guardrails(v)
+        cls._normalize_resources(v)
+        return v
+
+
+LowCodeAgentDefinition = AgentDefinition
diff --git a/packages/uipath/src/uipath/agent/models/evals.py b/packages/uipath/src/uipath/agent/models/evals.py
new file mode 100644
index 000000000..6bc94bad4
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/models/evals.py
@@ -0,0 +1,27 @@
+"""Agent Evaluation Models.
+
+These models extend the base agent models with evaluation and simulation-specific fields.
+"""
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from uipath.agent.models.agent import (
+    AgentDefinition,
+)
+from uipath.eval.evaluators.evaluator import Evaluator
+from uipath.eval.models.evaluation_set import EvaluationSet
+
+
+class AgentEvalsDefinition(AgentDefinition):
+    """Agent definition with evaluation sets and evaluators support."""
+
+    evaluation_sets: Optional[List[EvaluationSet]] = Field(
+        None,
+        alias="evaluationSets",
+        description="List of agent evaluation sets",
+    )
+    evaluators: Optional[List[Evaluator]] = Field(
+        None, description="List of agent evaluators"
+    )
diff --git a/packages/uipath/src/uipath/agent/react/__init__.py b/packages/uipath/src/uipath/agent/react/__init__.py
new file mode 100644
index 000000000..835fd0bda
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/react/__init__.py
@@ -0,0 +1,30 @@
+"""UiPath ReAct Agent Constructs.
+
+This module includes UiPath ReAct Agent Loop constructs such as prompts, tools
+"""
+
+from .conversational_prompts import (
+    PromptUserSettings,
+    get_chat_system_prompt,
+)
+from .conversational_voice_prompts import get_voice_system_prompt
+from .prompts import AGENT_SYSTEM_PROMPT_TEMPLATE
+from .tools import (
+    END_EXECUTION_TOOL,
+    RAISE_ERROR_TOOL,
+    EndExecutionToolSchemaModel,
+    FlowControlToolConfig,
+    RaiseErrorToolSchemaModel,
+)
+
+__all__ = [
+    "AGENT_SYSTEM_PROMPT_TEMPLATE",
+    "FlowControlToolConfig",
+    "END_EXECUTION_TOOL",
+    "RAISE_ERROR_TOOL",
+    "EndExecutionToolSchemaModel",
+    "RaiseErrorToolSchemaModel",
+    "PromptUserSettings",
+    "get_chat_system_prompt",
+    "get_voice_system_prompt",
+]
diff --git a/packages/uipath/src/uipath/agent/react/conversational_prompts.py b/packages/uipath/src/uipath/agent/react/conversational_prompts.py
new file mode 100644
index 000000000..f79de6185
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/react/conversational_prompts.py
@@ -0,0 +1,235 @@
+"""Conversational agent prompt generation logic."""
+
+import json
+import logging
+from datetime import datetime, timezone
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class PromptUserSettings(BaseModel):
+    """User settings for inclusion in the system prompt."""
+
+    name: str | None = None
+    email: str | None = None
+    role: str | None = None
+    department: str | None = None
+    company: str | None = None
+    country: str | None = None
+    timezone: str | None = None
+
+
+_AGENT_SYSTEM_PROMPT_PREFIX_TEMPLATE = """You are {{CONVERSATIONAL_AGENT_SERVICE_PREFIX_agentName}}.
+The current date is: {{CONVERSATIONAL_AGENT_SERVICE_PREFIX_currentDate}}.
+Understand user goals through conversation and use appropriate tools to fulfill requests.
+
+=====================================================================
+PRECEDENCE HIERARCHY
+=====================================================================
+1. Core System Instructions (highest authority)
+2. Agent System Prompt
+3. Tool definitions and parameter schemas
+4. User instructions and follow-up messages
+
+When conflicts occur, follow the highest-precedence rule above.
+
+=====================================================================
+AGENT SYSTEM PROMPT
+=====================================================================
+{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_systemPrompt}}
+
+{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_attachmentsPrompt}}
+
+{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_userSettingsPrompt}}
+
+=====================================================================
+TOOL USAGE RULES
+=====================================================================
+Parameter Resolution Priority:
+1. Check tool definitions for pre-configured values
+2. Use conversation context
+3. Ask user only if unavailable
+
+Execution:
+- Use tools ONLY with complete, specific data for all required parameters
+- NEVER use placeholders or incomplete information
+- Call independent tools in parallel when possible
+
+On Missing Data:
+- Ask user for specifics before proceeding
+- Never attempt calls with incomplete data
+- On errors: modify parameters or change approach (never retry identical calls)
+
+{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_conversationIdPrompt}}
+
+=====================================================================
+TOOL RESULTS
+=====================================================================
+Tool results contain:
+- status: "success" or "error"
+- data: result payload or exception details
+
+Rules:
+- For "success": check data for actual results
+- For "error": summarize issue and adjust approach
+
+=====================================================================
+CITATION RULES
+=====================================================================
+Citations will be parsed into the user interface.
+
+WHAT TO CITE:
+- Any information drawn from web search results.
+- Any information drawn from Context Grounding documents.
+
+CITATION FORMAT (self-closing tag after each sentence with cited information):
+- Web results: <uip:cite title="Document Title" url="https://url"/>
+- Context Grounding: <uip:cite title="Document Title" reference="https://url" page_number="1"/>
+
+TOOL RESULT PATTERNS REQUIRING CITATION:
+Tool results containing these fields indicate citable sources:
+- Web results: "url", "title" fields -> use url, title attributes
+- Context Grounding: objects with "reference", "source", "page_number" -> use reference, title (from source), page_number attributes
+
+RULES:
+- Place citation tag immediately after the sentence containing the cited fact
+- title attribute is required (truncate to 48 chars if needed)
+- For web results: use title and url attributes
+- For context grounding: use title, reference, and page_number attributes
+- Never include citations in tool inputs
+- Do not mix attributes between citation types: web results use only title/url, context grounding uses only title/reference/page_number
+- Do not add a space before the citation tag
+
+EXAMPLES OF CORRECT USAGE:
+AI adoption is growing rapidly.<uip:cite title="Industry Study" url="https://example.com/study"/>
+The procedure requires manager approval.<uip:cite title="Policy Manual v2.pdf" reference="https://docs.example.com/ref" page_number="15"/>
+
+CRITICAL ERRORS TO AVOID:
+<uip:cite/> (missing attributes)
+<uip:cite title=""/> (empty title)
+Putting all citations at the very end of the response instead of after each sentence
+
+=====================================================================
+EXECUTION CHECKLIST
+=====================================================================
+Before each tool call, verify:
+1. Pre-configured values have been checked
+2. All parameters are complete and specific
+
+If execution cannot proceed:
+- State why
+- Request missing or clarifying information"""
+
+_ATTACHMENTS_TEMPLATE = """=====================================================================
+ATTACHMENTS
+=====================================================================
+- You are capable of working with job attachments. Job attachments are file references.
+- If the user has attached files, they will be in the format of <uip:attachments>[...]</uip:attachments> in the user message. Example: <uip:attachments>[{"ID":"123","Type":"JobAttachment","FullName":"example.json","MimeType":"application/json","Metadata":{"key1":"value1","key2":"value2"}}]</uip:attachments>
+- You must send only the JobAttachment ID as the parameter values to a tool that accepts job attachments.
+- If the attachment ID is passed and not found, suggest the user to upload the file again."""
+
+_USER_CONTEXT_TEMPLATE = """=====================================================================
+USER CONTEXT
+=====================================================================
+You have the following information about the user:
+```json
+{user_settings_json}
+```"""
+
+_CONVERSATION_ID_TEMPLATE = """
+The current conversation ID is {conversation_id}. This may be useful to include in tool-calls when tool parameters specify passing in the conversation ID. Other than tool-call inputs, this ID should not be mentioned to the user.
+"""
+
+
+def get_chat_system_prompt(
+    model: str,
+    system_message: str,
+    agent_name: str | None,
+    user_settings: PromptUserSettings | None = None,
+    conversation_id: str | None = None,
+) -> str:
+    """Generate a system prompt for a conversational agent.
+
+    Args:
+        model: Model identifier.
+        system_message: The agent system prompt content.
+        agent_name: The agent display name; defaults to "Unnamed Agent" when None.
+        user_settings: Optional user data that is injected into the system prompt.
+        conversation_id: Optional conversation identifier that is injected into the system prompt.
+
+    Returns:
+        The complete system prompt string
+    """
+    # Format date as ISO 8601 (yyyy-MM-ddTHH:mmZ)
+    formatted_date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
+
+    prompt = _AGENT_SYSTEM_PROMPT_PREFIX_TEMPLATE
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_agentName}}",
+        agent_name or "Unnamed Agent",
+    )
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_currentDate}}",
+        formatted_date,
+    )
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_systemPrompt}}",
+        system_message,
+    )
+    # Always include attachments prompt
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_attachmentsPrompt}}",
+        _ATTACHMENTS_TEMPLATE,
+    )
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_userSettingsPrompt}}",
+        get_user_settings_template(user_settings),
+    )
+    prompt = prompt.replace(
+        "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_conversationIdPrompt}}",
+        get_conversation_id_template(conversation_id),
+    )
+
+    return prompt
+
+
+def get_user_settings_template(
+    user_settings: PromptUserSettings | None,
+) -> str:
+    """Get the user settings template section.
+
+    Args:
+        user_settings: User profile information
+
+    Returns:
+        The filled-in user settings template if user_settings is provided, otherwise an empty string
+    """
+    if user_settings is None:
+        return ""
+
+    # Convert to dict, filtering out None values
+    settings_dict = {
+        k: v for k, v in user_settings.model_dump().items() if v is not None
+    }
+
+    if not settings_dict:
+        return ""
+
+    user_settings_json = json.dumps(settings_dict, ensure_ascii=False)
+    return _USER_CONTEXT_TEMPLATE.format(user_settings_json=user_settings_json)
+
+
+def get_conversation_id_template(conversation_id: str | None) -> str:
+    """Get the conversation ID prompt section.
+
+    Args:
+        conversation_id: The ID of the current conversation, if any
+
+    Returns:
+        The filled-in conversation ID template if conversation_id is provided, otherwise an empty string
+    """
+    if not conversation_id:
+        return ""
+    return _CONVERSATION_ID_TEMPLATE.format(conversation_id=conversation_id)
diff --git a/packages/uipath/src/uipath/agent/react/conversational_voice_prompts.py b/packages/uipath/src/uipath/agent/react/conversational_voice_prompts.py
new file mode 100644
index 000000000..3e6036b12
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/react/conversational_voice_prompts.py
@@ -0,0 +1,53 @@
+"""Conversational voice agent prompt generation logic."""
+
+from datetime import datetime, timezone
+
+from .conversational_prompts import PromptUserSettings, get_user_settings_template
+
+_VOICE_SYSTEM_PROMPT_TEMPLATE = """You are {{VOICE_AGENT_PREFIX_agentName}}.
+The current date is: {{VOICE_AGENT_PREFIX_currentDate}}.
+
+=====================================================================
+AGENT SYSTEM PROMPT
+=====================================================================
+{{VOICE_AGENT_PREFIX_systemPrompt}}
+
+{{VOICE_AGENT_PREFIX_userSettingsPrompt}}
+
+=====================================================================
+TOOL USAGE RULES
+=====================================================================
+Use the end call tool to end the call when:
+- The primary objective of the call has been fulfilled and the user confirms they have no further questions
+- The user explicitly asks to end the call or says goodbye
+
+"""
+
+
+def get_voice_system_prompt(
+    system_message: str,
+    agent_name: str | None,
+    user_settings: PromptUserSettings | None = None,
+) -> str:
+    """Build the full voice system prompt with agent name, date, and optional user context."""
+    formatted_date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
+
+    prompt = _VOICE_SYSTEM_PROMPT_TEMPLATE
+    prompt = prompt.replace(
+        "{{VOICE_AGENT_PREFIX_agentName}}",
+        agent_name or "Voice Assistant",
+    )
+    prompt = prompt.replace(
+        "{{VOICE_AGENT_PREFIX_currentDate}}",
+        formatted_date,
+    )
+    prompt = prompt.replace(
+        "{{VOICE_AGENT_PREFIX_systemPrompt}}",
+        system_message,
+    )
+    prompt = prompt.replace(
+        "{{VOICE_AGENT_PREFIX_userSettingsPrompt}}",
+        get_user_settings_template(user_settings),
+    )
+
+    return prompt
diff --git a/packages/uipath/src/uipath/agent/react/prompts.py b/packages/uipath/src/uipath/agent/react/prompts.py
new file mode 100644
index 000000000..81ee4e3f6
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/react/prompts.py
@@ -0,0 +1,57 @@
+"""ReAct Agent Meta Prompts."""
+
+AGENT_SYSTEM_PROMPT_TEMPLATE = """
+You are an advanced automatic agent equipped with a variety of tools to assist users.
+Your primary function is to understand the user goal and utilize the appropriate tools at your disposal to fulfill it.
+The current date is: {{currentDate}}
+Your name is: {{agentName}}
+
+{{systemPrompt}}
+
+You adhere strictly to the following rules to ensure accuracy and data validity:
+
+<rules>
+Data Verification and Tool Analysis:
+- **Tool Inspection:** ALWAYS examine tool definitions thoroughly for any pre-configured or hardcoded parameter values before requesting information from the user.
+- **Pre-configured Parameter Usage:** If a parameter is pre-configured or hardcoded, use it directly without asking the user for it.
+- Specificity: Ensure **all information used as tool arguments is concrete and specific**. Utilize values provided in tool definitions when available.
+- Complete tasks accurately or clearly state why it cannot be done. Never proceed with incomplete or invalid information in tool arguments.
+
+Tool Usage:
+- **Parameter Resolution:** First check tool definitions for any pre-configured values, then use available context, and only then request missing information from the user.
+- **Preconditions:** Use a tool only when all required parameters have verified, specific data.
+- **Avoid Incomplete Calls:** Do not use tools if any parameter lacks specific data or would require placeholders.
+
+Handling Missing Information:
+- **End Execution:** If specific data is missing and no tool is available to obtain it, terminate the process using `end_execution` with a clear reason.
+- **No Placeholder Use:** Do not attempt to use tools with incomplete or placeholder information.
+
+Execution Steps:
+- **Step-by-Step Approach:** Break down user requests into required steps and gather necessary information sequentially.
+- **Verification:** Explicitly verify each piece of required information for specificity and validity before proceeding.
+- **Reasoning:** Begin by explaining your reasoning in plain text for each tool call.
+- **Tool Calls:** You can invoke tools, following a logical order where dependent actions occur after their prerequisites.
+- **End execution:** When you have no more steps to perform or you reached a point where you cannot proceed, use the end_execution tool to end the execution.
+</rules>
+
+<examples>
+**Example 1: Valid Data Available**
+User Request: "Schedule a meeting with Alice at 10 AM on October 9th 2023."
+Your Response: I will schedule a meeting with Alice at 10 AM on October 9th 2023.
+Tool: schedule_meeting
+Payload: { contact: "Alice", time: "2023-10-09T10:00:00" }
+
+**Example 2: Missing Data Without Retrieval Tool:**
+User Request: "Book a flight to Paris."
+Your Response: Cannot proceed because the departure location and date are missing, and no tool is available to obtain this information.
+Tool: raise_error
+Payload: { message: "Missing departure location and date.", details: "Cannot proceed because the departure location and date are missing and no tool is available to obtain this information"}
+
+**Example 3: Pre-configured Parameter Usage:**
+User Request: "Retrieve specific details."
+Your Response: I will retrieve the details using the pre-configured parameter value.
+Tool: example_tool
+Payload: { parameterName: "preConfiguredValue" }
+
+</examples>
+"""
diff --git a/packages/uipath/src/uipath/agent/react/tools.py b/packages/uipath/src/uipath/agent/react/tools.py
new file mode 100644
index 000000000..c2a162be9
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/react/tools.py
@@ -0,0 +1,74 @@
+"""UiPath ReAct Agent Control Flow Tools."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FlowControlToolName(str, Enum):
+    """Names of control flow tools."""
+
+    END_EXECUTION = "end_execution"
+    RAISE_ERROR = "raise_error"
+
+
+@dataclass(frozen=True)
+class FlowControlToolConfig:
+    """Flow control tool configuration.
+
+    Encapsulates the information needed to create a flow control tool
+    """
+
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+
+
+class EndExecutionToolSchemaModel(BaseModel):
+    """Arguments schema accepted by the `end_execution` control flow tool."""
+
+    success: bool = Field(
+        ...,
+        description="Whether the execution was successful",
+    )
+    message: str | None = Field(
+        None,
+        description="The message to return to the user if the execution was successful",
+    )
+    error: str | None = Field(
+        None,
+        description="The error message to return to the user if the execution was unsuccessful",
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class RaiseErrorToolSchemaModel(BaseModel):
+    """Arguments schema accepted by the `raise_error` control flow tool."""
+
+    message: str = Field(
+        ...,
+        description="The error message to display to the user. This should be a brief one line message.",
+    )
+    details: str | None = Field(
+        None,
+        description=(
+            "Optional additional details about the error. This can be a multiline text with more details. Only populate this if there are relevant details not already captured in the error message."
+        ),
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+END_EXECUTION_TOOL = FlowControlToolConfig(
+    name=FlowControlToolName.END_EXECUTION,
+    description="Ends the execution of the agent",
+    args_schema=EndExecutionToolSchemaModel,
+)
+
+RAISE_ERROR_TOOL = FlowControlToolConfig(
+    name=FlowControlToolName.RAISE_ERROR,
+    description="Raises an error and ends the execution of the agent",
+    args_schema=RaiseErrorToolSchemaModel,
+)
diff --git a/packages/uipath/src/uipath/agent/utils/__init__.py b/packages/uipath/src/uipath/agent/utils/__init__.py
new file mode 100644
index 000000000..0caacd3c4
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/utils/__init__.py
@@ -0,0 +1,18 @@
+"""UiPath Agent utilities module.
+
+This module provides utility functions for agent operations.
+"""
+
+from ._utils import (
+    create_agent_project,
+    download_agent_project,
+    get_file,
+    load_agent_definition,
+)
+
+__all__ = [
+    "create_agent_project",
+    "download_agent_project",
+    "get_file",
+    "load_agent_definition",
+]
diff --git a/packages/uipath/src/uipath/agent/utils/_utils.py b/packages/uipath/src/uipath/agent/utils/_utils.py
new file mode 100644
index 000000000..539c735f7
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/utils/_utils.py
@@ -0,0 +1,139 @@
+import json
+import logging
+from pathlib import Path, PurePath
+from typing import Any, Optional
+
+from httpx import Response
+from pydantic import TypeAdapter
+
+from uipath._cli._utils._project_files import pull_project
+from uipath._cli._utils._studio_project import (
+    ProjectFile,
+    ProjectFolder,
+    StudioClient,
+    StudioSolutionsClient,
+    resolve_path,
+)
+from uipath.agent.models.agent import (
+    AgentDefinition,
+)
+from uipath.agent.models.evals import AgentEvalsDefinition
+from uipath.eval.constants import EVALS_FOLDER
+from uipath.eval.helpers import EvalHelpers
+
+logger = logging.getLogger(__name__)
+
+
+async def get_file(
+    folder: ProjectFolder, path: PurePath, studio_client: StudioClient
+) -> Response:
+    resolved = resolve_path(folder, path)
+    assert isinstance(resolved, ProjectFile), "Path file not found."
+    return await studio_client.download_project_file_async(resolved)
+
+
+async def create_agent_project(
+    solution_id: str, project_name: str, description: Optional[str] = None
+) -> str:
+    studio_client = StudioSolutionsClient(solution_id=solution_id)
+    project = await studio_client.create_project_async(
+        project_name=project_name, description=description
+    )
+    return project["id"]
+
+
+async def download_agent_project(
+    project_id: str,
+    target_project_dir: Path,
+) -> None:
+    """Downloads all project files to the target directory.
+
+    Args:
+        project_id: The project ID to download from
+        target_project_dir: Directory where files will be downloaded
+    """
+    default_download_configuration: dict[str | None, Path] = {
+        None: target_project_dir,
+    }
+
+    studio_client = StudioClient(project_id)
+    logger.info(f"Downloading project {project_id}...")
+    async for update in pull_project(
+        project_id, default_download_configuration, studio_client
+    ):
+        logger.info(update.message)
+
+    logger.info(f"Successfully downloaded project {project_id}.")
+
+
+def load_agent_definition(
+    target_project_dir: Path,
+) -> AgentDefinition:
+    """Loads agent definition from downloaded files and applies migrations.
+
+    Args:
+        target_project_dir: Directory containing the downloaded files
+
+    Returns:
+        AgentDefinition with migrations applied
+    """
+    # Load agent definition from downloaded files
+    agent_definition_path = target_project_dir / "agent.json"
+
+    agent: dict[str, Any] = {}
+    with open(agent_definition_path) as f:
+        agent = json.load(f)
+
+    # Load resources from downloaded files
+    resources = agent.get("resources", []) if "resources" in agent else []
+    resources_dir = target_project_dir / "resources"
+    if resources_dir.exists() and resources_dir.is_dir():
+        for file_path in resources_dir.rglob("*.json"):
+            try:
+                with open(file_path) as f:
+                    resources.append(json.load(f))
+            except Exception as e:
+                logger.warning(f"Failed to load resource from {file_path}: {e}")
+
+    # Load evaluators from downloaded files
+    evaluators = []
+    evaluators_dir = target_project_dir / EVALS_FOLDER / "evaluators"
+    if evaluators_dir.exists() and evaluators_dir.is_dir():
+        for file_path in evaluators_dir.glob("*.json"):
+            try:
+                with open(file_path) as f:
+                    evaluators.append(json.load(f))
+            except Exception as e:
+                logger.warning(f"Failed to load evaluator from {file_path}: {e}")
+    else:
+        logger.warning(
+            "Unable to read evaluators from project. Defaulting to empty evaluators."
+        )
+
+    # Load evaluation sets from downloaded files
+    evaluation_sets = []
+    eval_sets_dir = target_project_dir / EVALS_FOLDER / "eval-sets"
+    if eval_sets_dir.exists() and eval_sets_dir.is_dir():
+        for file_path in eval_sets_dir.glob("*.json"):
+            evaluation_set, _ = EvalHelpers.load_eval_set(str(file_path))
+            evaluation_sets.append(evaluation_set)
+    else:
+        logger.warning(
+            "Unable to read eval-sets from project. Defaulting to empty eval-sets."
+        )
+
+    # Construct agent definition dictionary
+    agent_definition_dict = {
+        "evaluators": evaluators,
+        "evaluationSets": evaluation_sets,
+        **agent,
+        "resources": resources,  # This overrides agent["resources"] if it exists
+    }
+
+    # Validate and create AgentDefinition
+    agent_definition = TypeAdapter(AgentEvalsDefinition).validate_python(
+        agent_definition_dict
+    )
+
+    logger.info("Successfully loaded agent definition.")
+    return agent_definition
diff --git a/packages/uipath/src/uipath/agent/utils/text_tokens.py b/packages/uipath/src/uipath/agent/utils/text_tokens.py
new file mode 100644
index 000000000..ea60ef52f
--- /dev/null
+++ b/packages/uipath/src/uipath/agent/utils/text_tokens.py
@@ -0,0 +1,138 @@
+"""Text token utilities for building prompts from tokenized content."""
+
+import json
+from typing import Any
+
+from uipath.agent.models.agent import TextToken, TextTokenType
+
+
+def build_string_from_tokens(
+    tokens: list[TextToken],
+    input_arguments: dict[str, Any],
+    tool_names: list[str] | None = None,
+    escalation_names: list[str] | None = None,
+    context_names: list[str] | None = None,
+) -> str:
+    """Build a string from text tokens with variable replacement.
+
+    Args:
+        tokens: List of text tokens to join
+        input_arguments: Dictionary of input arguments for variable replacement
+        tool_names: Optional list of tool names for tool.* variable resolution
+        escalation_names: Optional list of escalation names for escalation.* variable resolution
+        context_names: Optional list of context names for context.* variable resolution
+    """
+    parts: list[str] = []
+
+    for token in tokens:
+        if token.type == TextTokenType.SIMPLE_TEXT:
+            parts.append(token.raw_string)
+        elif token.type == TextTokenType.EXPRESSION:
+            parts.append(token.raw_string)
+        elif token.type == TextTokenType.VARIABLE:
+            resolved_value = _process_variable_token(
+                token.raw_string,
+                input_arguments,
+                tool_names,
+                escalation_names,
+                context_names,
+            )
+            parts.append(resolved_value)
+        else:
+            parts.append(token.raw_string)
+
+    return "".join(parts)
+
+
+def _process_variable_token(
+    raw_string: str,
+    input_arguments: dict[str, Any],
+    tool_names: list[str] | None = None,
+    escalation_names: list[str] | None = None,
+    context_names: list[str] | None = None,
+) -> str:
+    """Process a variable token and return its resolved value.
+
+    Returns:
+        The resolved variable value or original string if unresolved
+    """
+    if not raw_string or not raw_string.strip():
+        return raw_string
+
+    if raw_string.lower() == "input":
+        return json.dumps(input_arguments, ensure_ascii=False)
+
+    dot_index = raw_string.find(".")
+    if dot_index < 0:
+        return raw_string
+
+    prefix = raw_string[:dot_index].lower()
+    path = raw_string[dot_index + 1 :]
+
+    if prefix == "input":
+        value = safe_get_nested(input_arguments, path)
+        return serialize_argument(value) if value is not None else raw_string
+    elif prefix == "output":
+        return path
+    elif prefix == "tools":
+        found_name = _find_resource_name(path, tool_names)
+        return found_name if found_name else raw_string
+    elif prefix == "escalations":
+        found_name = _find_resource_name(path, escalation_names)
+        return found_name if found_name else raw_string
+    elif prefix == "contexts":
+        found_name = _find_resource_name(path, context_names)
+        return found_name if found_name else raw_string
+
+    return raw_string
+
+
+def _find_resource_name(name: str, resource_names: list[str] | None) -> str | None:
+    """Find a resource name in the list.
+
+    Args:
+        name: The name to search for
+        resource_names: List of resource names to search in
+
+    Returns:
+        The matching resource name, or None if not found
+    """
+    if not resource_names:
+        return None
+
+    name_lower = name.lower()
+    return next(
+        (
+            resource_name
+            for resource_name in resource_names
+            if resource_name.lower() == name_lower
+        ),
+        None,
+    )
+
+
+def safe_get_nested(data: dict[str, Any], path: str) -> Any:
+    """Get nested dictionary value using dot notation (e.g., "user.email")."""
+    keys = path.split(".")
+    current = data
+
+    for key in keys:
+        if isinstance(current, dict) and key in current:
+            current = current[key]
+        else:
+            return None
+
+    return current
+
+
+def serialize_argument(
+    value: str | int | float | bool | list[Any] | dict[str, Any] | None,
+) -> str:
+    """Serialize value for interpolation: primitives as-is, collections as JSON."""
+    if value is None:
+        return ""
+    if isinstance(value, (list, dict, bool)):
+        return json.dumps(value, ensure_ascii=False)
+    if hasattr(value, "value"):
+        return serialize_argument(value.value)
+    return str(value)
diff --git a/packages/uipath/src/uipath/eval/_execution_context.py b/packages/uipath/src/uipath/eval/_execution_context.py
new file mode 100644
index 000000000..18596fddf
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/_execution_context.py
@@ -0,0 +1,44 @@
+"""Execution context variables and span collection shared between eval.runtime and eval.mocks.
+
+This is a leaf module with no internal dependencies (only opentelemetry),
+so it can be safely imported from anywhere without triggering circular imports.
+"""
+
+from collections import defaultdict
+from contextvars import ContextVar
+
+from opentelemetry.sdk.trace import ReadableSpan, Span
+
+
+class ExecutionSpanCollector:
+    """Collects spans as they are created during execution."""
+
+    def __init__(self):
+        # { execution_id -> list of spans }
+        self._spans: dict[str, list[ReadableSpan]] = defaultdict(list)
+
+    def add_span(self, span: Span, execution_id: str) -> None:
+        self._spans[execution_id].append(span)
+
+    def get_spans(self, execution_id: str) -> list[ReadableSpan]:
+        return self._spans.get(execution_id, [])
+
+    def clear(self, execution_id: str | None = None) -> None:
+        if execution_id:
+            self._spans.pop(execution_id, None)
+        else:
+            self._spans.clear()
+
+
+# Span collector for trace access during mocking
+span_collector_context: ContextVar[ExecutionSpanCollector | None] = ContextVar(
+    "span_collector", default=None
+)
+
+# Execution ID for the current evaluation item
+execution_id_context: ContextVar[str | None] = ContextVar("execution_id", default=None)
+
+# Evaluation set run ID (action ID) for grouping related LLM calls
+eval_set_run_id_context: ContextVar[str | None] = ContextVar(
+    "eval_set_run_id", default=None
+)
diff --git a/packages/uipath/src/uipath/eval/_helpers/__init__.py b/packages/uipath/src/uipath/eval/_helpers/__init__.py
new file mode 100644
index 000000000..7c034c3e1
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/_helpers/__init__.py
@@ -0,0 +1 @@
+"""Helper functions for evaluation process."""
diff --git a/packages/uipath/src/uipath/eval/_helpers/evaluators_helpers.py b/packages/uipath/src/uipath/eval/_helpers/evaluators_helpers.py
new file mode 100644
index 000000000..b639e631d
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/_helpers/evaluators_helpers.py
@@ -0,0 +1,710 @@
+import ast
+import json
+import re
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from typing import Any
+
+from opentelemetry.sdk.trace import ReadableSpan
+
+from ..models import (
+    ToolCall,
+    ToolOutput,
+)
+
+TOOL_NAME_ATTR = "tool.name"
+
+# Mirrors uipath_langchain.agent.tools.utils.sanitize_tool_name; pinned by TestSanitizedNameMatch.
+_TOOL_NAME_DISALLOWED = re.compile(r"[^a-zA-Z0-9_-]")
+
+
+def _sanitize_tool_name(name: str | None) -> str:
+    """Sanitise a tool name the same way the LangChain runtime does."""
+    if not name:
+        return ""
+    return _TOOL_NAME_DISALLOWED.sub("", "_".join(name.split()))[:64]
+
+
+COMPARATOR_MAPPINGS = {
+    ">": "gt",
+    "<": "lt",
+    ">=": "ge",
+    "<=": "le",
+    "=": "eq",
+    "==": "eq",
+    "!=": "ne",
+}
+
+COMMUNITY_agents_SUFFIX = "-community-agents"
+
+
+def _unsynthesized_tool_attrs(span: ReadableSpan) -> Mapping[str, Any] | None:
+    """Return span.attributes if this is a real tool invocation, else None."""
+    attrs = span.attributes
+    if (
+        not attrs
+        or attrs.get("tool.synthesized", False)
+        or not attrs.get(TOOL_NAME_ATTR)
+    ):
+        return None
+    return attrs
+
+
+def _match_key(actual_name: str, actual_id: str | None, expected_key: str) -> bool:
+    """Strict per-call kind: id-only when actual has one, sanitised-name otherwise — never cross-kind."""
+    if actual_id is not None:
+        return expected_key == actual_id
+    return _sanitize_tool_name(expected_key) == _sanitize_tool_name(actual_name)
+
+
+def _calls_match(actual, expected) -> bool:
+    """Strict per-call kind: id-only when actual has one, sanitised-name otherwise — never cross-kind."""
+    if actual.id is not None:
+        # Picker stores the id under `expected.name` when an id was chosen — honour either field.
+        expected_key = expected.id if expected.id is not None else expected.name
+        return actual.id == expected_key
+    return _sanitize_tool_name(actual.name) == _sanitize_tool_name(expected.name)
+
+
+def _parse_tool_args(input_value: Any) -> dict[str, Any]:
+    """Coerce a span's `input.value` into a dict of tool args.
+
+    Tries JSON first (handles `true`/`false`/`null` and double-quoted keys),
+    falls back to `ast.literal_eval` for Python literal syntax (single-quoted
+    dict repr). Returns `{}` for non-dict parsed values or any parse failure.
+    """
+    if isinstance(input_value, dict):
+        return input_value
+    if not isinstance(input_value, str):
+        return {}
+    try:
+        try:
+            parsed = json.loads(input_value)
+        except ValueError:  # JSONDecodeError is a ValueError
+            parsed = ast.literal_eval(input_value)
+    except (SyntaxError, ValueError):
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _tool_id_from(attrs: Mapping[str, Any]) -> str | None:
+    """Return the span's `tool.id` as a string when present, else None.
+
+    Uses `is not None` (not truthiness) so an id of 0 or '' isn't dropped.
+    """
+    tool_id = attrs.get("tool.id")
+    return str(tool_id) if tool_id is not None else None
+
+
+def _build_tool_call(span: ReadableSpan, include_args: bool) -> ToolCall | None:
+    """Build a ToolCall from a span, or None for synthesized / non-tool spans."""
+    attrs = _unsynthesized_tool_attrs(span)
+    if attrs is None:
+        return None
+    tool_name = str(attrs[TOOL_NAME_ATTR])
+    tool_id = _tool_id_from(attrs)
+    args = _parse_tool_args(attrs.get("input.value", {})) if include_args else {}
+    return ToolCall(name=tool_name, args=args, id=tool_id)
+
+
+def count_tool_calls_by_name_and_id(tool_calls: Sequence[ToolCall]) -> dict[str, int]:
+    """Bucket each call under its id when present, else its name — strict per-call kind, no cross-kind matching."""
+    counts: dict[str, int] = {}
+    for c in tool_calls:
+        key = c.id if c.id is not None else c.name
+        counts[key] = counts.get(key, 0) + 1
+    return counts
+
+
+def extract_tool_calls_names(spans: Sequence[ReadableSpan]) -> list[str]:
+    """Extract the tool call names from execution spans IN ORDER.
+
+    Args:
+        spans: List of ReadableSpan objects from agent execution.
+
+    Returns:
+        List of tool names in the order they were called.
+    """
+    tool_calls_names = []
+
+    for span in spans:
+        if (attrs := _unsynthesized_tool_attrs(span)) is not None:
+            tool_calls_names.append(str(attrs[TOOL_NAME_ATTR]))
+
+    return tool_calls_names
+
+
+def extract_tool_calls(
+    spans: Sequence[ReadableSpan],
+    include_args: bool = True,
+) -> list[ToolCall]:
+    """Extract the tool calls from execution spans.
+
+    Args:
+        spans: List of ReadableSpan objects from agent execution.
+        include_args: When False, skip parsing `input.value` and return
+            ToolCall objects with `args={}`. Use for evaluators that only
+            need name/id (count, order) — avoids a parse per span on large
+            traces.
+
+    Returns:
+        List of tool calls with their arguments.
+    """
+    return [c for s in spans if (c := _build_tool_call(s, include_args)) is not None]
+
+
+def extract_tool_calls_outputs(spans: Sequence[ReadableSpan]) -> list[ToolOutput]:
+    """Extract the outputs of the tool calls from execution spans.
+
+    Args:
+        spans: List of ReadableSpan objects from agent execution.
+
+    Returns:
+        List of tool calls outputs.
+    """
+    # After span normalization, the output.value should always be a dict with a content field
+    # We keep this list of potential output keys for extensibility purposes (e.g. frameworks without span normalization)
+    potential_output_keys = ["content"]
+    tool_calls_outputs = []
+    for span in spans:
+        if (attrs := _unsynthesized_tool_attrs(span)) is not None:
+            tool_name = str(attrs[TOOL_NAME_ATTR])
+            tool_id = _tool_id_from(attrs)
+            output = attrs.get("output.value", "")
+            final_output = ""
+
+            # Handle different output formats
+            if isinstance(output, str):
+                try:
+                    # Try to parse as JSON and extract content field
+                    parsed_output = json.loads(output)
+                    if isinstance(parsed_output, dict):
+                        for key in potential_output_keys:
+                            if key in parsed_output:
+                                final_output = parsed_output[key]
+                                break
+                    else:
+                        # If parsed JSON is not a dict, use the original string
+                        final_output = output
+                except (json.JSONDecodeError, ValueError):
+                    # If parsing fails, use the string as-is
+                    final_output = output
+            elif isinstance(output, dict):
+                # If output is already a dict, extract content field
+                for key in potential_output_keys:
+                    if key in output:
+                        final_output = output.get(key, "")
+                        break
+            else:
+                final_output = str(output)
+
+            tool_calls_outputs.append(
+                ToolOutput(
+                    name=tool_name,
+                    output=str(final_output) if final_output else "",
+                    id=tool_id,
+                )
+            )
+    return tool_calls_outputs
+
+
+def tool_calls_order_score(
+    actual_tool_calls_names: Sequence[str],
+    expected_tool_calls_names: Sequence[str],
+    strict: bool = False,
+) -> tuple[float, dict[str, Any]]:
+    """The function calculates a score based on LCS applied to the order of the tool calls.
+
+    It calculates the longest common subsequence between the actual tool calls
+    and the expected tool calls and returns the ratio of the LCS length to the number of
+    expected calls.
+
+    Args:
+        actual_tool_calls_names: List of tool names in the actual order
+        expected_tool_calls_names: List of tool names in the expected order
+        strict: If True, the function will return 0 if the actual calls do not match the expected calls exactly
+
+    Returns:
+        tuple[float, dict]: Ratio of the LCS length to the number of expected, and the justification dict
+    """
+    justification = {
+        "actual": str(list(actual_tool_calls_names)),
+        "expected": str(list(expected_tool_calls_names)),
+        "lcs": [],
+    }
+
+    # Handle empty cases
+    if not expected_tool_calls_names and not actual_tool_calls_names:
+        return 1.0, justification
+    elif not expected_tool_calls_names or not actual_tool_calls_names:
+        return 0.0, justification
+
+    # Handle exact match
+    if expected_tool_calls_names == actual_tool_calls_names:
+        justification["lcs"] = list(actual_tool_calls_names)
+        return 1.0, justification
+
+    # Handle strict mode - only perfect matches allowed
+    if strict:
+        return 0.0, justification
+
+    # Calculate LCS with full DP table for efficient reconstruction
+    m, n = len(actual_tool_calls_names), len(expected_tool_calls_names)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+    # Build DP table - O(m*n)
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if actual_tool_calls_names[i - 1] == expected_tool_calls_names[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+
+    # Reconstruct LCS - O(m+n)
+    lcs = []
+    i, j = m, n
+    while i > 0 and j > 0:
+        if actual_tool_calls_names[i - 1] == expected_tool_calls_names[j - 1]:
+            lcs.append(actual_tool_calls_names[i - 1])
+            i -= 1
+            j -= 1
+        elif dp[i - 1][j] > dp[i][j - 1]:
+            i -= 1
+        else:
+            j -= 1
+
+    lcs.reverse()  # Reverse to get correct order
+    lcs_length = len(lcs)
+    justification["lcs"] = lcs
+    return lcs_length / n, justification
+
+
+def _strict_order_score(
+    actual: Sequence[ToolCall],
+    expected: Sequence[str],
+    justification: dict[str, Any],
+) -> tuple[float, dict[str, Any]]:
+    """Strict-mode evaluation — only an exact positional match scores 1.0."""
+    if len(actual) != len(expected):
+        return 0.0, justification
+    for i, key in enumerate(expected):
+        if not _match_key(actual[i].name, actual[i].id, key):
+            return 0.0, justification
+    justification["lcs"] = list(expected)
+    return 1.0, justification
+
+
+def _build_lcs_dp(
+    actual: Sequence[ToolCall], expected: Sequence[str]
+) -> list[list[int]]:
+    """Fill the LCS dynamic-programming table for id-aware matching."""
+    m, n = len(actual), len(expected)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if _match_key(actual[i - 1].name, actual[i - 1].id, expected[j - 1]):
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+    return dp
+
+
+def _reconstruct_lcs(
+    actual: Sequence[ToolCall],
+    expected: Sequence[str],
+    dp: list[list[int]],
+) -> list[str]:
+    """Walk the DP table backwards to recover the LCS as a list of expected keys."""
+    lcs: list[str] = []
+    i, j = len(actual), len(expected)
+    while i > 0 and j > 0:
+        if _match_key(actual[i - 1].name, actual[i - 1].id, expected[j - 1]):
+            lcs.append(expected[j - 1])
+            i -= 1
+            j -= 1
+        elif dp[i - 1][j] > dp[i][j - 1]:
+            i -= 1
+        else:
+            j -= 1
+    lcs.reverse()
+    return lcs
+
+
+def tool_calls_order_score_with_ids(
+    actual_tool_calls: Sequence[ToolCall],
+    expected_tool_calls_keys: Sequence[str],
+    strict: bool = False,
+) -> tuple[float, dict[str, Any]]:
+    """LCS-based ordering score with id-aware matching.
+
+    Identical scoring algorithm to `tool_calls_order_score`, but each expected
+    key string is allowed to match either the actual call's `id` or its
+    `name`. Use this when eval-set criteria may be authored against the
+    stable tool id so renames of `name` don't silently break ordering checks.
+
+    Args:
+        actual_tool_calls: ToolCall objects in the actual order. Each may carry
+            an `id` from the runtime's `tool.id` span attribute.
+        expected_tool_calls_keys: List of names OR ids in the expected order.
+        strict: When True, only perfect matches score above 0.
+
+    Returns:
+        Same shape as `tool_calls_order_score`. The "actual" justification
+        renders the resolved match-key sequence (id when available, else name)
+        so the LCS reconstruction reads clearly.
+    """
+    actual_keys: list[str] = [
+        (c.id if c.id is not None else c.name) for c in actual_tool_calls
+    ]
+    justification: dict[str, Any] = {
+        "actual": str(list(actual_keys)),
+        "expected": str(list(expected_tool_calls_keys)),
+        "lcs": [],
+    }
+
+    if not expected_tool_calls_keys and not actual_tool_calls:
+        return 1.0, justification
+    if not expected_tool_calls_keys or not actual_tool_calls:
+        return 0.0, justification
+
+    if strict:
+        return _strict_order_score(
+            actual_tool_calls, expected_tool_calls_keys, justification
+        )
+
+    dp = _build_lcs_dp(actual_tool_calls, expected_tool_calls_keys)
+    lcs = _reconstruct_lcs(actual_tool_calls, expected_tool_calls_keys, dp)
+    justification["lcs"] = lcs
+    return len(lcs) / len(expected_tool_calls_keys), justification
+
+
+def tool_calls_count_score(
+    actual_tool_calls_count: Mapping[str, int],
+    expected_tool_calls_count: Mapping[str, tuple[str, int]],
+    strict: bool = False,
+    justification_key: str = "explained_tool_calls_count",
+) -> tuple[float, dict[str, Any]]:
+    """Check if the expected tool call counts match the actual tool call counts.
+
+    Args:
+        actual_tool_calls_count: Mapping of tool names to their actual call counts.
+        expected_tool_calls_count: Mapping of tool names to expected (comparator, count) tuples.
+        strict: If True, the function will return 0 if not all expected tool calls are matched.
+        justification_key: Key to use for the justification in the returned dict.
+
+    Returns:
+        tuple[float, dict]: Score based on the number of matches, and the justification dict.
+    """
+    if not expected_tool_calls_count and not actual_tool_calls_count:
+        return 1.0, {
+            "expected": str(dict(expected_tool_calls_count)),
+            "actual": str(dict(actual_tool_calls_count)),
+            justification_key: {
+                "_result": "Both expected and actual tool calls are empty"
+            },
+        }
+    elif not expected_tool_calls_count or not actual_tool_calls_count:
+        return 0.0, {
+            "expected": str(dict(expected_tool_calls_count)),
+            "actual": str(dict(actual_tool_calls_count)),
+            justification_key: {
+                "_result": "Either expected or actual tool calls are empty"
+            },
+        }
+
+    score = 0.0
+    justifications: dict[str, Any] = {
+        "expected": str(dict(expected_tool_calls_count)),
+        "actual": str(dict(actual_tool_calls_count)),
+        justification_key: {},
+    }
+    for tool_name, (
+        expected_comparator,
+        expected_count,
+    ) in expected_tool_calls_count.items():
+        # Raw key first (id-keyed / exact-match), then sanitised (legacy display-name). `is None` not `or`: count of 0 is a hit.
+        actual_count = actual_tool_calls_count.get(tool_name)
+        if actual_count is None:
+            actual_count = actual_tool_calls_count.get(
+                _sanitize_tool_name(tool_name), 0
+            )
+        comparator = f"__{COMPARATOR_MAPPINGS[expected_comparator]}__"
+        to_add = float(getattr(actual_count, comparator)(expected_count))
+
+        justifications[justification_key][tool_name] = (
+            f"Actual: {actual_count}, Expected: {expected_count}, Score: {to_add}"
+        )
+        if strict and to_add == 0.0:
+            # When strict is True, if the actual count does not match the expected count, return 0
+            # The justification should only include the breaching tool name
+            return 0.0, {
+                "expected": str(dict(expected_tool_calls_count)),
+                "actual": str(dict(actual_tool_calls_count)),
+                justification_key: {
+                    tool_name: justifications[justification_key][tool_name]
+                },
+            }
+        score += to_add
+    return score / len(expected_tool_calls_count), justifications
+
+
+def tool_calls_args_score(
+    actual_tool_calls: list[ToolCall],
+    expected_tool_calls: list[ToolCall],
+    strict: bool = False,
+    subset: bool = False,
+    justification_key: str = "explained_tool_calls_args",
+) -> tuple[float, dict[str, Any]]:
+    """Check if the expected tool calls are correctly called with matching arguments.
+
+    This function does not check the order of the tool calls!
+
+    Args:
+        actual_tool_calls: List of actual tool calls with their arguments.
+        expected_tool_calls: List of expected tool calls with their arguments.
+        strict: If True, the function will return 0 if not all expected tool calls are matched.
+        subset: If True, the function will check if the expected args are a subset of the actual args.
+        justification_key: Key to use for the justification in the returned dict.
+
+    Returns:
+        tuple[float, dict]: Score based on the number of matches, and the justification dict.
+    """
+    if not expected_tool_calls and not actual_tool_calls:
+        return 1.0, {
+            "expected": str(expected_tool_calls),
+            "actual": str(actual_tool_calls),
+            justification_key: {
+                "_result": "Both expected and actual tool calls are empty"
+            },
+        }
+    elif not expected_tool_calls or not actual_tool_calls:
+        return 0.0, {
+            "expected": str(expected_tool_calls),
+            "actual": str(actual_tool_calls),
+            justification_key: {
+                "_result": "Either expected or actual tool calls are empty"
+            },
+        }
+
+    cnt = 0
+    visited: set[int] = set()
+    justifications: dict[str, Any] = {
+        "expected": str(expected_tool_calls),
+        "actual": str(actual_tool_calls),
+        justification_key: {},
+    }
+    tool_counters: dict[str, int] = {}
+
+    for expected_tool_call in expected_tool_calls:
+        for idx, call in enumerate(actual_tool_calls):
+            if _calls_match(call, expected_tool_call) and idx not in visited:
+                # Get or initialize counter for this tool name
+                tool_counters[call.name] = tool_counters.get(call.name, 0)
+                tool_key = f"{call.name}_{tool_counters[call.name]}"
+                tool_counters[call.name] += 1
+
+                # Check arguments based on mode
+                if subset:
+                    # Subset mode: safely check if all expected args exist and match
+                    # Capture 'call' as a default argument to bind the loop variable
+                    args_check = (  # noqa: E731
+                        lambda k, v, call=call: k in call.args and call.args[k] == v
+                    )
+                else:
+                    # Exact mode: direct access (may raise KeyError)
+                    # Capture 'call' as a default argument to bind the loop variable
+                    args_check = lambda k, v, call=call: call.args[k] == v  # noqa: E731
+
+                try:
+                    args_match = all(
+                        args_check(k, v) for k, v in expected_tool_call.args.items()
+                    )
+                except KeyError:
+                    # Only possible in exact mode when key is missing
+                    args_match = False
+
+                justifications[justification_key][tool_key] = (
+                    f"Actual: {call.args}, Expected: {expected_tool_call.args}, Score: {float(args_match)}"
+                )
+                if args_match:
+                    cnt += 1
+                    visited.add(idx)
+                    break
+                # In case of mismatch, DON'T add to visited in non-strict mode
+                # so this actual tool call can be matched against other expected calls
+
+    return (
+        cnt / len(expected_tool_calls)
+        if not strict
+        else float(cnt == len(expected_tool_calls))
+    ), justifications
+
+
+def tool_calls_output_score(
+    actual_tool_calls_outputs: list[ToolOutput],
+    expected_tool_calls_outputs: list[ToolOutput],
+    strict: bool = False,
+    justification_key: str = "explained_tool_calls_outputs",
+) -> tuple[float, dict[str, Any]]:
+    """Check if the expected tool calls are correctly called, where expected args must be a subset of actual args.
+
+    Args:
+        actual_tool_calls_outputs: List of actual tool calls outputs.
+        expected_tool_calls_outputs: List of expected tool calls outputs.
+        strict: If True, the function will return 0 if not all expected tool calls are matched.
+
+    Returns:
+        tuple[float, str]: Score based on the number of matches, and the justification.
+    """
+    if not expected_tool_calls_outputs and not actual_tool_calls_outputs:
+        return 1.0, {
+            "expected": str(expected_tool_calls_outputs),
+            "actual": str(actual_tool_calls_outputs),
+            justification_key: {
+                "_result": "Both expected and actual tool calls outputs are empty"
+            },
+        }
+    elif not expected_tool_calls_outputs or not actual_tool_calls_outputs:
+        return 0.0, {
+            "expected": str(expected_tool_calls_outputs),
+            "actual": str(actual_tool_calls_outputs),
+            justification_key: {
+                "_result": "Either expected or actual tool calls outputs are empty"
+            },
+        }
+
+    cnt = 0.0
+    justifications: dict[str, Any] = {
+        "expected": str(expected_tool_calls_outputs),
+        "actual": str(actual_tool_calls_outputs),
+        justification_key: {},
+    }
+    visited: set[int] = set()
+    tool_counters: dict[str, int] = {}
+
+    for expected_tool_call_output in expected_tool_calls_outputs:
+        matched = False
+
+        # Look through ALL actual tool calls to find a match
+        for idx, actual_tool_call_output in enumerate(actual_tool_calls_outputs):
+            if idx in visited:
+                continue
+            if _calls_match(actual_tool_call_output, expected_tool_call_output):
+                # Get or initialize counter for this tool name
+                tool_counters[actual_tool_call_output.name] = tool_counters.get(
+                    actual_tool_call_output.name, 0
+                )
+                tool_key = f"{actual_tool_call_output.name}_{tool_counters[actual_tool_call_output.name]}"
+                tool_counters[actual_tool_call_output.name] += 1
+
+                justifications[justification_key][tool_key] = (
+                    f"Actual: {actual_tool_call_output.output}, Expected: {expected_tool_call_output.output}, Score: {float(actual_tool_call_output.output == expected_tool_call_output.output)}"
+                )
+
+                if actual_tool_call_output.output == expected_tool_call_output.output:
+                    # Perfect match found
+                    cnt += 1.0
+                    visited.add(idx)
+                    matched = True
+                    break
+                elif strict:
+                    # In strict mode, any mismatch returns 0 immediately
+                    return 0.0, {
+                        "expected": str(expected_tool_calls_outputs),
+                        "actual": str(actual_tool_calls_outputs),
+                        justification_key: {
+                            tool_key: justifications[justification_key][tool_key]
+                        },
+                    }
+                # In non-strict mode with mismatch, continue looking for perfect match
+                # DON'T add to visited, DON'T break
+
+        # If no match found and we're in strict mode, return 0
+        if not matched and strict:
+            return 0.0, {
+                "expected": str(expected_tool_calls_outputs),
+                "actual": str(actual_tool_calls_outputs),
+                justification_key: {
+                    "_result": f"No matching actual tool call found for expected {expected_tool_call_output.name}"
+                },
+            }
+
+    return (
+        cnt / len(expected_tool_calls_outputs)
+        if not strict
+        else float(cnt == len(expected_tool_calls_outputs))
+    ), justifications
+
+
+def trace_to_str(agent_trace: Sequence[ReadableSpan]) -> str:
+    """Convert OTEL spans to a platform-style agent run history string.
+
+    Creates a similar structure to LangChain message processing but using OTEL spans.
+    Only processes tool spans (spans with 'tool.name' attribute).
+
+    Args:
+        agent_trace: List of ReadableSpan objects from the agent execution
+
+    Returns:
+        String representation of the agent run history in platform format
+    """
+    platform_history = []
+    seen_tool_calls = set()
+
+    for span in agent_trace:
+        if span.attributes and (tool_name := span.attributes.get(TOOL_NAME_ATTR)):
+            # Get span timing information
+            start_time = span.start_time
+            end_time = span.end_time
+
+            # Convert nanoseconds to datetime if needed
+            if isinstance(start_time, int):
+                start_timestamp = datetime.fromtimestamp(start_time / 1e9)
+            else:
+                start_timestamp = start_time  # type:ignore
+
+            if isinstance(end_time, int):
+                end_timestamp = datetime.fromtimestamp(end_time / 1e9)
+            else:
+                end_timestamp = end_time  # type:ignore
+
+            timestamp_str = (
+                start_timestamp.strftime("%Y-%m-%d %H:%M:%S") if start_timestamp else ""
+            )
+
+            # Get tool call information
+            tool_args: Any = span.attributes.get("input.value", {})
+            tool_result = str(span.attributes.get("output.value", {})).strip()
+
+            span_id = (
+                span.context.span_id
+                if span.context
+                else str(hash(f"{tool_name}_{timestamp_str}"))
+            )
+
+            # De-duplicate tool calls based on span ID
+            if span_id in seen_tool_calls:
+                continue
+            seen_tool_calls.add(span_id)
+
+            # Add tool selection (equivalent to AIMessage with tool_calls)
+            platform_history.append(f"[{timestamp_str}] LLM Response:")
+            platform_history.append("  Agent Selected 1 Tool(s):")
+            platform_history.append("")
+            platform_history.append(f"  Tool: {tool_name}")
+            platform_history.append(f"  Arguments: {str(tool_args)}")
+            platform_history.append("")
+
+            # Add tool response (equivalent to ToolMessage)
+            end_timestamp_str = (
+                end_timestamp.strftime("%Y-%m-%d %H:%M:%S")
+                if end_timestamp
+                else timestamp_str
+            )
+            platform_history.append(
+                f"[{end_timestamp_str}] Tool Call Response - {tool_name}:"
+            )
+            platform_history.append(f"{tool_result}")
+            platform_history.append("")
+
+    return "\n".join(platform_history)
diff --git a/packages/uipath/src/uipath/eval/_helpers/helpers.py b/packages/uipath/src/uipath/eval/_helpers/helpers.py
new file mode 100644
index 000000000..e69976955
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/_helpers/helpers.py
@@ -0,0 +1,57 @@
+"""Helper functions for evaluation process."""
+
+import functools
+import time
+from collections.abc import Callable
+from typing import Any
+
+from ..models import ErrorEvaluationResult, EvaluationResult
+
+
+def is_empty_value(value: Any) -> bool:
+    """Check if a value is empty or contains only empty values.
+
+    Handles multiple cases:
+    - None or empty string
+    - String with only whitespace
+    - Dict where all values are empty strings or whitespace
+    - Empty list or dict
+    """
+    if value is None:
+        return True
+
+    if isinstance(value, str):
+        return not value.strip()
+
+    if isinstance(value, dict):
+        if not value:  # Empty dict
+            return True
+        # Check if all values are empty strings
+        return all(isinstance(v, str) and not v.strip() for v in value.values())
+
+    if isinstance(value, list):
+        return len(value) == 0
+
+    return False
+
+
+def track_evaluation_metrics(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to track evaluation metrics and handle errors gracefully."""
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> EvaluationResult:
+        start_time = time.time()
+        try:
+            result = await func(*args, **kwargs)
+        except Exception as e:
+            result = ErrorEvaluationResult(
+                details="Exception thrown by evaluator: {}".format(e),
+                evaluation_time=time.time() - start_time,
+            )
+        end_time = time.time()
+        execution_time = end_time - start_time
+
+        result.evaluation_time = execution_time
+        return result
+
+    return wrapper
diff --git a/packages/uipath/src/uipath/eval/_helpers/output_path.py b/packages/uipath/src/uipath/eval/_helpers/output_path.py
new file mode 100644
index 000000000..5c50a34df
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/_helpers/output_path.py
@@ -0,0 +1,89 @@
+"""Utility for resolving dot-notation paths from agent output dictionaries.
+
+Supports:
+- "*" → return entire output (default behavior)
+- "result" → flat key lookup (backward compatible)
+- "result.calculation.value" → nested dot-notation path
+- "items[0].name" → array index access with dot-notation
+- "items[2].details.score" → mixed nested object and array access
+
+Examples:
+    >>> resolve_output_path({"result": {"value": 42}}, "result.value")
+    42
+    >>> resolve_output_path({"items": [{"name": "a"}, {"name": "b"}]}, "items[1].name")
+    'b'
+    >>> resolve_output_path({"result": 5}, "*")
+    {"result": 5}
+"""
+
+import re
+from typing import Any
+
+
+def resolve_output_path(output: Any, path: str) -> Any:
+    """Resolve a dot-notation path with optional array indexing from output.
+
+    Args:
+        output: The output dictionary (or any value) to resolve the path from.
+        path: The path string. "*" returns the full output.
+              Dot notation for nested objects: "a.b.c"
+              Bracket notation for array indices: "items[0].name"
+
+    Returns:
+        The resolved value at the given path.
+
+    Raises:
+        KeyError: If a dict key in the path is not found.
+        IndexError: If an array index is out of range.
+        TypeError: If the path tries to index into a non-dict/non-list value.
+    """
+    if path == "*":
+        return output
+
+    tokens = _tokenize_path(path)
+    current = output
+
+    for token in tokens:
+        if isinstance(token, int):
+            if not isinstance(current, (list, tuple)):
+                raise TypeError(
+                    f"Cannot index into {type(current).__name__} with integer index [{token}]"
+                )
+            current = current[token]
+        else:
+            if not isinstance(current, dict):
+                raise TypeError(
+                    f"Cannot access key '{token}' on {type(current).__name__}"
+                )
+            current = current[token]
+
+    return current
+
+
+# Pattern to match either:
+#   - a bare key segment (no dots or brackets)
+#   - a bracket index like [0], [12]
+_TOKEN_PATTERN = re.compile(r"([^.\[\]]+)|\[(\d+)\]")
+
+
+def _tokenize_path(path: str) -> list[str | int]:
+    """Parse a path string into a list of string keys and integer indices.
+
+    Examples:
+        "result" → ["result"]
+        "result.value" → ["result", "value"]
+        "items[0].name" → ["items", 0, "name"]
+        "data[2].nested.list[0]" → ["data", 2, "nested", "list", 0]
+    """
+    tokens: list[str | int] = []
+    for match in _TOKEN_PATTERN.finditer(path):
+        key_part, index_part = match.groups()
+        if index_part is not None:
+            tokens.append(int(index_part))
+        else:
+            tokens.append(key_part)
+
+    if not tokens:
+        raise ValueError(f"Invalid path: '{path}'")
+
+    return tokens
diff --git a/packages/uipath/src/uipath/eval/constants.py b/packages/uipath/src/uipath/eval/constants.py
new file mode 100644
index 000000000..4bd86ecf1
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/constants.py
@@ -0,0 +1,8 @@
+"""Constants used in the evaluation module."""
+
+# Folder names
+LEGACY_EVAL_FOLDER = "evals"
+EVALS_FOLDER = "evaluations"
+
+# Evaluators
+CUSTOM_EVALUATOR_PREFIX = "file://"
diff --git a/packages/uipath/src/uipath/eval/evaluators/__init__.py b/packages/uipath/src/uipath/eval/evaluators/__init__.py
new file mode 100644
index 000000000..03a4bf63b
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/__init__.py
@@ -0,0 +1,91 @@
+"""UiPath evaluator implementations for agent performance evaluation."""
+
+from typing import Any
+
+# Current coded evaluators
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from .base_legacy_evaluator import BaseLegacyEvaluator
+from .binary_classification_evaluator import BinaryClassificationEvaluator
+
+# Legacy evaluators
+from .contains_evaluator import ContainsEvaluator
+from .exact_match_evaluator import ExactMatchEvaluator
+from .json_similarity_evaluator import JsonSimilarityEvaluator
+from .legacy_context_precision_evaluator import LegacyContextPrecisionEvaluator
+from .legacy_csv_exact_match_evaluator import LegacyCSVExactMatchEvaluator
+from .legacy_exact_match_evaluator import LegacyExactMatchEvaluator
+from .legacy_faithfulness_evaluator import LegacyFaithfulnessEvaluator
+from .legacy_json_similarity_evaluator import LegacyJsonSimilarityEvaluator
+from .legacy_llm_as_judge_evaluator import LegacyLlmAsAJudgeEvaluator
+from .legacy_trajectory_evaluator import LegacyTrajectoryEvaluator
+from .llm_as_judge_evaluator import LLMJudgeJustification
+from .llm_judge_output_evaluator import (
+    BaseLLMOutputEvaluator,
+    LLMJudgeOutputEvaluator,
+    LLMJudgeStrictJSONSimilarityOutputEvaluator,
+)
+from .llm_judge_trajectory_evaluator import (
+    BaseLLMTrajectoryEvaluator,
+    LLMJudgeTrajectoryEvaluator,
+    LLMJudgeTrajectorySimulationEvaluator,
+)
+from .multiclass_classification_evaluator import MulticlassClassificationEvaluator
+from .output_evaluator import AggregationMethod
+from .tool_call_args_evaluator import ToolCallArgsEvaluator
+from .tool_call_count_evaluator import ToolCallCountEvaluator
+from .tool_call_order_evaluator import ToolCallOrderEvaluator
+from .tool_call_output_evaluator import ToolCallOutputEvaluator
+
+EVALUATORS: list[type[BaseEvaluator[Any, Any, Any]]] = [
+    ExactMatchEvaluator,
+    ContainsEvaluator,
+    BinaryClassificationEvaluator,
+    MulticlassClassificationEvaluator,
+    JsonSimilarityEvaluator,
+    LLMJudgeOutputEvaluator,
+    LLMJudgeStrictJSONSimilarityOutputEvaluator,
+    LLMJudgeTrajectoryEvaluator,
+    LLMJudgeTrajectorySimulationEvaluator,
+    ToolCallOrderEvaluator,
+    ToolCallArgsEvaluator,
+    ToolCallCountEvaluator,
+    ToolCallOutputEvaluator,
+]
+__all__ = [
+    # Legacy evaluators
+    "BaseLegacyEvaluator",
+    "LegacyContextPrecisionEvaluator",
+    "LegacyCSVExactMatchEvaluator",
+    "LegacyExactMatchEvaluator",
+    "LegacyFaithfulnessEvaluator",
+    "LegacyLlmAsAJudgeEvaluator",
+    "LegacyTrajectoryEvaluator",
+    "LegacyJsonSimilarityEvaluator",
+    # Current coded evaluators
+    "BaseEvaluator",
+    "BinaryClassificationEvaluator",
+    "MulticlassClassificationEvaluator",
+    "ContainsEvaluator",
+    "ExactMatchEvaluator",
+    "JsonSimilarityEvaluator",
+    "BaseLLMOutputEvaluator",
+    "LLMJudgeOutputEvaluator",
+    "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+    "BaseLLMTrajectoryEvaluator",
+    "LLMJudgeTrajectoryEvaluator",
+    "LLMJudgeTrajectorySimulationEvaluator",
+    "ToolCallOrderEvaluator",
+    "ToolCallArgsEvaluator",
+    "ToolCallCountEvaluator",
+    "ToolCallOutputEvaluator",
+    "BaseEvaluationCriteria",
+    "BaseEvaluatorConfig",
+    "BaseEvaluatorJustification",
+    "LLMJudgeJustification",
+    "AggregationMethod",
+]
diff --git a/packages/uipath/src/uipath/eval/evaluators/attachment_utils.py b/packages/uipath/src/uipath/eval/evaluators/attachment_utils.py
new file mode 100644
index 000000000..318e48cdc
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/attachment_utils.py
@@ -0,0 +1,91 @@
+"""Utility functions for handling job attachments in evaluators."""
+
+import re
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Any
+
+from ..models.models import UiPathEvaluationError, UiPathEvaluationErrorCategory
+
+
+def is_job_attachment_uri(value: Any) -> bool:
+    """Check if a value is a job attachment URI.
+
+    Job attachment URIs follow the pattern:
+    urn:uipath:cas:file:orchestrator:{attachment_id}
+
+    Args:
+        value: The value to check
+
+    Returns:
+        True if the value is a job attachment URI, False otherwise
+    """
+    if not isinstance(value, str):
+        return False
+    pattern = r"^urn:uipath:cas:file:orchestrator:([a-f0-9-]+)$"
+    return bool(re.match(pattern, value, re.IGNORECASE))
+
+
+def extract_attachment_id(uri: str) -> str:
+    """Extract attachment ID from a job attachment URI.
+
+    Args:
+        uri: The job attachment URI
+
+    Returns:
+        The attachment ID (UUID)
+
+    Raises:
+        ValueError: If the URI is not a valid job attachment URI
+    """
+    pattern = r"^urn:uipath:cas:file:orchestrator:([a-f0-9-]+)$"
+    match = re.match(pattern, uri, re.IGNORECASE)
+    if match:
+        return match.group(1)
+    raise ValueError(f"Invalid job attachment URI: {uri}")
+
+
+def download_attachment_as_string(attachment_id: str) -> str:
+    """Download a job attachment and return its content as a string.
+
+    Uses the AttachmentsService to download the file and reads it as a string.
+
+    Args:
+        attachment_id: The UUID of the attachment
+
+    Returns:
+        The file content as a string
+
+    Raises:
+        UiPathEvaluationError: If download fails or UiPath platform is not available
+    """
+    try:
+        from uipath.platform import UiPath
+
+        client = UiPath()
+
+        # Create temporary file for download
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".txt") as tmp_file:
+            temp_path = tmp_file.name
+
+        try:
+            # Use AttachmentsService to download
+            client.attachments.download(
+                key=uuid.UUID(attachment_id), destination_path=temp_path
+            )
+
+            # Read and return content as string
+            with open(temp_path, "r", encoding="utf-8") as f:
+                return f.read()
+        finally:
+            # Clean up temporary file
+            Path(temp_path).unlink(missing_ok=True)
+
+    except Exception as e:
+        raise UiPathEvaluationError(
+            code="ATTACHMENT_DOWNLOAD_FAILED",
+            title="Failed to download job attachment",
+            detail=f"Could not download attachment {attachment_id}: {e}",
+            category=UiPathEvaluationErrorCategory.SYSTEM,
+        ) from e
diff --git a/packages/uipath/src/uipath/eval/evaluators/base_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/base_evaluator.py
new file mode 100644
index 000000000..73fac46c6
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/base_evaluator.py
@@ -0,0 +1,642 @@
+"""Base evaluator abstract class for agent evaluation."""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar, Union, cast, get_args
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic.alias_generators import to_camel
+
+from .._helpers.helpers import track_evaluation_metrics
+from ..models import AgentExecution, EvaluationResult
+from ..models.models import (
+    EvaluationResultDto,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+
+
+class BaseEvaluationCriteria(BaseModel):
+    """Base class for all evaluation criteria."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    pass
+
+
+# Type variable for evaluation criteria, used by both Config and Evaluator
+T = TypeVar("T", bound=BaseEvaluationCriteria)
+
+
+class BaseEvaluatorConfig(BaseModel, Generic[T]):
+    """Base class for all evaluator configurations.
+
+    Generic over T (evaluation criteria type) to ensure type safety between
+    the config's default_evaluation_criteria and the evaluator's expected criteria type.
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    name: str = Field(description="The name of the evaluator")
+    description: str = Field(default="", description="The description of the evaluator")
+    default_evaluation_criteria: T | None = None
+
+
+class BaseEvaluatorJustification(BaseModel):
+    """Base class for all evaluator justifications."""
+
+    expected: str
+    actual: str
+
+
+# Additional type variables for Config and Justification
+# Note: C must be BaseEvaluatorConfig[T] to ensure type consistency
+C = TypeVar("C", bound=BaseEvaluatorConfig[Any])
+J = TypeVar("J", bound=Union[str, BaseEvaluatorJustification])
+
+
+class GenericBaseEvaluator(BaseModel, Generic[T, C, J], ABC):
+    """Abstract base class for all evaluators.
+
+    Generic Parameters:
+        T: The evaluation criteria type (bound to BaseEvaluationCriteria)
+        C: The evaluator config type (bound to BaseEvaluatorConfig[T])
+        J: The justification type (str, None, or BaseEvaluatorJustification subclass)
+
+    Design Rationale:
+        T is explicitly specified even though C = BaseEvaluatorConfig[T] already encodes it.
+        This redundancy is intentional and provides:
+
+        1. **Type Checker Support**: Static type checkers can infer the exact criteria type
+           for the evaluate() method signature without runtime introspection
+
+        2. **Clear API**: The signature BaseEvaluator[MyCriteria, MyConfig[MyCriteria], str]
+           makes it immediately obvious what criteria type is expected
+
+        3. **IDE Support**: Autocomplete and type hints work perfectly for method parameters
+
+        Runtime validation ensures T and C's generic parameter are consistent.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    id: str
+    name: str = Field(default="", description="The name of the evaluator")
+    description: str = Field(default="", description="The description of the evaluator")
+
+    config_type: type[C] = Field(description="The config type class", exclude=True)
+    evaluation_criteria_type: type[T] = Field(
+        description="The type used for evaluation criteria validation and creation",
+        exclude=True,
+    )
+    justification_type: type[J] = Field(
+        description="The type used for justification validation and creation",
+        exclude=True,
+    )
+
+    def __init_subclass__(cls, **kwargs: Any):
+        """Hook for subclass creation - automatically applies evaluation metrics tracking."""
+        super().__init_subclass__(**kwargs)
+
+        if hasattr(cls, "evaluate") and not getattr(
+            cls.evaluate, "_has_metrics_decorator", False
+        ):
+            new_evaluation_method = track_evaluation_metrics(cls.evaluate)
+            new_evaluation_method._has_metrics_decorator = True  # type: ignore[attr-defined] # probably a better way to do this
+            cls.evaluate = new_evaluation_method  # type: ignore[method-assign] # probably a better way to do this
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_model(cls, values: Any) -> Any:
+        """Pre-initialization model validator for Pydantic models.
+
+        This validator extracts the Generic type parameters and validates their consistency.
+
+        Args:
+            values: The raw input values before validation
+
+        Returns:
+            The validated/transformed values with types set
+
+        Raises:
+            ValueError: If types cannot be determined or are inconsistent
+        """
+        if isinstance(values, dict):
+            if "description" in values and "evaluatorConfig" in values:
+                values["evaluatorConfig"]["description"] = values.pop("description")
+            if "name" in values and "evaluatorConfig" in values:
+                values["evaluatorConfig"]["name"] = values.pop("name")
+            # Always extract and set evaluation_criteria_type
+            criteria_type = cls._extract_evaluation_criteria_type()
+            values["evaluation_criteria_type"] = criteria_type
+
+            # Always extract and set config_type
+            config_type = cls._extract_config_type()
+            values["config_type"] = config_type
+
+            # Always extract and set justification_type
+            justification_type = cls._extract_justification_type()
+            values["justification_type"] = justification_type
+
+            # Validate consistency: config's generic parameter should match criteria_type
+            cls._validate_type_consistency(config_type, criteria_type)
+
+            # Validate and create the config object if config dict is provided
+            try:
+                raw_config = values.get("config") or values.get("evaluatorConfig") or {}
+                validated_config = config_type.model_validate(raw_config)
+                values["evaluator_config"] = validated_config
+            except Exception as e:
+                raise UiPathEvaluationError(
+                    code="FAILED_TO_VALIDATE_EVALUATOR_CONFIG",
+                    title=f"Failed to validate evaluator config for {cls.__name__}",
+                    detail=f"Error: {e}",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                ) from e
+
+        return values
+
+    @classmethod
+    def _validate_type_consistency(
+        cls,
+        config_type: type[BaseEvaluatorConfig[Any]],
+        criteria_type: type[BaseEvaluationCriteria],
+    ) -> None:
+        """Validate that the config's generic parameter matches the evaluator's criteria type.
+
+        Extracts the criteria type from the config's default_evaluation_criteria field
+        annotation and validates it matches the evaluator's expected criteria type.
+
+        Args:
+            config_type: The config type to validate
+            criteria_type: The expected evaluation criteria type
+
+        Raises:
+            ValueError: If the types are inconsistent
+        """
+        # Skip validation for base classes
+        if config_type.__name__ in (
+            "BaseEvaluatorConfig",
+            "OutputEvaluatorConfig",
+            "BaseLLMJudgeEvaluatorConfig",
+        ):
+            return
+
+        # Extract from Pydantic's model_fields which preserves generic types
+        if (
+            hasattr(config_type, "model_fields")
+            and "default_evaluation_criteria" in config_type.model_fields
+        ):
+            field_info = config_type.model_fields["default_evaluation_criteria"]
+            if hasattr(field_info, "annotation"):
+                annotation = field_info.annotation
+                # The annotation will be SomeCriteria | None
+                args = get_args(annotation)
+                if args:
+                    # Get the criteria type (the non-None arg)
+                    for arg in args:
+                        if (
+                            arg is not type(None)
+                            and isinstance(arg, type)
+                            and issubclass(arg, BaseEvaluationCriteria)
+                        ):
+                            # Found the config's criteria type, check if it matches
+                            if arg != criteria_type:
+                                raise UiPathEvaluationError(
+                                    code="TYPE_INCONSISTENCY_IN_EVALUATOR",
+                                    title=f"Type inconsistency in {cls.__name__}: "
+                                    f"Config {config_type.__name__} expects criteria type {arg.__name__}",
+                                    detail=f"Evaluator expects {criteria_type.__name__}. "
+                                    f"Ensure BaseEvaluator[T, C[T], J] has matching T and C[T] parameters.",
+                                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                                )
+                            return  # Validation passed
+
+    @classmethod
+    def _extract_evaluation_criteria_type(cls) -> type[BaseEvaluationCriteria]:
+        """Extract the evaluation criteria type from Pydantic model fields.
+
+        Returns:
+            The evaluation criteria type
+
+        Raises:
+            ValueError: If no valid evaluation criteria type can be determined from the class definition
+        """
+        # Special case: if this is the BaseEvaluator class itself, return BaseEvaluationCriteria
+        if cls.__name__ == ("BaseEvaluator" or "BaseEvaluator[Any, Any, Any]"):
+            return BaseEvaluationCriteria
+
+        # Check if Pydantic has already resolved the evaluation_criteria_type field annotation
+        if not (
+            hasattr(cls, "model_fields")
+            and "evaluation_criteria_type" in cls.model_fields
+        ):
+            raise UiPathEvaluationError(
+                code="COULD_NOT_FIND_EVALUATION_CRITERIA_TYPE_FIELD",
+                title=f"Could not find evaluation_criteria_type field in {cls.__name__}",
+                detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        field_info = cls.model_fields["evaluation_criteria_type"]
+        if not hasattr(field_info, "annotation"):
+            raise UiPathEvaluationError(
+                code="NO_ANNOTATION_FOUND_FOR_EVALUATION_CRITERIA_TYPE_FIELD",
+                title=f"No annotation found for evaluation_criteria_type field in {cls.__name__}",
+                detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        # Extract the inner type from type[SomeType]
+        annotation = field_info.annotation
+        args = get_args(annotation)
+        if not args:
+            raise UiPathEvaluationError(
+                code="INVALID_ANNOTATION_FOR_EVALUATION_CRITERIA_TYPE",
+                title=f"Invalid annotation for evaluation_criteria_type in {cls.__name__}: {annotation}",
+                detail="Expected type[SomeEvaluationCriteria]",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        criteria_type = args[0]
+        if not (
+            isinstance(criteria_type, type)
+            and issubclass(criteria_type, BaseEvaluationCriteria)
+        ):
+            raise UiPathEvaluationError(
+                code="INVALID_EVALUATION_CRITERIA_TYPE",
+                title=f"Invalid evaluation criteria type {criteria_type} in {cls.__name__}",
+                detail=f"{criteria_type} must be a subclass of BaseEvaluationCriteria",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        return criteria_type
+
+    @classmethod
+    def _extract_config_type(cls) -> type[BaseEvaluatorConfig[Any]]:
+        """Extract the config type from Pydantic model fields.
+
+        Returns:
+            The config type for this evaluator
+
+        Raises:
+            ValueError: If no valid config type can be determined from the class definition
+        """
+        # Special case: if this is the BaseEvaluator class itself, return BaseEvaluatorConfig
+        if cls.__name__ == ("BaseEvaluator" or "BaseEvaluator[Any, Any, Any]"):
+            return BaseEvaluatorConfig
+        # Check if Pydantic has already resolved the config_type field annotation
+        if not (hasattr(cls, "model_fields") and "config_type" in cls.model_fields):
+            raise UiPathEvaluationError(
+                code="COULD_NOT_FIND_CONFIG_TYPE_FIELD",
+                title=f"Could not find config_type field in {cls.__name__}",
+                detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        field_info = cls.model_fields["config_type"]
+        if not hasattr(field_info, "annotation"):
+            raise UiPathEvaluationError(
+                code="NO_ANNOTATION_FOUND_FOR_CONFIG_TYPE_FIELD",
+                title=f"No annotation found for config_type field in {cls.__name__}",
+                detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        # Extract the inner type from type[SomeType]
+        annotation = field_info.annotation
+        args = get_args(annotation)
+        if not args:
+            raise UiPathEvaluationError(
+                code="INVALID_ANNOTATION_FOR_CONFIG_TYPE",
+                title=f"Invalid annotation for config_type in {cls.__name__}: {annotation}",
+                detail="Expected type[SomeEvaluatorConfig]",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        config_type = args[0]
+        if not (
+            isinstance(config_type, type)
+            and issubclass(config_type, BaseEvaluatorConfig)
+        ):
+            raise UiPathEvaluationError(
+                code="INVALID_CONFIG_TYPE",
+                title=f"Invalid config type {config_type} in {cls.__name__}",
+                detail=f"{config_type} must be a subclass of BaseEvaluatorConfig",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        return config_type
+
+    @classmethod
+    def _extract_justification_type(cls) -> type[J]:
+        """Extract the justification type from Pydantic model fields.
+
+        Returns:
+            The justification type (str or BaseEvaluatorJustification subclass)
+
+        Raises:
+            UiPathEvaluationError: If no valid justification type can be determined
+        """
+        try:
+            # Check if Pydantic has resolved the justification_type field annotation
+            if not (
+                hasattr(cls, "model_fields")
+                and "justification_type" in cls.model_fields
+            ):
+                raise UiPathEvaluationError(
+                    code="COULD_NOT_FIND_JUSTIFICATION_TYPE_FIELD",
+                    title=f"Could not find justification_type field in {cls.__name__}",
+                    detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            field_info = cls.model_fields["justification_type"]
+            if not hasattr(field_info, "annotation"):
+                raise UiPathEvaluationError(
+                    code="NO_ANNOTATION_FOUND_FOR_JUSTIFICATION_TYPE_FIELD",
+                    title=f"No annotation found for justification_type field in {cls.__name__}",
+                    detail="Ensure the class properly inherits from BaseEvaluator with correct Generic parameters.",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            # Extract the inner type from type[SomeType]
+            annotation = field_info.annotation
+            args = get_args(annotation)
+            if not args:
+                raise UiPathEvaluationError(
+                    code="INVALID_ANNOTATION_FOR_JUSTIFICATION_TYPE",
+                    title=f"Invalid annotation for justification_type in {cls.__name__}: {annotation}",
+                    detail="Expected type[str] or type[SomeEvaluatorJustification]",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            justification_type = args[0]
+
+            # Validate the justification type - must be str or BaseEvaluatorJustification subclass
+            if justification_type is str:
+                return cast(type[J], justification_type)
+            elif isinstance(justification_type, type) and issubclass(
+                justification_type, BaseEvaluatorJustification
+            ):
+                return cast(type[J], justification_type)
+            else:
+                raise UiPathEvaluationError(
+                    code="INVALID_JUSTIFICATION_TYPE",
+                    title=f"Invalid justification type {justification_type} in {cls.__name__}",
+                    detail="Must be str or subclass of BaseEvaluatorJustification.",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+        except UiPathEvaluationError:
+            raise
+        except Exception as e:
+            raise UiPathEvaluationError(
+                code="CANNOT_EXTRACT_JUSTIFICATION_TYPE",
+                title=f"Cannot extract justification type from {cls.__name__}",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
+
+    def validate_evaluation_criteria(self, criteria: Any) -> T:
+        """Validate and convert input to the correct evaluation criteria type.
+
+        Uses Pydantic's model_validate for proper validation, type coercion,
+        and error handling.
+
+        Args:
+            criteria: The criteria to validate (dict, BaseEvaluationCriteria, or other)
+
+        Returns:
+            An instance of the evaluation criteria type (T)
+
+        Raises:
+            ValueError: If the criteria cannot be converted to the expected type
+        """
+        try:
+            if isinstance(criteria, self.evaluation_criteria_type):
+                return criteria
+            elif isinstance(criteria, dict):
+                return self.evaluation_criteria_type.model_validate(criteria)
+            elif hasattr(criteria, "__dict__"):
+                # Try to convert from another object type
+                return self.evaluation_criteria_type.model_validate(criteria.__dict__)
+            else:
+                # Try to let Pydantic handle the conversion
+                return self.evaluation_criteria_type.model_validate(criteria)
+        except Exception as e:
+            raise UiPathEvaluationError(
+                code="CANNOT_VALIDATE_EVALUATION_CRITERIA",
+                title=f"Cannot validate {type(criteria)} to {self.evaluation_criteria_type}",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
+
+    def validate_justification(self, justification: Any) -> J:
+        """Validate and convert input to the correct justification type.
+
+        Args:
+            justification: The justification to validate (str, dict, BaseEvaluatorJustification, or other)
+
+        Returns:
+            The validated justification of the correct type
+        """
+        try:
+            # Handle str type - when J is bound to str
+            if self.justification_type is str:
+                if justification is None:
+                    return cast(J, "")
+                return cast(J, str(justification))
+
+            # Handle BaseEvaluatorJustification subclasses - when J is bound to a specific subclass
+            if isinstance(self.justification_type, type) and issubclass(
+                self.justification_type, BaseEvaluatorJustification
+            ):
+                if justification is None:
+                    raise ValueError(
+                        f"None is not allowed for justification type {self.justification_type}"
+                    )
+
+                if isinstance(justification, self.justification_type):
+                    return justification
+                elif isinstance(justification, dict):
+                    return self.justification_type.model_validate(justification)
+                elif hasattr(justification, "__dict__"):
+                    return self.justification_type.model_validate(
+                        justification.__dict__
+                    )
+                else:
+                    return self.justification_type.model_validate(justification)
+        except Exception as e:
+            raise UiPathEvaluationError(
+                code="CANNOT_CONVERT_JUSTIFICATION",
+                title=f"Cannot convert {type(justification)} to {self.justification_type}",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
+
+        # Fallback: this should never happen
+        raise UiPathEvaluationError(
+            code="UNSUPPORTED_JUSTIFICATION_TYPE",
+            title=f"Unsupported justification type {self.justification_type} for input {type(justification)}",
+            detail=f"Unsupported justification type {self.justification_type} for input {type(justification)}",
+            category=UiPathEvaluationErrorCategory.SYSTEM,
+        )
+
+    @classmethod
+    def get_evaluation_criteria_schema(cls) -> dict[str, Any]:
+        """Get the JSON schema for the evaluation criteria type.
+
+        Returns:
+            The JSON schema for the evaluation criteria type
+        """
+        criteria_type = cls._extract_evaluation_criteria_type()
+        return criteria_type.model_json_schema(by_alias=False)
+
+    @classmethod
+    def get_config_schema(cls) -> dict[str, Any]:
+        """Get the JSON schema for the config type.
+
+        Returns:
+            The JSON schema for the config type
+        """
+        config_type = cls._extract_config_type()
+        return config_type.model_json_schema(by_alias=False)
+
+    @classmethod
+    def get_justification_schema(cls) -> dict[str, Any]:
+        """Get the JSON schema for the justification type.
+
+        Returns:
+            The JSON schema for the justification type
+        """
+        justification_type = cls._extract_justification_type()
+        if justification_type is str:
+            return {"type": "string"}
+        elif isinstance(justification_type, type) and issubclass(
+            justification_type, BaseEvaluatorJustification
+        ):
+            return justification_type.model_json_schema(by_alias=False)
+        else:
+            raise UiPathEvaluationError(
+                code="INVALID_JUSTIFICATION_TYPE",
+                title=f"Invalid justification type {justification_type} in {cls.__name__}",
+                detail="Must be str or subclass of BaseEvaluatorJustification",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+    def _canonical_json(self, obj: Any) -> str:
+        """Convert an object to canonical JSON string for consistent comparison.
+
+        Args:
+            obj: The object to convert to canonical JSON
+
+        Returns:
+            str: Canonical JSON string with normalized numbers and sorted keys
+        """
+        return json.dumps(
+            obj,
+            sort_keys=True,
+            separators=(",", ":"),
+            ensure_ascii=False,
+        )
+
+    @classmethod
+    @abstractmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        pass
+
+    @classmethod
+    def generate_json_type(cls) -> dict[str, Any]:
+        """Generate the JSON schema for the evaluator."""
+        return {
+            "evaluatorTypeId": cls.get_evaluator_id(),
+            "evaluatorConfigSchema": cls.get_config_schema(),
+            "evaluationCriteriaSchema": cls.get_evaluation_criteria_schema(),
+            "justificationSchema": cls.get_justification_schema(),
+        }
+
+    def reduce_scores(self, results: list[EvaluationResultDto]) -> float:
+        """Reduce per-datapoint results into a single aggregated score.
+
+        Default implementation computes a simple average of scores. Subclasses
+        can override this to implement custom aggregation logic (e.g., precision,
+        recall) using the rich per-datapoint data in EvaluationResultDto.
+
+        Args:
+            results: List of per-datapoint results, each containing the score
+                and evaluation details/justification.
+
+        Returns:
+            The aggregated score
+        """
+        if not results:
+            return 0.0
+        return sum(r.score for r in results) / len(results)
+
+    @abstractmethod
+    async def validate_and_evaluate_criteria(
+        self, agent_execution: AgentExecution, evaluation_criteria: Any
+    ) -> EvaluationResult:
+        """Evaluate the given data and return a result from a raw evaluation criteria."""
+        pass
+
+    @abstractmethod
+    async def evaluate(
+        self, agent_execution: AgentExecution, evaluation_criteria: T
+    ) -> EvaluationResult:
+        """Evaluate the given data and return a result.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The actual output from the agent
+                - agent_trace: The execution trace from the agent
+                - simulation_instructions: The simulation instructions for the agent
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult containing the score and details
+        """
+        pass
+
+
+class BaseEvaluator(GenericBaseEvaluator[T, C, J]):
+    """Abstract base class for all coded evaluators. Not naming this BaseCodedEvaluator for backwards compatibility."""
+
+    version: str = Field(default="1.0", description="Version of the evaluator")
+    evaluator_type_id: str = Field(
+        default="", alias="evaluatorTypeId", description="Type of the evaluator"
+    )
+    evaluator_config: C = Field(
+        alias="evaluatorConfig", description="The validated config object instance"
+    )
+
+    name: str = Field(default="", description="The name of the evaluator", exclude=True)
+    description: str = Field(
+        default="", description="The description of the evaluator", exclude=True
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Post initialization of the evaluator."""
+        if not self.evaluator_type_id:
+            self.evaluator_type_id = type(self).get_evaluator_id()
+        if not self.name:
+            self.name = self.evaluator_config.name
+        if not self.description:
+            self.description = self.evaluator_config.description
+
+    async def validate_and_evaluate_criteria(
+        self, agent_execution: AgentExecution, evaluation_criteria: Any
+    ) -> EvaluationResult:
+        """Evaluate the given data and return a result from a raw evaluation criteria."""
+        if evaluation_criteria is None:
+            evaluation_criteria = self.evaluator_config.default_evaluation_criteria
+        if evaluation_criteria is None:
+            raise UiPathEvaluationError(
+                code="NO_EVALUATION_CRITERIA_PROVIDED",
+                title="No evaluation criteria provided and no default evaluation criteria configured",
+                detail="No evaluation criteria provided and no default evaluation criteria configured",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+        criteria = self.validate_evaluation_criteria(evaluation_criteria)
+        return await self.evaluate(agent_execution, criteria)
diff --git a/packages/uipath/src/uipath/eval/evaluators/base_legacy_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/base_legacy_evaluator.py
new file mode 100644
index 000000000..d53dcda20
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/base_legacy_evaluator.py
@@ -0,0 +1,235 @@
+"""Base evaluator abstract class for agent evaluation."""
+
+import functools
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+from pydantic import ConfigDict, Field
+
+from ..models import EvaluationResult
+from ..models.models import (
+    AgentExecution,
+    ErrorEvaluationResult,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+from .attachment_utils import (
+    download_attachment_as_string,
+    extract_attachment_id,
+    is_job_attachment_uri,
+)
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluatorConfig,
+    GenericBaseEvaluator,
+)
+from .line_by_line_utils import split_into_lines
+
+
+def track_evaluation_metrics(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to track evaluation metrics and handle errors gracefully."""
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> EvaluationResult:
+        start_time = time.time()
+        try:
+            result = await func(*args, **kwargs)
+        except Exception as e:
+            result = ErrorEvaluationResult(
+                details="Exception thrown by evaluator: {}".format(e),
+                evaluation_time=time.time() - start_time,
+            )
+        end_time = time.time()
+        execution_time = end_time - start_time
+
+        result.evaluation_time = execution_time
+        return result
+
+    return wrapper
+
+
+# Legacy evaluator config (non-generic version for simplicity)
+class LegacyEvaluatorConfig(BaseEvaluatorConfig[BaseEvaluationCriteria]):
+    """Configuration for legacy evaluators."""
+
+    name: str = "LegacyEvaluator"
+    default_evaluation_criteria: None = None  # Legacy evaluators don't use this
+
+
+class LegacyEvaluationCriteria(BaseEvaluationCriteria):
+    """Legacy evaluation criteria."""
+
+    expected_output: Any = Field(alias="expectedOutput")
+    expected_agent_behavior: str = Field(alias="expectedAgentBehavior")
+
+
+T = TypeVar("T", bound=LegacyEvaluatorConfig)
+
+
+class BaseLegacyEvaluator(
+    GenericBaseEvaluator[LegacyEvaluationCriteria, T, str], Generic[T], ABC
+):
+    """Abstract base class for all legacy evaluators.
+
+    Inherits from BaseEvaluator to share common evaluator infrastructure while maintaining
+    legacy-specific fields and behavior.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    # Required Fields
+    category: LegacyEvaluatorCategory = Field(...)
+    type: LegacyEvaluatorType = Field(...)
+
+    # Optional Fields
+    file_name: str = Field(default="", alias="fileName")
+    target_output_key: str = Field(default="*", alias="targetOutputKey")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+
+    # Line-by-line evaluation support
+    line_by_line_evaluation: bool = Field(default=False, alias="lineByLineEvaluation")
+    line_delimiter: str = Field(default="\n", alias="lineDelimiter")
+
+    # Note: __init_subclass__ is inherited from BaseEvaluator and handles metrics tracking
+
+    def model_post_init(self, __context: Any):
+        """Post-initialization hook for Pydantic models."""
+        # Ensure config is set up for legacy evaluators
+        super().model_post_init(__context)
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id.
+
+        For legacy evaluators, this returns a placeholder. Actual evaluator instances
+        have an 'id' field that identifies them.
+        """
+        return "legacy-evaluator"
+
+    async def validate_and_evaluate_criteria(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate the given data and return a result from a raw evaluation criteria."""
+        criteria = self.validate_evaluation_criteria(evaluation_criteria)
+
+        # Check if line-by-line evaluation is enabled
+        if self.line_by_line_evaluation:
+            return await self._evaluate_line_by_line(agent_execution, criteria)
+
+        return await self.evaluate(agent_execution, criteria)
+
+    async def _evaluate_line_by_line(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate output line-by-line and aggregate results.
+
+        Args:
+            agent_execution: The execution details
+            evaluation_criteria: The evaluation criteria
+
+        Returns:
+            Aggregated NumericEvaluationResult with line-by-line details
+        """
+        from .line_by_line_utils import build_line_by_line_result, evaluate_lines
+
+        # Extract actual and expected outputs
+        actual_output = self._get_actual_output(agent_execution)
+        expected_output = evaluation_criteria.expected_output
+
+        # Split into lines using utility function
+        actual_lines = split_into_lines(
+            actual_output, self.line_delimiter, self.target_output_key
+        )
+        expected_lines = split_into_lines(
+            expected_output, self.line_delimiter, self.target_output_key
+        )
+
+        # Create function to build line criteria
+        def create_line_criteria(expected_line: str) -> LegacyEvaluationCriteria:
+            from .line_by_line_utils import wrap_line_in_structure
+
+            line_expected_output = wrap_line_in_structure(
+                expected_line, self.target_output_key
+            )
+            return LegacyEvaluationCriteria(
+                expected_output=line_expected_output,
+                expected_agent_behavior=evaluation_criteria.expected_agent_behavior,
+            )
+
+        # Evaluate all lines using utility function
+        line_details, line_results = await evaluate_lines(
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+            target_output_key=self.target_output_key,
+            agent_execution=agent_execution,
+            evaluate_fn=self.evaluate,
+            create_line_criteria_fn=create_line_criteria,
+        )
+
+        # Build and return the aggregated result using utility function
+        return build_line_by_line_result(
+            line_details=line_details,
+            line_results=line_results,
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+        )
+
+    def _get_actual_output(self, agent_execution: AgentExecution) -> Any:
+        """Extract actual output from agent execution.
+
+        If the output is a job attachment URI, downloads the attachment
+        and returns its content as a string.
+
+        Args:
+            agent_execution: The agent execution
+
+        Returns:
+            The actual output (either the full agent_output or a specific key)
+        """
+        agent_output = agent_execution.agent_output
+
+        # If target_output_key is "*", return full output
+        if self.target_output_key == "*":
+            result = agent_output
+        # Otherwise, extract specific key
+        elif isinstance(agent_output, dict) and self.target_output_key in agent_output:
+            result = agent_output[self.target_output_key]
+        else:
+            # Fallback to full output
+            result = agent_output
+
+        # Check if result is a job attachment URI and download if so
+        if is_job_attachment_uri(result):
+            # At this point we know result is a string
+            assert isinstance(result, str)
+            attachment_id = extract_attachment_id(result)
+            result = download_attachment_as_string(attachment_id)
+
+        return result
+
+    @abstractmethod
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate the given data and return a result.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate (legacy evaluators accept any type)
+
+        Returns:
+            EvaluationResult containing the score and details
+        """
+        pass
diff --git a/packages/uipath/src/uipath/eval/evaluators/binary_classification_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/binary_classification_evaluator.py
new file mode 100644
index 000000000..d56509228
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/binary_classification_evaluator.py
@@ -0,0 +1,132 @@
+"""Binary classification evaluator for agent outputs.
+
+Evaluates binary classification by comparing predicted vs expected class.
+Per-datapoint score is 1.0 (correct) or 0.0 (incorrect). The reduce_scores
+method reads predicted/expected from justification details to build
+TP/FP/FN/TN counts and compute precision, recall, or F-score.
+"""
+
+from typing import Literal
+
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+    NumericEvaluationResult,
+)
+from ..models.models import (
+    EvaluationResultDto,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+from .base_evaluator import BaseEvaluationCriteria, BaseEvaluatorJustification
+from .output_evaluator import (
+    BaseOutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class BinaryClassificationEvaluationCriteria(BaseEvaluationCriteria):
+    """Per-datapoint criteria: which class this sample should belong to."""
+
+    expected_class: str
+
+
+class BinaryClassificationEvaluatorConfig(
+    OutputEvaluatorConfig[BinaryClassificationEvaluationCriteria]
+):
+    """Configuration for the binary classification evaluator."""
+
+    name: str = "BinaryClassificationEvaluator"
+    positive_class: str
+    metric_type: Literal["precision", "recall", "f-score"] = "precision"
+    f_value: float = 1.0
+
+
+class BinaryClassificationEvaluator(
+    BaseOutputEvaluator[
+        BinaryClassificationEvaluationCriteria,
+        BinaryClassificationEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """Binary classification evaluator with precision/recall/F-score aggregation.
+
+    Per-datapoint scores are 1.0 (correct) or 0.0 (incorrect). The reduce_scores
+    method reads predicted/expected from justification details to compute metrics.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.BINARY_CLASSIFICATION.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: BinaryClassificationEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate binary classification by comparing predicted vs expected class."""
+        predicted_class = str(self._get_actual_output(agent_execution)).lower()
+        expected_class = evaluation_criteria.expected_class.lower()
+        positive_class = self.evaluator_config.positive_class.lower()
+
+        if not positive_class:
+            raise UiPathEvaluationError(
+                code="INVALID_POSITIVE_CLASS",
+                title="Positive class is empty",
+                detail="positive_class must be a non-empty string",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        score = 1.0 if predicted_class == expected_class else 0.0
+
+        justification = self.validate_justification(
+            {
+                "expected": expected_class,
+                "actual": predicted_class,
+            }
+        )
+        return NumericEvaluationResult(score=score, details=justification)
+
+    def reduce_scores(self, results: list[EvaluationResultDto]) -> float:
+        """Compute precision, recall, or F-score from per-datapoint results."""
+        if not results:
+            return 0.0
+
+        positive_class = self.evaluator_config.positive_class.lower()
+        tp = fp = fn = 0
+
+        for r in results:
+            if isinstance(r.details, BaseEvaluatorJustification):
+                details = r.details
+            elif isinstance(r.details, dict):
+                try:
+                    details = BaseEvaluatorJustification.model_validate(r.details)
+                except Exception:
+                    continue
+            else:
+                continue
+            pred = details.actual
+            exp = details.expected
+            if pred == positive_class and exp == positive_class:
+                tp += 1
+            elif pred == positive_class:
+                fp += 1
+            elif exp == positive_class:
+                fn += 1
+
+        metric_type = self.evaluator_config.metric_type
+
+        if metric_type == "precision":
+            return tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        elif metric_type == "recall":
+            return tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        elif metric_type == "f-score":
+            p = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+            rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+            beta_sq = self.evaluator_config.f_value**2
+            denom = beta_sq * p + rec
+            return (1 + beta_sq) * p * rec / denom if denom > 0 else 0.0
+        else:
+            return 0.0
diff --git a/packages/uipath/src/uipath/eval/evaluators/contains_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/contains_evaluator.py
new file mode 100644
index 000000000..c002b47d6
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/contains_evaluator.py
@@ -0,0 +1,90 @@
+"""Contains evaluator for agent outputs."""
+
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+    NumericEvaluationResult,
+)
+from .base_evaluator import BaseEvaluationCriteria, BaseEvaluatorJustification
+from .output_evaluator import (
+    BaseOutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class ContainsEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the contains evaluator."""
+
+    search_text: str
+
+
+class ContainsEvaluatorConfig(OutputEvaluatorConfig[ContainsEvaluationCriteria]):
+    """Configuration for the contains evaluator."""
+
+    name: str = "ContainsEvaluator"
+    case_sensitive: bool = False
+    negated: bool = False
+
+
+class ContainsEvaluator(
+    BaseOutputEvaluator[
+        ContainsEvaluationCriteria, ContainsEvaluatorConfig, BaseEvaluatorJustification
+    ]
+):
+    """Evaluator that checks if the actual output contains the expected output.
+
+    This evaluator returns True if the actual output contains the expected output,
+    and False otherwise. It supports case sensitivity and negation options.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.CONTAINS.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: ContainsEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate whether actual output contains the expected output.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The actual output from the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Boolean result indicating if output contains expected value (True/False)
+        """
+        actual_output = str(self._get_actual_output(agent_execution))
+        expected_output = str(self._get_expected_output(evaluation_criteria))
+
+        if not self.evaluator_config.case_sensitive:
+            actual_output = actual_output.lower()
+            expected_output = expected_output.lower()
+
+        is_contains = expected_output in actual_output
+
+        if self.evaluator_config.negated:
+            is_contains = not is_contains
+
+        validated_justification = self.validate_justification(
+            {
+                "expected": expected_output,
+                "actual": actual_output,
+            }
+        )
+        return NumericEvaluationResult(
+            score=float(is_contains),
+            details=validated_justification,
+        )
+
+    def _get_expected_output(
+        self, evaluation_criteria: ContainsEvaluationCriteria
+    ) -> str:
+        """Get the expected output from the evaluation criteria."""
+        return evaluation_criteria.search_text
diff --git a/packages/uipath/src/uipath/eval/evaluators/evaluator.py b/packages/uipath/src/uipath/eval/evaluators/evaluator.py
new file mode 100644
index 000000000..b9b818847
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/evaluator.py
@@ -0,0 +1,233 @@
+"""Evaluator definitions and discriminators for legacy and coded evaluators."""
+
+from typing import Annotated, Any, Union
+
+from pydantic import ConfigDict, Discriminator, Field, Tag
+
+from ..models import (
+    EvaluatorType,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+from . import (
+    BaseLegacyEvaluator,
+    BinaryClassificationEvaluator,
+    ContainsEvaluator,
+    ExactMatchEvaluator,
+    JsonSimilarityEvaluator,
+    LegacyCSVExactMatchEvaluator,
+    LegacyExactMatchEvaluator,
+    LegacyJsonSimilarityEvaluator,
+    LegacyLlmAsAJudgeEvaluator,
+    LegacyTrajectoryEvaluator,
+    LLMJudgeOutputEvaluator,
+    LLMJudgeStrictJSONSimilarityOutputEvaluator,
+    LLMJudgeTrajectoryEvaluator,
+    LLMJudgeTrajectorySimulationEvaluator,
+    MulticlassClassificationEvaluator,
+    ToolCallArgsEvaluator,
+    ToolCallCountEvaluator,
+    ToolCallOrderEvaluator,
+    ToolCallOutputEvaluator,
+)
+from .base_evaluator import BaseEvaluator, BaseEvaluatorConfig
+
+
+class UnknownLegacyEvaluator(BaseLegacyEvaluator[Any]):
+    """Fallback evaluator for unknown legacy evaluator types."""
+
+    pass
+
+
+class UnknownEvaluatorConfig(BaseEvaluatorConfig[Any]):
+    """Fallback config for unknown evaluator types."""
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class UnknownCodedEvaluator(BaseEvaluator[Any, Any, Any]):
+    """Fallback evaluator for unknown coded evaluator types."""
+
+    pass
+
+
+def legacy_evaluator_discriminator(data: Any) -> str:
+    """Determine the specific legacy evaluator type based on category and type fields."""
+    if isinstance(data, dict):
+        category = data.get("category")
+        evaluator_type = data.get("type")
+        match category:
+            case LegacyEvaluatorCategory.LlmAsAJudge:
+                return "LegacyLLMEvaluator"
+            case LegacyEvaluatorCategory.Trajectory:
+                return "LegacyTrajectoryEvaluator"
+            case LegacyEvaluatorCategory.Deterministic:
+                match evaluator_type:
+                    case LegacyEvaluatorType.Equals:
+                        return "LegacyEqualsEvaluator"
+                    case LegacyEvaluatorType.JsonSimilarity:
+                        return "LegacyJsonSimilarityEvaluator"
+                    case LegacyEvaluatorType.CSVColumnExactMatch:
+                        return "LegacyCSVExactMatchEvaluator"
+                    case _:
+                        return "LegacyUnknownEvaluator"
+            case _:
+                return "LegacyUnknownEvaluator"
+    else:
+        return "LegacyUnknownLegacyEvaluator"
+
+
+LegacyEvaluator = Annotated[
+    Union[
+        Annotated[
+            LegacyLlmAsAJudgeEvaluator,
+            Tag("LegacyLLMEvaluator"),
+        ],
+        Annotated[
+            LegacyTrajectoryEvaluator,
+            Tag("LegacyTrajectoryEvaluator"),
+        ],
+        Annotated[
+            LegacyExactMatchEvaluator,
+            Tag("LegacyEqualsEvaluator"),
+        ],
+        Annotated[
+            LegacyJsonSimilarityEvaluator,
+            Tag("LegacyJsonSimilarityEvaluator"),
+        ],
+        Annotated[
+            LegacyCSVExactMatchEvaluator,
+            Tag("LegacyCSVExactMatchEvaluator"),
+        ],
+        Annotated[
+            UnknownLegacyEvaluator,
+            Tag("LegacyUnknownEvaluator"),
+        ],
+    ],
+    Field(discriminator=Discriminator(legacy_evaluator_discriminator)),
+]
+
+
+def coded_evaluator_discriminator(data: Any) -> str:
+    """Determine the specific coded evaluator type based on evaluatorTypeId field."""
+    if isinstance(data, dict):
+        evaluator_type_id = data.get("evaluatorTypeId")
+        match evaluator_type_id:
+            case EvaluatorType.CONTAINS:
+                return "ContainsEvaluator"
+            case EvaluatorType.EXACT_MATCH:
+                return "ExactMatchEvaluator"
+            case EvaluatorType.JSON_SIMILARITY:
+                return "JsonSimilarityEvaluator"
+            case EvaluatorType.LLM_JUDGE_OUTPUT_SEMANTIC_SIMILARITY:
+                return "LLMJudgeOutputEvaluator"
+            case EvaluatorType.LLM_JUDGE_OUTPUT_STRICT_JSON_SIMILARITY:
+                return "LLMJudgeStrictJSONSimilarityOutputEvaluator"
+            case EvaluatorType.LLM_JUDGE_TRAJECTORY_SIMILARITY:
+                return "LLMJudgeTrajectoryEvaluator"
+            case EvaluatorType.LLM_JUDGE_TRAJECTORY_SIMULATION:
+                return "LLMJudgeTrajectorySimulationEvaluator"
+            case EvaluatorType.TOOL_CALL_ARGS:
+                return "ToolCallArgsEvaluator"
+            case EvaluatorType.TOOL_CALL_COUNT:
+                return "ToolCallCountEvaluator"
+            case EvaluatorType.TOOL_CALL_ORDER:
+                return "ToolCallOrderEvaluator"
+            case EvaluatorType.TOOL_CALL_OUTPUT:
+                return "ToolCallOutputEvaluator"
+            case EvaluatorType.BINARY_CLASSIFICATION:
+                return "BinaryClassificationEvaluator"
+            case EvaluatorType.MULTICLASS_CLASSIFICATION:
+                return "MulticlassClassificationEvaluator"
+            case _:
+                return "UnknownEvaluator"
+    else:
+        return "UnknownEvaluator"
+
+
+CodedEvaluator = Annotated[
+    Union[
+        Annotated[
+            ContainsEvaluator,
+            Tag("ContainsEvaluator"),
+        ],
+        Annotated[
+            ExactMatchEvaluator,
+            Tag("ExactMatchEvaluator"),
+        ],
+        Annotated[
+            JsonSimilarityEvaluator,
+            Tag("JsonSimilarityEvaluator"),
+        ],
+        Annotated[
+            LLMJudgeOutputEvaluator,
+            Tag("LLMJudgeOutputEvaluator"),
+        ],
+        Annotated[
+            LLMJudgeStrictJSONSimilarityOutputEvaluator,
+            Tag("LLMJudgeStrictJSONSimilarityOutputEvaluator"),
+        ],
+        Annotated[
+            LLMJudgeTrajectoryEvaluator,
+            Tag("LLMJudgeTrajectoryEvaluator"),
+        ],
+        Annotated[
+            ToolCallArgsEvaluator,
+            Tag("ToolCallArgsEvaluator"),
+        ],
+        Annotated[
+            ToolCallCountEvaluator,
+            Tag("ToolCallCountEvaluator"),
+        ],
+        Annotated[
+            ToolCallOrderEvaluator,
+            Tag("ToolCallOrderEvaluator"),
+        ],
+        Annotated[
+            ToolCallOutputEvaluator,
+            Tag("ToolCallOutputEvaluator"),
+        ],
+        Annotated[
+            LLMJudgeTrajectorySimulationEvaluator,
+            Tag("LLMJudgeTrajectorySimulationEvaluator"),
+        ],
+        Annotated[
+            BinaryClassificationEvaluator,
+            Tag("BinaryClassificationEvaluator"),
+        ],
+        Annotated[
+            MulticlassClassificationEvaluator,
+            Tag("MulticlassClassificationEvaluator"),
+        ],
+        Annotated[
+            UnknownCodedEvaluator,
+            Tag("UnknownEvaluator"),
+        ],
+    ],
+    Field(discriminator=Discriminator(coded_evaluator_discriminator)),
+]
+
+
+def evaluator_discriminator(data: Any) -> str:
+    """Determine the specific evaluator type (legacy vs coded) based on presence of version field."""
+    if "version" in data:
+        return "CodedEvaluator"
+    else:
+        return "LegacyEvaluator"
+
+
+Evaluator = Annotated[
+    Union[
+        Annotated[
+            LegacyEvaluator,
+            Tag("LegacyEvaluator"),
+        ],
+        Annotated[
+            CodedEvaluator,
+            Tag("CodedEvaluator"),
+        ],
+    ],
+    Field(discriminator=Discriminator(evaluator_discriminator)),
+]
diff --git a/packages/uipath/src/uipath/eval/evaluators/evaluator_factory.py b/packages/uipath/src/uipath/eval/evaluators/evaluator_factory.py
new file mode 100644
index 000000000..6a80caac6
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/evaluator_factory.py
@@ -0,0 +1,223 @@
+"""Factory class for creating evaluator instances based on configuration."""
+
+import importlib.util
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+from pydantic import TypeAdapter
+
+from ..constants import CUSTOM_EVALUATOR_PREFIX, EVALS_FOLDER
+from . import (
+    BaseEvaluator,
+    BaseLegacyEvaluator,
+    LegacyContextPrecisionEvaluator,
+    LegacyFaithfulnessEvaluator,
+    LegacyLlmAsAJudgeEvaluator,
+    LegacyTrajectoryEvaluator,
+)
+from .base_evaluator import GenericBaseEvaluator
+from .evaluator import CodedEvaluator, LegacyEvaluator
+
+logger = logging.getLogger(__name__)
+
+
+def _try_extract_file_and_class_name(text: str) -> tuple[bool, str, str]:
+    if text.startswith(CUSTOM_EVALUATOR_PREFIX):
+        file_and_class = text[len(CUSTOM_EVALUATOR_PREFIX) :]
+        if ":" not in file_and_class:
+            raise ValueError(
+                f"evaluatorSchema must include class name after ':' - got: {text}"
+            )
+        file_path_str, class_name = file_and_class.rsplit(":", 1)
+
+        return True, file_path_str, class_name
+    return False, "", ""
+
+
+class EvaluatorFactory:
+    """Factory class for creating evaluator instances based on configuration."""
+
+    @staticmethod
+    def _prepare_evaluator_config(data: dict[str, Any]) -> dict[str, Any]:
+        """Prepare evaluator config by merging top-level fields into evaluatorConfig.
+
+        This allows flexibility in specifying fields like 'name' and 'description' either at the
+        top level or within evaluatorConfig. Top-level values take precedence if both exist.
+
+        Args:
+            data: The raw evaluator data dictionary
+
+        Returns:
+            The prepared evaluatorConfig with merged fields
+        """
+        evaluator_config = data.get("evaluatorConfig", {})
+        if not isinstance(evaluator_config, dict):
+            evaluator_config = {}
+        else:
+            # Create a copy to avoid modifying the original
+            evaluator_config = evaluator_config.copy()
+
+        # Merge top-level 'name' into config if present
+        if "name" in data and data["name"] is not None:
+            # Top-level name takes precedence
+            evaluator_config["name"] = data["name"]
+
+        # Merge top-level 'description' into config if present
+        if "description" in data and data["description"] is not None:
+            # Top-level description takes precedence
+            evaluator_config["description"] = data["description"]
+
+        return evaluator_config
+
+    @classmethod
+    def create_evaluator(
+        cls,
+        data: dict[str, Any],
+        evaluators_dir: Path | None = None,
+        agent_model: str | None = None,
+    ) -> GenericBaseEvaluator[Any, Any, Any]:
+        """Create an evaluator instance from configuration data."""
+        if data.get("version", None) == "1.0":
+            return cls._create_evaluator_internal(data, evaluators_dir)
+        else:
+            return cls._create_legacy_evaluator_internal(data, agent_model)
+
+    @staticmethod
+    def _create_evaluator_internal(
+        data: dict[str, Any],
+        evaluators_dir: Path | None = None,
+    ) -> BaseEvaluator[Any, Any, Any]:
+        # check custom evaluator
+        evaluator_schema = data.get("evaluatorSchema", "")
+        success, file_path, class_name = _try_extract_file_and_class_name(
+            evaluator_schema
+        )
+        if success:
+            return EvaluatorFactory._create_custom_coded_evaluator_internal(
+                data, file_path, class_name, evaluators_dir
+            )
+        else:
+            return TypeAdapter(CodedEvaluator).validate_python(data)
+
+    @staticmethod
+    def _create_custom_coded_evaluator_internal(
+        data: dict[str, Any],
+        file_path_str: str,
+        class_name: str,
+        evaluators_dir: Path | None = None,
+    ) -> BaseEvaluator[Any, Any, Any]:
+        """Create a custom coded evaluator by dynamically loading from a Python file.
+
+        Args:
+            data: Dictionary containing evaluator configuration with evaluatorTypeId
+                  in format "file://path/to/file.py:ClassName"
+            evaluators_dir: Directory containing evaluator configuration files
+
+        Returns:
+            Instance of the dynamically loaded evaluator class
+
+        Raises:
+            ValueError: If file or class cannot be loaded, or if the class is not a BaseEvaluator subclass
+        """
+        file_path = Path(file_path_str)
+        if not file_path.is_absolute():
+            if not file_path.exists():
+                if evaluators_dir is not None:
+                    # Try the file directly in evaluators_dir first
+                    file_path = evaluators_dir / file_path_str
+                    if not file_path.exists():
+                        # Fall back to evaluators_dir/custom/
+                        file_path = evaluators_dir / "custom" / file_path_str
+                else:
+                    # Fall back to the old behavior
+                    file_path = (
+                        Path.cwd()
+                        / EVALS_FOLDER
+                        / "evaluators"
+                        / "custom"
+                        / file_path_str
+                    )
+
+        if not file_path.exists():
+            raise ValueError(
+                f"Evaluator file not found: {file_path}. "
+                f"Make sure the file exists in the evaluators/custom/ directory"
+            )
+
+        module_name = f"_custom_evaluator_{file_path.stem}_{id(data)}"
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None or spec.loader is None:
+            raise ValueError(f"Could not load module from {file_path}")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise ValueError(
+                f"Error executing module from {file_path}: {str(e)}"
+            ) from e
+
+        # Get the class from the module
+        if not hasattr(module, class_name):
+            raise ValueError(
+                f"Class '{class_name}' not found in {file_path}. "
+                f"Available classes: {[name for name in dir(module) if not name.startswith('_')]}"
+            )
+
+        evaluator_class = getattr(module, class_name)
+
+        if not isinstance(evaluator_class, type) or not issubclass(
+            evaluator_class, BaseEvaluator
+        ):
+            raise ValueError(
+                f"Class '{class_name}' must be a subclass of BaseEvaluator"
+            )
+
+        evaluator_id = data.get("id")
+        if not evaluator_id or not isinstance(evaluator_id, str):
+            raise ValueError("Evaluator 'id' must be a non-empty string")
+        return TypeAdapter(evaluator_class).validate_python(data)
+
+    @staticmethod
+    def _create_legacy_evaluator_internal(
+        data: dict[str, Any],
+        agent_model: str | None = None,
+    ) -> BaseLegacyEvaluator[Any]:
+        """Create an evaluator instance from configuration data.
+
+        Args:
+            data: Dictionary containing evaluator configuration from JSON file
+            agent_model: Optional model name from agent settings for resolving
+                'same-as-agent' model configuration
+
+        Returns:
+            Appropriate evaluator instance based on category
+
+        Raises:
+            ValueError: If category is unknown or required fields are missing
+        """
+        evaluator: LegacyEvaluator = TypeAdapter(LegacyEvaluator).validate_python(data)
+
+        if isinstance(
+            evaluator,
+            LegacyTrajectoryEvaluator
+            | LegacyLlmAsAJudgeEvaluator
+            | LegacyContextPrecisionEvaluator
+            | LegacyFaithfulnessEvaluator,
+        ):
+            if evaluator.model == "same-as-agent":
+                if not agent_model:
+                    raise ValueError(
+                        "'same-as-agent' model option requires agent settings. "
+                        "Ensure agent.json contains valid model settings."
+                    )
+                logger.info(
+                    f"Resolving 'same-as-agent' to agent model: {agent_model} "
+                    f"for evaluator '{evaluator.name}'"
+                )
+                evaluator.model = agent_model
+
+        return evaluator
diff --git a/packages/uipath/src/uipath/eval/evaluators/exact_match_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/exact_match_evaluator.py
new file mode 100644
index 000000000..0f1b3e8e8
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/exact_match_evaluator.py
@@ -0,0 +1,84 @@
+"""Exact match evaluator for agent outputs."""
+
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+    NumericEvaluationResult,
+)
+from .base_evaluator import BaseEvaluatorJustification
+from .output_evaluator import (
+    OutputEvaluationCriteria,
+    OutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class ExactMatchEvaluatorConfig(OutputEvaluatorConfig[OutputEvaluationCriteria]):
+    """Configuration for the exact match evaluator."""
+
+    name: str = "ExactMatchEvaluator"
+    case_sensitive: bool = False
+    negated: bool = False
+
+
+class ExactMatchEvaluator(
+    OutputEvaluator[
+        OutputEvaluationCriteria, ExactMatchEvaluatorConfig, BaseEvaluatorJustification
+    ]
+):
+    """Evaluator that performs exact structural matching between expected and actual outputs.
+
+    This evaluator returns True if the actual output exactly matches the expected output
+    after canonical JSON normalization, and False otherwise. Numbers are normalized
+    to floats for consistent comparison.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.EXACT_MATCH.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: OutputEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate whether actual output exactly matches expected output.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The actual output from the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Boolean result indicating exact match (True/False)
+        """
+        actual_output = self._get_actual_output(agent_execution)
+        expected_output = self._get_expected_output(evaluation_criteria)
+
+        if isinstance(actual_output, str) or isinstance(expected_output, str):
+            actual_str = str(actual_output)
+            expected_str = str(expected_output)
+            if not self.evaluator_config.case_sensitive:
+                actual_str = actual_str.lower()
+                expected_str = expected_str.lower()
+            is_exact_match = actual_str == expected_str
+        else:
+            is_exact_match = actual_output == expected_output
+
+        if self.evaluator_config.negated:
+            is_exact_match = not is_exact_match
+
+        validated_justification = self.validate_justification(
+            {
+                "expected": str(expected_output),
+                "actual": str(actual_output),
+            }
+        )
+        return NumericEvaluationResult(
+            score=float(is_exact_match),
+            details=validated_justification,
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators/json_similarity_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/json_similarity_evaluator.py
new file mode 100644
index 000000000..552194f2e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/json_similarity_evaluator.py
@@ -0,0 +1,200 @@
+"""JSON similarity evaluator for flexible structural comparison of outputs."""
+
+import math
+from typing import Any, Tuple
+
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+    NumericEvaluationResult,
+)
+from .base_evaluator import BaseEvaluatorJustification
+from .output_evaluator import (
+    OutputEvaluationCriteria,
+    OutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class JsonSimilarityJustification(BaseEvaluatorJustification):
+    """Justification for the JSON similarity evaluator."""
+
+    matched_leaves: float
+    total_leaves: float
+
+
+class JsonSimilarityEvaluatorConfig(OutputEvaluatorConfig[OutputEvaluationCriteria]):
+    """Configuration for the json similarity evaluator."""
+
+    name: str = "JsonSimilarityEvaluator"
+
+
+class JsonSimilarityEvaluator(
+    OutputEvaluator[
+        OutputEvaluationCriteria,
+        JsonSimilarityEvaluatorConfig,
+        JsonSimilarityJustification,
+    ]
+):
+    """Deterministic evaluator that scores structural JSON similarity between expected and actual output.
+
+    Compares expected versus actual JSON-like structures and returns a
+    numerical score in the range [0, 100]. The comparison is token-based
+    and tolerant for numbers and strings (via Levenshtein distance).
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.JSON_SIMILARITY.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: OutputEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate similarity between expected and actual JSON outputs.
+
+        Uses token-based comparison with tolerance for numeric differences
+        and Levenshtein distance for string similarity.
+
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Numerical score between 0-100 indicating similarity
+        """
+        expected_output = self._get_expected_output(evaluation_criteria)
+        actual_output = self._get_actual_output(agent_execution)
+        score, justification = self._compare_json(
+            expected_output,
+            actual_output,
+        )
+        validated_justification = self.validate_justification(justification)
+        return NumericEvaluationResult(
+            score=score,
+            details=validated_justification,
+        )
+
+    def _compare_json(self, expected: Any, actual: Any) -> tuple[float, dict[str, Any]]:
+        matched_leaves, total_leaves = self._compare_tokens(expected, actual)
+        if total_leaves == 0:
+            sim = 1.0
+        else:
+            sim = matched_leaves / total_leaves
+        return (
+            max(0.0, min(1.0, sim)),
+            {
+                "expected": str(expected),
+                "actual": str(actual),
+                "matched_leaves": matched_leaves,
+                "total_leaves": total_leaves,
+            },
+        )
+
+    def _compare_tokens(
+        self, expected_token: Any, actual_token: Any
+    ) -> Tuple[float, float]:
+        if self._is_number(expected_token) and self._is_number(actual_token):
+            return self._compare_numbers(float(expected_token), float(actual_token))
+
+        if type(expected_token) is not type(actual_token):
+            return 0.0, self._count_leaves(expected_token)
+
+        if isinstance(expected_token, dict):
+            matched_leaves = total_leaves = 0.0
+            # Only expected keys count
+            for expected_key, expected_value in expected_token.items():
+                if isinstance(actual_token, dict) and expected_key in actual_token:
+                    matched, total = self._compare_tokens(
+                        expected_value, actual_token[expected_key]
+                    )
+                else:
+                    matched, total = (0.0, self._count_leaves(expected_value))
+                matched_leaves += matched
+                total_leaves += total
+            return matched_leaves, total_leaves
+
+        if isinstance(expected_token, list):
+            matched_leaves = total_leaves = 0.0
+            common_length = min(len(expected_token), len(actual_token))
+            for index in range(common_length):
+                matched, total = self._compare_tokens(
+                    expected_token[index], actual_token[index]
+                )
+                matched_leaves += matched
+                total_leaves += total
+            for index in range(common_length, len(expected_token)):
+                total_leaves += self._count_leaves(expected_token[index])
+            return (matched_leaves, total_leaves)
+
+        if isinstance(expected_token, bool):
+            return (1.0, 1.0) if expected_token == actual_token else (0.0, 1.0)
+
+        if isinstance(expected_token, str):
+            return self._compare_strings(expected_token, actual_token)
+
+        return (1.0, 1.0) if str(expected_token) == str(actual_token) else (0.0, 1.0)
+
+    def _compare_numbers(
+        self, expected_number: float, actual_number: float
+    ) -> Tuple[float, float]:
+        total = 1.0
+        if math.isclose(expected_number, 0.0, abs_tol=1e-12):
+            matched = 1.0 if math.isclose(actual_number, 0.0, abs_tol=1e-12) else 0.0
+        else:
+            ratio = abs(expected_number - actual_number) / abs(expected_number)
+            matched = max(0.0, min(1.0, 1.0 - ratio))
+        return matched, total
+
+    def _compare_strings(
+        self, expected_string: str, actual_string: str
+    ) -> Tuple[float, float]:
+        total = 1.0
+        if not expected_string and not actual_string:
+            return 1.0, total
+        distance = self._levenshtein(expected_string, actual_string)
+        max_length = max(len(expected_string), len(actual_string))
+        similarity = 1.0 - (distance / max_length) if max_length else 1.0
+        similarity = max(0.0, min(1.0, similarity))
+        return similarity, total
+
+    def _count_leaves(self, token_node: Any) -> float:
+        if isinstance(token_node, dict):
+            return sum(
+                self._count_leaves(child_value) for child_value in token_node.values()
+            )
+        if isinstance(token_node, list):
+            return sum(self._count_leaves(child_value) for child_value in token_node)
+        return 1.0
+
+    def _levenshtein(self, source_text: str, target_text: str) -> int:
+        if not source_text:
+            return len(target_text)
+        if not target_text:
+            return len(source_text)
+        source_len, target_len = len(source_text), len(target_text)
+        distance_matrix = [[0] * (target_len + 1) for _ in range(source_len + 1)]
+        for row_idx in range(source_len + 1):
+            distance_matrix[row_idx][0] = row_idx
+        for col_idx in range(target_len + 1):
+            distance_matrix[0][col_idx] = col_idx
+        for row_idx in range(1, source_len + 1):
+            for col_idx in range(1, target_len + 1):
+                substitution_cost = (
+                    0 if source_text[row_idx - 1] == target_text[col_idx - 1] else 1
+                )
+                distance_matrix[row_idx][col_idx] = min(
+                    distance_matrix[row_idx - 1][col_idx] + 1,  # deletion
+                    distance_matrix[row_idx][col_idx - 1] + 1,  # insertion
+                    distance_matrix[row_idx - 1][col_idx - 1]
+                    + substitution_cost,  # substitution
+                )
+        return distance_matrix[source_len][target_len]
+
+    def _is_number(self, value: Any) -> bool:
+        return isinstance(value, (int, float)) and not isinstance(value, bool)
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_context_precision_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_context_precision_evaluator.py
new file mode 100644
index 000000000..3b0468363
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_context_precision_evaluator.py
@@ -0,0 +1,389 @@
+"""Legacy Context Precision evaluator for assessing the relevance of context chunks to queries."""
+
+import ast
+import json
+from typing import Any, Optional
+
+from pydantic import Field
+
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+
+from .._execution_context import eval_set_run_id_context
+from ..models import NumericEvaluationResult
+from ..models.models import AgentExecution, EvaluationResult
+from .base_legacy_evaluator import (
+    BaseLegacyEvaluator,
+    LegacyEvaluationCriteria,
+    LegacyEvaluatorConfig,
+    track_evaluation_metrics,
+)
+from .legacy_evaluator_utils import clean_model_name, serialize_object
+
+
+class LegacyContextPrecisionEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy context precision evaluators."""
+
+    name: str = "LegacyContextPrecisionEvaluator"
+    model: str = ""
+
+
+PROMPT = """You are an expert evaluator assessing the relevance of context chunks to a given query.
+
+TASK: Evaluate how relevant each provided context chunk is to answering the query.
+Your scoring should be deterministic - the same chunk-query pair should always receive the same score.
+
+EVALUATION CRITERIA:
+Score each chunk using the HIGHEST applicable range (if multiple apply, use the highest):
+
+- HIGHLY RELEVANT (80-100) - Directly answers or addresses the query:
+  * 95-100: Contains the exact, complete answer to the query
+  * 85-94: Directly addresses the query with comprehensive information (but not the complete answer)
+  * 80-84: Provides a direct but partial answer to the query
+
+- MODERATELY RELEVANT (50-79) - Provides useful supporting information:
+  * 70-79: Contains substantial supporting information that helps understand the topic
+  * 60-69: Provides relevant context or background information
+  * 50-59: Has some connection to the query but limited usefulness
+
+- SLIGHTLY RELEVANT (20-49) - Contains tangentially related information:
+  * 35-49: Mentions related concepts, terms, or entities from the query
+  * 20-34: Very indirect connection to the query topic
+
+- NOT RELEVANT (0-19) - Has no meaningful connection to the query:
+  * 10-19: Contains some keywords from the query but no meaningful connection
+  * 0-9: Completely unrelated to the query or empty/malformed content
+
+IMPORTANT INSTRUCTIONS:
+1. Evaluate EACH chunk independently - do not let one chunk influence another's score
+2. Base relevance ONLY on how well the chunk helps answer the specific query
+3. Consider semantic meaning, not just keyword matches
+4. If a chunk is empty or malformed, assign a score of 0
+5. Scores must be integers between 0 and 100 inclusive
+6. Be consistent: similar content should receive similar scores
+7. Use the specific sub-ranges above to guide precise scoring
+8. HIERARCHY RULE: If a chunk meets criteria for multiple ranges, always assign the HIGHEST applicable score
+
+OUTPUT FORMAT:
+You MUST respond using the provided tool with a JSON object containing:
+- A "relevancies" field that is an array
+- Each array element must be an object with "relevancy_score" (integer 0-100)
+- The array must have the same number of elements as context chunks provided
+- Order matters: the first score corresponds to the first chunk, etc.
+
+EXAMPLE STRUCTURE (do not copy values, this is just format):
+{
+  "relevancies": [
+    {"relevancy_score": 85},
+    {"relevancy_score": 45},
+    {"relevancy_score": 0}
+  ]
+}
+
+<query>
+{{Query}}
+</query>
+
+<context_chunks>
+{{Chunks}}
+</context_chunks>
+
+Evaluate each chunk's relevance to the query and respond with the structured output."""
+
+
+class LegacyContextPrecisionEvaluator(
+    BaseLegacyEvaluator[LegacyContextPrecisionEvaluatorConfig]
+):
+    """Legacy evaluator that assesses context precision using an LLM.
+
+    This evaluator extracts context grounding spans from agent execution traces
+    and uses an LLM to score the relevance of each chunk to its corresponding query.
+    The final score is the mean of all chunk relevancy scores (normalized to 0-1).
+    """
+
+    model: str = Field(default="same-as-agent")
+    query_placeholder: str = "{{Query}}"
+    chunks_placeholder: str = "{{Chunks}}"
+    llm: Optional[UiPathLlmChatService] = None
+
+    def model_post_init(self, __context: Any):
+        """Initialize the evaluator after model creation."""
+        super().model_post_init(__context)
+
+    def _initialize_llm(self):
+        """Initialize the LLM used for evaluation."""
+        uipath = UiPath()
+        self.llm = UiPathLlmChatService(
+            uipath._config,
+            uipath._execution_context,
+            requesting_product="agentsplayground",
+            requesting_feature="agents-evaluations",
+            agenthub_config="agentsevals",
+            action_id=eval_set_run_id_context.get(),
+        )
+
+    @track_evaluation_metrics
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate context precision from agent execution traces.
+
+        Args:
+            agent_execution: The execution details containing agent_trace with spans
+            evaluation_criteria: Legacy evaluation criteria (unused for context precision)
+
+        Returns:
+            NumericEvaluationResult with normalized score (0-1) and detailed justification
+        """
+        # Lazily initialize the LLM on first evaluation call
+        if self.llm is None:
+            self._initialize_llm()
+
+        # Extract context grounding spans from the trace
+        context_groundings = self._extract_context_groundings(
+            agent_execution.agent_trace
+        )
+
+        if not context_groundings:
+            return NumericEvaluationResult(
+                score=0.0,
+                details="No context grounding tool calls found in the agent execution trace.",
+            )
+
+        # Evaluate each context grounding call
+        all_scores = []
+        evaluation_details = []
+
+        for idx, grounding in enumerate(context_groundings, 1):
+            query = grounding.get("query", "")
+            chunks = grounding.get("chunks", [])
+
+            if not query or not chunks:
+                evaluation_details.append(
+                    f"{idx}. Query: (empty) - SKIPPED (no query or chunks)"
+                )
+                continue
+
+            scores = await self._evaluate_context_grounding(query, chunks)
+
+            if scores:
+                mean_score = sum(scores) / len(scores)
+                all_scores.append(mean_score)
+
+                # Format score summaries for this grounding
+                score_summaries = [f"Relevancy: {s:d}/100" for s in scores]
+                evaluation_details.append(
+                    f'{idx}. Query: "{query}"\n'
+                    f"\tAvg. Score: {mean_score:.1f}/100 ({len(scores)} chunks). "
+                    f"Chunk Relevancies: [{', '.join(score_summaries)}]."
+                )
+
+        if not all_scores:
+            return NumericEvaluationResult(
+                score=0.0,
+                details="No valid context chunks were found for evaluation.",
+            )
+
+        # Calculate overall mean score (0-100 range)
+        overall_mean = sum(all_scores) / len(all_scores)
+        overall_mean = max(0, min(100, overall_mean))
+
+        # Build justification
+        justification = f"Overall Context Precision: {overall_mean:.1f}/100 ({len(context_groundings)} Context Tool Call(s) evaluated).\n"
+        if evaluation_details:
+            justification += "---\nPer-Context Tool Call Details:\n\n"
+            justification += "\n\n".join(evaluation_details)
+
+        return NumericEvaluationResult(
+            score=overall_mean,
+            details=justification,
+        )
+
+    def _parse_span_value(self, value_str: str) -> Any:
+        """Parse span value that could be JSON or Python literal syntax.
+
+        Args:
+            value_str: String that could be JSON or Python literal (dict/list)
+
+        Returns:
+            Parsed Python object (dict, list, etc.)
+
+        Raises:
+            ValueError: If string cannot be parsed as JSON or literal
+        """
+        try:
+            # Try JSON first (most common)
+            return json.loads(value_str)
+        except json.JSONDecodeError:
+            try:
+                # Fall back to Python literal_eval for Python syntax
+                return ast.literal_eval(value_str)
+            except (ValueError, SyntaxError) as e:
+                raise ValueError(f"Cannot parse value: {value_str}") from e
+
+    def _extract_context_groundings(
+        self, agent_trace: list[Any]
+    ) -> list[dict[str, Any]]:
+        """Extract context groundings from agent execution trace.
+
+        Looks for spans with input.value and output.value attributes that represent
+        context grounding tool calls.
+        """
+        context_groundings = []
+
+        for span in agent_trace:
+            if not hasattr(span, "attributes") or span.attributes is None:
+                continue
+
+            attrs = span.attributes
+
+            if attrs.get("openinference.span.kind", None) != "RETRIEVER":
+                # NOTE: all tool calls can be extracted using this approach
+                continue
+
+            # Look for spans with input.value and output.value (context grounding calls)
+            query = attrs.get("input.value")
+            try:
+                chunks = self._normalize_chunks(
+                    json.loads(attrs.get("output.value")).get("documents")
+                )
+
+                if chunks:
+                    context_groundings.append(
+                        {
+                            "query": str(query),
+                            "chunks": chunks,
+                        }
+                    )
+            except (ValueError, KeyError, TypeError):
+                # Skip spans that don't have the expected structure
+                continue
+
+        return context_groundings
+
+    def _normalize_chunks(self, results: Any) -> list[str]:
+        """Normalize various chunk representations to a list of strings."""
+        if isinstance(results, list):
+            return [self._serialize_chunk(chunk) for chunk in results]
+        elif isinstance(results, dict):
+            # Handle dict representations of chunks
+            return [self._serialize_chunk(results)]
+        elif isinstance(results, str):
+            return [results]
+        else:
+            return [str(results)]
+
+    def _serialize_chunk(self, chunk: Any) -> str:
+        """Serialize a single chunk to string format."""
+        return serialize_object(chunk, sort_keys=True)
+
+    async def _evaluate_context_grounding(
+        self, query: str, chunks: list[str]
+    ) -> list[int]:
+        """Evaluate the relevance of chunks to a query using the LLM.
+
+        Args:
+            query: The query string
+            chunks: List of context chunks to evaluate
+
+        Returns:
+            List of relevancy scores (0-100) for each chunk
+        """
+        # Create evaluation prompt
+        chunks_text = "\n".join(chunks)
+        prompt = PROMPT.replace(self.query_placeholder, query).replace(
+            self.chunks_placeholder, chunks_text
+        )
+
+        # Get LLM response
+        response_obj = await self._get_structured_llm_response(prompt)
+
+        # Extract relevancy scores from response
+        relevancies = response_obj.get("relevancies", [])
+        if not relevancies:
+            raise ValueError("No relevancies found in LLM response")
+
+        scores = []
+        for rel in relevancies:
+            if isinstance(rel, dict) and "relevancy_score" in rel:
+                score = rel["relevancy_score"]
+                # Clamp score to 0-100
+                score = max(0, min(100, int(score)))
+                scores.append(score)
+
+        return scores
+
+    async def _get_structured_llm_response(
+        self, evaluation_prompt: str
+    ) -> dict[str, Any]:
+        """Get structured LLM response using function calling."""
+        from uipath.platform.chat.llm_gateway import (
+            RequiredToolChoice,
+            ToolDefinition,
+            ToolFunctionDefinition,
+            ToolParametersDefinition,
+        )
+
+        # Remove community-agents suffix from llm model name
+        model = clean_model_name(self.model)
+
+        # Create tool definition for context precision evaluation
+        # Note: We pass the array schema as a raw dict because ToolPropertyDefinition
+        # doesn't support the 'items' field needed for array types
+        tool = ToolDefinition(
+            type="function",
+            function=ToolFunctionDefinition(
+                name="submit_context_precision_evaluation",
+                description="Submit relevancy scores for context chunks",
+                parameters=ToolParametersDefinition(
+                    type="object",
+                    properties={
+                        "relevancies": {  # type: ignore[dict-item]
+                            "type": "array",
+                            "description": "List of relevancy scores for each context chunk",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "relevancy_score": {
+                                        "type": "number",
+                                        "description": "Relevancy score for the chunk (0-100).",
+                                    }
+                                },
+                                "required": ["relevancy_score"],
+                            },
+                        }
+                    },
+                    required=["relevancies"],
+                ),
+            ),
+        )
+
+        tool_choice = RequiredToolChoice()
+
+        # Prepare the request with function calling
+        request_data = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": "Context Precision Evaluation"},
+                {"role": "user", "content": evaluation_prompt},
+            ],
+            "tools": [tool],
+            "tool_choice": tool_choice,
+        }
+
+        assert self.llm, "LLM should be initialized before calling this method."
+        response = await self.llm.chat_completions(**request_data)
+
+        # Extract from tool call
+        if (
+            response.choices
+            and response.choices[0].message.tool_calls
+            and len(response.choices[0].message.tool_calls) > 0
+        ):
+            tool_call = response.choices[0].message.tool_calls[0]
+            return tool_call.arguments
+
+        # Fallback to empty dict if no tool calls
+        return {}
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_csv_exact_match_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_csv_exact_match_evaluator.py
new file mode 100644
index 000000000..0b7bac2b4
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_csv_exact_match_evaluator.py
@@ -0,0 +1,419 @@
+"""CSV exact match evaluator for comparing specific columns in CSV outputs."""
+
+import csv
+import io
+import json
+from typing import Any
+
+from pydantic import Field, field_validator
+
+from uipath.eval.models import (
+    BooleanEvaluationResult,
+    EvaluationResult,
+)
+
+from ..models.models import AgentExecution
+from .base_legacy_evaluator import LegacyEvaluationCriteria, LegacyEvaluatorConfig
+from .legacy_deterministic_evaluator_base import BaseLegacyDeterministicEvaluator
+from .line_by_line_utils import wrap_line_in_structure
+
+
+class LegacyCSVExactMatchEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy CSV exact-match evaluators."""
+
+    name: str = "LegacyCSVExactMatchEvaluator"
+
+
+class LegacyCSVExactMatchEvaluator(
+    BaseLegacyDeterministicEvaluator[LegacyCSVExactMatchEvaluatorConfig]
+):
+    """Evaluator that performs exact matching on specific columns in CSV outputs.
+
+    This evaluator compares specific columns from actual and expected CSV outputs.
+    It supports:
+    - Multiple column comparison (comma-separated column names)
+    - Case-insensitive column name matching
+    - Job attachment inputs (automatic via base class)
+    - Line-by-line evaluation (CSV-aware: preserves headers for each row)
+
+    Line-by-line mode:
+    When line_by_line_evaluation=True, the evaluator splits CSVs by line_delimiter
+    and evaluates each data row separately. Headers from the first line are
+    automatically prepended to each data row to create valid mini-CSVs.
+    Results are aggregated using the average of all row scores.
+    """
+
+    target_sub_output_key: str = Field(
+        ...,
+        alias="targetSubOutputKey",
+        description="Comma-separated list of column names to compare",
+    )
+
+    @field_validator("target_sub_output_key")
+    @classmethod
+    def validate_target_sub_output_key(cls, v: str) -> str:
+        """Validate that target_sub_output_key is not empty."""
+        if not v or not v.strip():
+            raise ValueError("target_sub_output_key must not be empty")
+        return v
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate whether specific CSV columns exactly match between actual and expected.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The actual output from the agent (can be CSV string or job attachment)
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate containing expected output
+
+        Returns:
+            EvaluationResult: Boolean result indicating whether the specified columns match
+
+        Raises:
+            ValueError: If CSV format is invalid or required columns are missing
+        """
+        # Get actual output (handles job attachments and target_output_key extraction)
+        actual_output = self._get_actual_output(agent_execution)
+
+        # Get expected output from criteria
+        expected_output = evaluation_criteria.expected_output
+
+        # Extract based on target_output_key if not wildcard
+        if self.target_output_key and self.target_output_key != "*":
+            if (
+                isinstance(expected_output, dict)
+                and self.target_output_key in expected_output
+            ):
+                expected_output = expected_output[self.target_output_key]
+
+        # Extract CSV content from the outputs
+        actual_csv = self._extract_csv_content(actual_output)
+        expected_csv = self._extract_csv_content(expected_output)
+
+        # Parse target columns
+        target_columns = self._parse_target_columns(self.target_sub_output_key)
+
+        # Extract column values from both CSVs
+        actual_values = self._extract_single_record_from_csv(actual_csv, target_columns)
+        expected_values = self._extract_single_record_from_csv(
+            expected_csv, target_columns
+        )
+
+        # Compare values
+        match = self._do_values_match(actual_values, expected_values)
+
+        return BooleanEvaluationResult(score=match)
+
+    def _extract_csv_content(self, output: Any) -> str:
+        """Extract CSV content from various output formats.
+
+        Args:
+            output: The output value (can be string, dict with 'content' key, or other)
+
+        Returns:
+            CSV content as string
+
+        Raises:
+            ValueError: If output format is invalid or empty
+        """
+        csv_content = None
+
+        # Handle dict with 'content' property
+        if isinstance(output, dict):
+            if "content" in output:
+                csv_content = output["content"]
+            else:
+                # Try to serialize as JSON
+                csv_content = json.dumps(output)
+        # Handle string
+        elif isinstance(output, str):
+            csv_content = output
+        else:
+            # Try to convert to string
+            csv_content = str(output)
+
+        # Validate content is not empty
+        if not csv_content or not csv_content.strip():
+            raise ValueError("CSV output is null or empty")
+
+        return csv_content
+
+    def _parse_target_columns(self, target_sub_output_key: str) -> list[str]:
+        """Parse comma-separated target columns.
+
+        Args:
+            target_sub_output_key: Comma-separated column names
+
+        Returns:
+            List of column names (trimmed and filtered)
+
+        Raises:
+            ValueError: If no valid columns are found
+        """
+        columns = [
+            col.strip() for col in target_sub_output_key.split(",") if col.strip()
+        ]
+
+        if not columns:
+            raise ValueError("At least one target column must be specified")
+
+        return columns
+
+    def _extract_single_record_from_csv(
+        self, csv_content: str, target_columns: list[str]
+    ) -> dict[str, str]:
+        """Extract values for target columns from the first data row of CSV.
+
+        Args:
+            csv_content: The CSV content as string
+            target_columns: List of column names to extract
+
+        Returns:
+            Dictionary mapping column names to values
+
+        Raises:
+            ValueError: If CSV format is invalid, headers missing, or columns not found
+        """
+        try:
+            # Create CSV reader
+            reader = csv.DictReader(io.StringIO(csv_content))
+
+            # Get headers (field names)
+            if reader.fieldnames is None:
+                raise ValueError("CSV must contain headers")
+
+            headers = reader.fieldnames
+
+            # Create case-insensitive column mapping
+            column_map = {h.lower(): h for h in headers}
+
+            # Validate target columns exist (case-insensitive)
+            missing_columns = []
+            for col in target_columns:
+                if col.lower() not in column_map:
+                    missing_columns.append(col)
+
+            if missing_columns:
+                raise ValueError(f"Missing columns: {', '.join(missing_columns)}")
+
+            # Read first data row
+            try:
+                row = next(reader)
+            except StopIteration as e:
+                raise ValueError("CSV must contain one data row") from e
+
+            # Extract target column values
+            result = {}
+            for col in target_columns:
+                actual_col_name = column_map[col.lower()]
+                value = row.get(actual_col_name, "")
+                # Trim whitespace from values
+                result[col] = value.strip() if value else ""
+
+            return result
+
+        except csv.Error as e:
+            raise ValueError(f"Invalid CSV format: {e}") from e
+
+    def _do_values_match(
+        self, actual_values: dict[str, str], expected_values: dict[str, str]
+    ) -> bool:
+        """Compare actual and expected values.
+
+        Args:
+            actual_values: Dictionary of actual column values
+            expected_values: Dictionary of expected column values
+
+        Returns:
+            True if all values match exactly, False otherwise
+        """
+        for column, expected_value in expected_values.items():
+            actual_value = actual_values.get(column)
+            # Use exact string comparison (case-sensitive for values)
+            if actual_value != expected_value:
+                return False
+        return True
+
+    async def _evaluate_line_by_line(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Override line-by-line evaluation to handle CSV structure properly.
+
+        For CSV files, we need to preserve headers when splitting into lines.
+        This method:
+        1. Extracts the CSV content (handles job attachments via _get_actual_output)
+        2. Splits into header + data lines
+        3. For each data line, creates a mini-CSV with header + that line
+        4. Evaluates each mini-CSV
+        5. Aggregates results
+
+        Args:
+            agent_execution: The execution details
+            evaluation_criteria: The evaluation criteria
+
+        Returns:
+            NumericEvaluationResult with line-by-line details
+        """
+        # Import here to get NumericEvaluationResult
+        from ..models.models import NumericEvaluationResult
+        from .output_evaluator import (
+            AggregationMethod,
+            LineByLineEvaluationDetails,
+            LineByLineEvaluationResult,
+            LineEvaluationDetail,
+        )
+
+        # Get actual output (this handles job attachments automatically)
+        actual_output = self._get_actual_output(agent_execution)
+
+        # Get expected output from criteria
+        expected_output = evaluation_criteria.expected_output
+
+        # Extract based on target_output_key if not wildcard
+        if self.target_output_key and self.target_output_key != "*":
+            if (
+                isinstance(expected_output, dict)
+                and self.target_output_key in expected_output
+            ):
+                expected_output = expected_output[self.target_output_key]
+
+        # Extract CSV content
+        actual_csv = self._extract_csv_content(actual_output)
+        expected_csv = self._extract_csv_content(expected_output)
+
+        # Split into lines
+        actual_lines = actual_csv.split(self.line_delimiter)
+        expected_lines = expected_csv.split(self.line_delimiter)
+
+        # Filter out empty lines
+        actual_lines = [line for line in actual_lines if line.strip()]
+        expected_lines = [line for line in expected_lines if line.strip()]
+
+        # Validate we have at least headers
+        if not actual_lines or not expected_lines:
+            raise ValueError("CSV must contain at least a header row")
+
+        # Extract headers (first line)
+        actual_header = actual_lines[0]
+        expected_header = expected_lines[0]
+
+        # Get data rows (everything after first line)
+        actual_data_rows = actual_lines[1:]
+        expected_data_rows = expected_lines[1:]
+
+        # Evaluate each line
+        line_details = []
+        line_results: list[tuple[int, Any]] = []
+        max_lines = max(len(actual_data_rows), len(expected_data_rows))
+
+        for i in range(max_lines):
+            actual_line = actual_data_rows[i] if i < len(actual_data_rows) else ""
+            expected_line = expected_data_rows[i] if i < len(expected_data_rows) else ""
+
+            # Create mini-CSVs with header + data line
+            if actual_line:
+                actual_mini_csv = f"{actual_header}{self.line_delimiter}{actual_line}"
+            else:
+                actual_mini_csv = actual_header  # Just header, will fail validation
+
+            if expected_line:
+                expected_mini_csv = (
+                    f"{expected_header}{self.line_delimiter}{expected_line}"
+                )
+            else:
+                expected_mini_csv = expected_header  # Just header, will fail validation
+
+            # Create a modified agent execution for this line
+            line_agent_execution = AgentExecution(
+                agent_input=agent_execution.agent_input,
+                agent_output=wrap_line_in_structure(
+                    actual_mini_csv, self.target_output_key
+                ),
+                agent_trace=agent_execution.agent_trace,
+                expected_agent_behavior=getattr(
+                    agent_execution, "expected_agent_behavior", None
+                ),
+                simulation_instructions=getattr(
+                    agent_execution, "simulation_instructions", ""
+                ),
+            )
+
+            # Create criteria for this line
+            line_criteria = LegacyEvaluationCriteria(
+                expected_output=wrap_line_in_structure(
+                    expected_mini_csv, self.target_output_key
+                ),
+                expected_agent_behavior=evaluation_criteria.expected_agent_behavior,
+            )
+
+            # Evaluate this line
+            try:
+                line_result = await self.evaluate(line_agent_execution, line_criteria)
+                score_value = (
+                    line_result.score if hasattr(line_result, "score") else 0.0
+                )
+            except Exception:
+                # If evaluation fails (e.g., missing data), score as 0
+                line_result = BooleanEvaluationResult(score=False)
+                score_value = 0.0
+
+            # Store line evaluation detail
+            line_details.append(
+                LineEvaluationDetail(
+                    line_number=i + 1,
+                    actual=actual_line,
+                    expected=expected_line,
+                    score=score_value,
+                    details=line_result.details
+                    if hasattr(line_result, "details")
+                    else None,
+                )
+            )
+
+            # Store for runtime extraction
+            line_results.append((i + 1, line_result))
+
+        # Calculate aggregate score
+        scores = []
+        for _line_num, result in line_results:
+            if hasattr(result, "score"):
+                score = result.score
+                # Convert boolean to float
+                if isinstance(score, bool):
+                    scores.append(1.0 if score else 0.0)
+                else:
+                    scores.append(float(score))
+
+        aggregated_score = sum(scores) / len(scores) if scores else 0.0
+
+        # Create aggregated details
+        details = LineByLineEvaluationDetails(
+            line_by_line_results=line_details,
+            total_lines_actual=len(actual_data_rows),
+            total_lines_expected=len(expected_data_rows),
+            aggregation_method=AggregationMethod.AVERAGE,
+        )
+
+        # Create the aggregated result
+        aggregated_result = NumericEvaluationResult(
+            score=aggregated_score,
+            details=details,
+        )
+
+        # Attach line results container for runtime to extract
+        setattr(  # noqa: B010
+            aggregated_result,
+            "_line_by_line_results",
+            LineByLineEvaluationResult(
+                line_results=line_results, aggregation_method=AggregationMethod.AVERAGE
+            ),
+        )
+
+        return aggregated_result
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_deterministic_evaluator_base.py b/packages/uipath/src/uipath/eval/evaluators/legacy_deterministic_evaluator_base.py
new file mode 100644
index 000000000..faa5cac17
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_deterministic_evaluator_base.py
@@ -0,0 +1,53 @@
+"""Base class for deterministic evaluators that provide consistent outputs."""
+
+import json
+from abc import ABC
+from typing import Any, Generic, TypeVar
+
+from .base_legacy_evaluator import BaseLegacyEvaluator, LegacyEvaluatorConfig
+
+T = TypeVar("T", bound=LegacyEvaluatorConfig)
+
+
+class BaseLegacyDeterministicEvaluator(BaseLegacyEvaluator[T], Generic[T], ABC):
+    """Base class for evaluators that produce deterministic, reproducible results.
+
+    This class provides utility methods for canonical JSON comparison and number normalization
+    to ensure consistent evaluation results across runs.
+    """
+
+    def _canonical_json(self, obj: Any) -> str:
+        """Convert an object to canonical JSON string for consistent comparison.
+
+        Args:
+            obj: The object to convert to canonical JSON
+
+        Returns:
+            str: Canonical JSON string with normalized numbers and sorted keys
+        """
+        return json.dumps(
+            self._normalize_numbers(obj),
+            sort_keys=True,
+            separators=(",", ":"),
+            ensure_ascii=False,
+        )
+
+    def _normalize_numbers(self, obj: Any) -> Any:
+        """Recursively normalize numbers in nested data structures.
+
+        Converts all numeric values (int, float) to float for consistent comparison,
+        while preserving booleans and other data types.
+
+        Args:
+            obj: The object to normalize
+
+        Returns:
+            Any: Object with normalized numbers
+        """
+        if isinstance(obj, dict):
+            return {k: self._normalize_numbers(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [self._normalize_numbers(v) for v in obj]
+        if isinstance(obj, (int, float)) and not isinstance(obj, bool):
+            return float(obj)
+        return obj
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_evaluator_utils.py b/packages/uipath/src/uipath/eval/evaluators/legacy_evaluator_utils.py
new file mode 100644
index 000000000..b8c20f372
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_evaluator_utils.py
@@ -0,0 +1,75 @@
+"""Utility functions for legacy evaluators."""
+
+import json
+from typing import Any, Optional
+
+from ..._utils.constants import COMMUNITY_agents_SUFFIX
+
+
+def clean_model_name(model: str) -> str:
+    """Remove community-agents suffix from model name.
+
+    Args:
+        model: Model name that may have the community suffix
+
+    Returns:
+        Model name without the community suffix
+    """
+    if model.endswith(COMMUNITY_agents_SUFFIX):
+        return model.replace(COMMUNITY_agents_SUFFIX, "")
+    return model
+
+
+def serialize_object(
+    content: Any,
+    sort_keys: bool = False,
+) -> str:
+    """Serialize content to string format.
+
+    Args:
+        content: Content to serialize (str, dict, list, etc.)
+        sort_keys: Whether to sort dict keys (default: False)
+
+    Returns:
+        Serialized string representation
+    """
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, dict):
+        if sort_keys:
+            content = dict(sorted(content.items()))
+        return json.dumps(content, default=str, separators=(",", ":"))
+    else:
+        return json.dumps(content, default=str, separators=(",", ":"))
+
+
+def safe_get_span_attributes(span: Any) -> Optional[dict[str, Any]]:
+    """Safely extract attributes from a span.
+
+    Args:
+        span: The span object
+
+    Returns:
+        Span attributes dict, or None if not available
+    """
+    if not hasattr(span, "attributes") or span.attributes is None:
+        return None
+    return span.attributes
+
+
+def parse_json_value(value: str) -> Any:
+    """Safely parse a JSON string value.
+
+    Args:
+        value: JSON string to parse
+
+    Returns:
+        Parsed JSON object
+
+    Raises:
+        ValueError: If string cannot be parsed as JSON
+    """
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Cannot parse JSON value: {value}") from e
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_exact_match_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_exact_match_evaluator.py
new file mode 100644
index 000000000..42ffae047
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_exact_match_evaluator.py
@@ -0,0 +1,72 @@
+"""Exact match evaluator for binary pass/fail evaluation of agent outputs."""
+
+from uipath.eval.models import BooleanEvaluationResult, EvaluationResult
+
+from .._helpers.output_path import resolve_output_path
+from ..models.models import AgentExecution
+from .base_legacy_evaluator import LegacyEvaluationCriteria, LegacyEvaluatorConfig
+from .legacy_deterministic_evaluator_base import BaseLegacyDeterministicEvaluator
+
+
+class LegacyExactMatchEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy exact-match evaluators."""
+
+    name: str = "LegacyExactMatchEvaluator"
+
+
+class LegacyExactMatchEvaluator(
+    BaseLegacyDeterministicEvaluator[LegacyExactMatchEvaluatorConfig]
+):
+    """Evaluator that performs exact structural matching between expected and actual outputs.
+
+    This evaluator returns True if the actual output exactly matches the expected output
+    after canonical JSON normalization, and False otherwise. Numbers are normalized
+    to floats for consistent comparison.
+    """
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate whether actual output exactly matches expected output.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Boolean result indicating exact match (True/False)
+        """
+        actual_output = agent_execution.agent_output
+        expected_output = evaluation_criteria.expected_output
+
+        if self.target_output_key and self.target_output_key != "*":
+            if isinstance(actual_output, dict) and isinstance(expected_output, dict):
+                actual_resolved = True
+                expected_resolved = True
+
+                try:
+                    actual_output = resolve_output_path(
+                        actual_output, self.target_output_key
+                    )
+                except (KeyError, IndexError, TypeError):
+                    actual_resolved = False
+
+                try:
+                    expected_output = resolve_output_path(
+                        expected_output, self.target_output_key
+                    )
+                except (KeyError, IndexError, TypeError):
+                    expected_resolved = False
+
+                if not actual_resolved or not expected_resolved:
+                    actual_output = expected_output = {}
+
+        return BooleanEvaluationResult(
+            score=self._canonical_json(actual_output)
+            == self._canonical_json(expected_output)
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_faithfulness_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_faithfulness_evaluator.py
new file mode 100644
index 000000000..c4eba1fcf
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_faithfulness_evaluator.py
@@ -0,0 +1,553 @@
+"""Legacy Faithfulness evaluator for assessing whether agent output claims are grounded in context."""
+
+import json
+from typing import Any, Optional
+
+from pydantic import Field
+
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+
+from .._execution_context import eval_set_run_id_context
+from ..models import NumericEvaluationResult
+from ..models.models import AgentExecution, EvaluationResult
+from .base_legacy_evaluator import (
+    BaseLegacyEvaluator,
+    LegacyEvaluationCriteria,
+    LegacyEvaluatorConfig,
+    track_evaluation_metrics,
+)
+from .legacy_evaluator_utils import (
+    clean_model_name,
+    serialize_object,
+)
+
+
+class LegacyFaithfulnessEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy faithfulness evaluators."""
+
+    name: str = "LegacyFaithfulnessEvaluator"
+    model: str = ""
+
+
+class LegacyFaithfulnessEvaluator(
+    BaseLegacyEvaluator[LegacyFaithfulnessEvaluatorConfig]
+):
+    """Legacy evaluator that assesses faithfulness using an LLM.
+
+    This evaluator extracts claims from agent output using a 3-stage pipeline
+    (selection, disambiguation, decomposition) and evaluates whether each claim
+    is grounded in the available context sources extracted from agent traces.
+    The final score is the percentage of claims that are grounded.
+    """
+
+    model: str = Field(default="same-as-agent")
+    llm: Optional[UiPathLlmChatService] = None
+
+    def model_post_init(self, __context: Any):
+        """Initialize the evaluator after model creation."""
+        super().model_post_init(__context)
+
+    def _initialize_llm(self):
+        """Initialize the LLM used for evaluation."""
+        uipath = UiPath()
+        self.llm = UiPathLlmChatService(
+            uipath._config,
+            uipath._execution_context,
+            requesting_product="agentsplayground",
+            requesting_feature="agents-evaluations",
+            agenthub_config="agentsevals",
+            action_id=eval_set_run_id_context.get(),
+        )
+
+    @track_evaluation_metrics
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate faithfulness of agent output against available context.
+
+        Args:
+            agent_execution: The execution details containing agent_trace with spans
+            evaluation_criteria: Legacy evaluation criteria containing expected_output
+
+        Returns:
+            NumericEvaluationResult with normalized score (0-100) and detailed justification
+        """
+        # Lazily initialize the LLM on first evaluation call
+        if self.llm is None:
+            self._initialize_llm()
+
+        # Extract agent output
+        agent_output = str(evaluation_criteria.expected_output or "")
+        if not agent_output or not agent_output.strip():
+            return NumericEvaluationResult(
+                score=0.0,
+                details="No agent output provided for faithfulness evaluation.",
+            )
+
+        # Extract context sources from traces
+        context_sources = self._extract_context_sources(agent_execution.agent_trace)
+
+        if not context_sources:
+            return NumericEvaluationResult(
+                score=0.0,
+                details="No context sources found in the agent execution trace.",
+            )
+
+        # Stage 1: Extract verifiable claims from agent output
+        claims = await self._extract_claims(agent_output)
+
+        if not claims:
+            return NumericEvaluationResult(
+                score=100.0,
+                details="No verifiable claims found in agent output.",
+            )
+
+        # Stage 2: Evaluate each claim against context sources
+        claim_evaluations = await self._evaluate_claims_against_context(
+            claims, context_sources
+        )
+
+        # Calculate score
+        grounded_claims = [c for c in claim_evaluations if c["is_grounded"]]
+        score = (
+            (len(grounded_claims) / len(claim_evaluations)) * 100
+            if claim_evaluations
+            else 0.0
+        )
+        score = max(0, min(100, score))
+
+        # Build justification
+        justification = self._format_justification(score, claim_evaluations)
+
+        return NumericEvaluationResult(
+            score=score,
+            details=justification,
+        )
+
+    def _extract_context_sources(self, agent_trace: list[Any]) -> list[dict[str, str]]:
+        """Extract context sources from agent execution trace.
+
+        Looks for tool call outputs and context grounding spans that provide context.
+
+        Returns:
+            List of context source dicts with 'content' and 'source' keys
+        """
+        context_sources = []
+
+        for span in agent_trace:
+            if not hasattr(span, "attributes") or span.attributes is None:
+                continue
+
+            attrs = span.attributes
+
+            tool_name = attrs.get("openinference.span.kind")
+            if not tool_name or tool_name == "UNKNOWN":
+                continue
+
+            output_value = attrs.get("output.value")
+            if not output_value:
+                continue
+
+            try:
+                output_data = (
+                    json.loads(output_value)
+                    if isinstance(output_value, str)
+                    else output_value
+                )
+
+                # For RETRIEVER spans, extract individual documents
+                if tool_name == "RETRIEVER":
+                    documents = output_data.get("documents", [])
+                    if documents:
+                        for doc in documents:
+                            content = self._serialize_content(doc)
+                            context_sources.append(
+                                {"content": content, "source": "Context Grounding"}
+                            )
+                else:
+                    # For other tool calls, extract the full output
+                    content = self._serialize_content(output_data)
+                    context_sources.append({"content": content, "source": tool_name})
+            except (ValueError, TypeError):
+                continue
+
+        return context_sources
+
+    def _serialize_content(self, content: Any) -> str:
+        """Serialize content to string format."""
+        return serialize_object(content, sort_keys=False)
+
+    async def _extract_claims(self, agent_output: str) -> list[dict[str, str]]:
+        """Extract verifiable claims from agent output using 3-stage pipeline.
+
+        Stages:
+        1. Selection: Filter to verifiable sentences
+        2. Disambiguation: Resolve internal ambiguities
+        3. Decomposition: Extract standalone claims
+
+        Returns:
+            List of claim dicts with 'text' and 'original_sentence' keys
+        """
+        # Stage 1: Selection
+        verifiable_sentences = await self._select_verifiable_sentences(agent_output)
+        if not verifiable_sentences:
+            return []
+
+        # Stage 2: Disambiguation
+        disambiguated_sentences = await self._disambiguate_sentences(
+            verifiable_sentences, agent_output
+        )
+        if not disambiguated_sentences:
+            return []
+
+        # Stage 3: Decomposition
+        claims = await self._decompose_to_claims(disambiguated_sentences, agent_output)
+        return claims
+
+    async def _select_verifiable_sentences(self, agent_output: str) -> list[str]:
+        """Stage 1: Filter agent output to verifiable sentences."""
+        prompt = f"""You are an expert evaluator identifying verifiable claims.
+
+TASK: Identify sentences in the agent output that contain verifiable, factual claims.
+Filter out subjective opinions, instructions, questions, and meta-commentary.
+
+OUTPUT FORMAT: Return a JSON object with a "sentences" field containing an array of strings.
+Each string should be a complete sentence from the original output.
+
+<agent_output>
+{agent_output}
+</agent_output>
+
+Identify and return only the verifiable sentences."""
+
+        response_obj = await self._get_structured_llm_response(
+            prompt,
+            schema_name="claim_selection",
+            schema={
+                "type": "object",
+                "properties": {
+                    "sentences": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of verifiable sentences from agent output",
+                    }
+                },
+                "required": ["sentences"],
+            },
+        )
+
+        return response_obj.get("sentences", [])
+
+    async def _disambiguate_sentences(
+        self, sentences: list[str], full_output: str
+    ) -> list[dict[str, str]]:
+        """Stage 2: Resolve ambiguities in sentences."""
+        if not sentences:
+            return []
+
+        sentences_text = "\n".join(f"{i + 1}. {s}" for i, s in enumerate(sentences))
+
+        prompt = f"""You are an expert at disambiguating claims.
+
+TASK: For each sentence, resolve any internal ambiguities using the full agent output as context.
+Replace pronouns, references, and implicit information with explicit, standalone versions.
+
+<full_agent_output>
+{full_output}
+</full_agent_output>
+
+<sentences_to_disambiguate>
+{sentences_text}
+</sentences_to_disambiguate>
+
+OUTPUT FORMAT: Return a JSON object with a "disambiguated" field containing an array of objects.
+Each object must have:
+- "original": the original sentence
+- "disambiguated": the disambiguated version"""
+
+        response_obj = await self._get_structured_llm_response(
+            prompt,
+            schema_name="claim_disambiguation",
+            schema={
+                "type": "object",
+                "properties": {
+                    "disambiguated": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "original": {"type": "string"},
+                                "disambiguated": {"type": "string"},
+                            },
+                            "required": ["original", "disambiguated"],
+                        },
+                        "description": "List of disambiguated sentences",
+                    }
+                },
+                "required": ["disambiguated"],
+            },
+        )
+
+        return response_obj.get("disambiguated", [])
+
+    async def _decompose_to_claims(
+        self, disambiguated: list[dict[str, str]], full_output: str
+    ) -> list[dict[str, str]]:
+        """Stage 3: Decompose sentences into standalone verifiable claims."""
+        if not disambiguated:
+            return []
+
+        sentences_text = "\n".join(
+            f"{i + 1}. {item.get('disambiguated', '')}"
+            for i, item in enumerate(disambiguated)
+        )
+
+        prompt = f"""You are an expert at claim decomposition.
+
+TASK: Break down each sentence into standalone, atomic claims that can be independently verified.
+Each claim should be self-contained and not depend on other claims for context.
+
+<sentences>
+{sentences_text}
+</sentences>
+
+<full_context>
+{full_output}
+</full_context>
+
+OUTPUT FORMAT: Return a JSON object with a "claims" field containing an array of objects.
+Each object must have:
+- "claim": the standalone claim
+- "original_sentence": which sentence it came from (number)"""
+
+        response_obj = await self._get_structured_llm_response(
+            prompt,
+            schema_name="claim_decomposition",
+            schema={
+                "type": "object",
+                "properties": {
+                    "claims": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "claim": {"type": "string"},
+                                "original_sentence": {"type": "string"},
+                            },
+                            "required": ["claim", "original_sentence"],
+                        },
+                        "description": "List of decomposed claims",
+                    }
+                },
+                "required": ["claims"],
+            },
+        )
+
+        claims_data = response_obj.get("claims", [])
+        return [
+            {
+                "text": c.get("claim", ""),
+                "original_sentence": c.get("original_sentence", ""),
+            }
+            for c in claims_data
+            if c.get("claim", "").strip()
+        ]
+
+    async def _evaluate_claims_against_context(
+        self,
+        claims: list[dict[str, str]],
+        context_sources: list[dict[str, str]],
+    ) -> list[dict[str, Any]]:
+        """Evaluate each claim against context sources.
+
+        Returns:
+            List of claim evaluations with grounding status and source attribution
+        """
+        claim_evaluations = []
+
+        for claim in claims:
+            claim_text = claim.get("text", "")
+            if not claim_text.strip():
+                continue
+
+            supporting_sources = []
+            contradicting_sources = []
+
+            # Evaluate claim against each context source
+            for source in context_sources:
+                source_content = source.get("content", "")
+                source_name = source.get("source", "Unknown")
+
+                stance = await self._evaluate_claim_stance(claim_text, source_content)
+
+                if stance == "SUPPORTS":
+                    supporting_sources.append(source_name)
+                elif stance == "CONTRADICTS":
+                    contradicting_sources.append(source_name)
+
+            # A claim is grounded if it has supporting sources and no contradicting ones
+            is_grounded = (
+                len(supporting_sources) > 0 and len(contradicting_sources) == 0
+            )
+
+            claim_evaluations.append(
+                {
+                    "claim": claim_text,
+                    "original_sentence": claim.get("original_sentence", ""),
+                    "is_grounded": is_grounded,
+                    "supporting_sources": supporting_sources,
+                    "contradicting_sources": contradicting_sources,
+                }
+            )
+
+        return claim_evaluations
+
+    async def _evaluate_claim_stance(self, claim: str, context: str) -> str:
+        """Evaluate whether a context source supports, contradicts, or is irrelevant to a claim.
+
+        Returns:
+            One of: "SUPPORTS", "CONTRADICTS", "IRRELEVANT"
+        """
+        prompt = f"""You are an expert evaluator assessing the relationship between claims and sources.
+
+TASK: Determine if the source supports, contradicts, or is irrelevant to the claim.
+
+DEFINITION:
+- SUPPORTS: The source provides evidence that makes the claim more likely to be true
+- CONTRADICTS: The source provides evidence that makes the claim false or less likely
+- IRRELEVANT: The source does not address the claim at all
+
+<claim>
+{claim}
+</claim>
+
+<source>
+{context}
+</source>
+
+OUTPUT FORMAT: Return a JSON object with a "stance" field.
+The stance must be exactly one of: "SUPPORTS", "CONTRADICTS", or "IRRELEVANT"."""
+
+        response_obj = await self._get_structured_llm_response(
+            prompt,
+            schema_name="claim_stance_evaluation",
+            schema={
+                "type": "object",
+                "properties": {
+                    "stance": {
+                        "type": "string",
+                        "enum": ["SUPPORTS", "CONTRADICTS", "IRRELEVANT"],
+                        "description": "Stance of the source relative to the claim",
+                    }
+                },
+                "required": ["stance"],
+            },
+        )
+
+        stance = response_obj.get("stance", "IRRELEVANT").upper()
+        if stance not in ["SUPPORTS", "CONTRADICTS", "IRRELEVANT"]:
+            stance = "IRRELEVANT"
+
+        return stance
+
+    def _format_justification(
+        self, score: float, claim_evaluations: list[dict[str, Any]]
+    ) -> str:
+        """Format detailed justification with claim breakdown."""
+        grounded_claims = [c for c in claim_evaluations if c["is_grounded"]]
+        ungrounded_claims = [c for c in claim_evaluations if not c["is_grounded"]]
+
+        justification = (
+            f"Overall Faithfulness: {score:.1f}/100 "
+            f"({len(grounded_claims)}/{len(claim_evaluations)} claims grounded).\n"
+        )
+
+        if claim_evaluations:
+            justification += "---\n"
+
+            if grounded_claims:
+                justification += "\n✓ GROUNDED CLAIMS:\n\n"
+                for i, eval_item in enumerate(grounded_claims, 1):
+                    justification += f'{i}. "{eval_item["claim"]}"\n'
+                    if eval_item["supporting_sources"]:
+                        sources_str = ", ".join(eval_item["supporting_sources"])
+                        justification += f"   Supporting Sources: {sources_str}\n"
+                    justification += "\n"
+
+            if ungrounded_claims:
+                justification += "\n✗ UNGROUNDED CLAIMS:\n\n"
+                for i, eval_item in enumerate(ungrounded_claims, 1):
+                    justification += f'{i}. "{eval_item["claim"]}"\n'
+                    if eval_item["contradicting_sources"]:
+                        sources_str = ", ".join(eval_item["contradicting_sources"])
+                        justification += f"   Contradicting Sources: {sources_str}\n"
+                    if (
+                        not eval_item["supporting_sources"]
+                        and not eval_item["contradicting_sources"]
+                    ):
+                        justification += "   No supporting sources found in context.\n"
+                    justification += "\n"
+
+        return justification.rstrip()
+
+    async def _get_structured_llm_response(
+        self,
+        evaluation_prompt: str,
+        schema_name: str,
+        schema: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Get structured LLM response using function calling."""
+        from uipath.platform.chat.llm_gateway import (
+            RequiredToolChoice,
+            ToolDefinition,
+            ToolFunctionDefinition,
+            ToolParametersDefinition,
+        )
+
+        # Remove community-agents suffix from llm model name
+        model = clean_model_name(self.model)
+
+        # Create a dynamic tool definition based on the schema
+        tool = ToolDefinition(
+            type="function",
+            function=ToolFunctionDefinition(
+                name=schema_name,
+                description=f"Submit the structured response for {schema_name}",
+                parameters=ToolParametersDefinition(
+                    type=schema.get("type", "object"),
+                    properties=schema.get("properties", {}),
+                    required=schema.get("required", []),
+                ),
+            ),
+        )
+
+        tool_choice = RequiredToolChoice()
+
+        # Prepare the request with function calling
+        request_data = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": "Faithfulness Evaluation"},
+                {"role": "user", "content": evaluation_prompt},
+            ],
+            "tools": [tool],
+            "tool_choice": tool_choice,
+        }
+
+        assert self.llm, "LLM should be initialized before calling this method."
+        response = await self.llm.chat_completions(**request_data)
+
+        # Extract from tool call
+        if (
+            response.choices
+            and response.choices[0].message.tool_calls
+            and len(response.choices[0].message.tool_calls) > 0
+        ):
+            tool_call = response.choices[0].message.tool_calls[0]
+            return tool_call.arguments
+
+        # Fallback to empty dict if no tool calls
+        return {}
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_json_similarity_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_json_similarity_evaluator.py
new file mode 100644
index 000000000..70fe28b2e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_json_similarity_evaluator.py
@@ -0,0 +1,180 @@
+"""JSON similarity evaluator for flexible structural comparison of outputs."""
+
+import math
+from typing import Any, Tuple, TypeVar
+
+from .._helpers.output_path import resolve_output_path
+from ..models import EvaluationResult, NumericEvaluationResult
+from ..models.models import AgentExecution
+from .base_legacy_evaluator import LegacyEvaluationCriteria, LegacyEvaluatorConfig
+from .legacy_deterministic_evaluator_base import BaseLegacyDeterministicEvaluator
+
+T = TypeVar("T")
+
+
+class LegacyJsonSimilarityEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy json-similarity evaluators."""
+
+    name: str = "LegacyJsonSimilarityEvaluator"
+
+
+class LegacyJsonSimilarityEvaluator(
+    BaseLegacyDeterministicEvaluator[LegacyJsonSimilarityEvaluatorConfig]
+):
+    """Legacy deterministic evaluator that scores structural JSON similarity between expected and actual output.
+
+    Compares expected versus actual JSON-like structures and returns a
+    numerical score in the range [0, 100]. The comparison is token-based
+    and tolerant for numbers and strings (via Levenshtein distance).
+    """
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate similarity between expected and actual JSON outputs.
+
+        Uses token-based comparison with tolerance for numeric differences
+        and Levenshtein distance for string similarity.
+
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Numerical score between 0-100 indicating similarity
+        """
+        actual_output = agent_execution.agent_output
+        expected_output = evaluation_criteria.expected_output
+
+        if self.target_output_key and self.target_output_key != "*":
+            try:
+                actual_output = resolve_output_path(
+                    actual_output, self.target_output_key
+                )
+            except (KeyError, IndexError, TypeError):
+                actual_output = {}
+
+            try:
+                expected_output = resolve_output_path(
+                    expected_output, self.target_output_key
+                )
+            except (KeyError, IndexError, TypeError):
+                expected_output = {}
+
+        return NumericEvaluationResult(
+            score=self._compare_json(expected_output, actual_output)
+        )
+
+    def _compare_json(self, expected: Any, actual: Any) -> float:
+        matched_leaves, total_leaves = self._compare_tokens(expected, actual)
+        if total_leaves == 0:
+            return 100.0
+        sim = (matched_leaves / total_leaves) * 100.0
+        return max(0.0, min(100.0, sim))
+
+    def _compare_tokens(
+        self, expected_token: Any, actual_token: Any
+    ) -> Tuple[float, float]:
+        if self._is_number(expected_token) and self._is_number(actual_token):
+            return self._compare_numbers(float(expected_token), float(actual_token))
+
+        if type(expected_token) is not type(actual_token):
+            return 0.0, self._count_leaves(expected_token)
+
+        if isinstance(expected_token, dict):
+            matched_leaves = total_leaves = 0.0
+            # Only expected keys count
+            for expected_key, expected_value in expected_token.items():
+                if isinstance(actual_token, dict) and expected_key in actual_token:
+                    matched, total = self._compare_tokens(
+                        expected_value, actual_token[expected_key]
+                    )
+                else:
+                    matched, total = (0.0, self._count_leaves(expected_value))
+                matched_leaves += matched
+                total_leaves += total
+            return matched_leaves, total_leaves
+
+        if isinstance(expected_token, list):
+            matched_leaves = total_leaves = 0.0
+            common_length = min(len(expected_token), len(actual_token))
+            for index in range(common_length):
+                matched, total = self._compare_tokens(
+                    expected_token[index], actual_token[index]
+                )
+                matched_leaves += matched
+                total_leaves += total
+            for index in range(common_length, len(expected_token)):
+                total_leaves += self._count_leaves(expected_token[index])
+            return (matched_leaves, total_leaves)
+
+        if isinstance(expected_token, bool):
+            return (1.0, 1.0) if expected_token == actual_token else (0.0, 1.0)
+
+        if isinstance(expected_token, str):
+            return self._compare_strings(expected_token, actual_token)
+
+        return (1.0, 1.0) if str(expected_token) == str(actual_token) else (0.0, 1.0)
+
+    def _compare_numbers(
+        self, expected_number: float, actual_number: float
+    ) -> Tuple[float, float]:
+        total = 1.0
+        if math.isclose(expected_number, 0.0, abs_tol=1e-12):
+            matched = 1.0 if math.isclose(actual_number, 0.0, abs_tol=1e-12) else 0.0
+        else:
+            ratio = abs(expected_number - actual_number) / abs(expected_number)
+            matched = max(0.0, min(1.0, 1.0 - ratio))
+        return matched, total
+
+    def _compare_strings(
+        self, expected_string: str, actual_string: str
+    ) -> Tuple[float, float]:
+        total = 1.0
+        if not expected_string and not actual_string:
+            return 1.0, total
+        distance = self._levenshtein(expected_string, actual_string)
+        max_length = max(len(expected_string), len(actual_string))
+        similarity = 1.0 - (distance / max_length) if max_length else 1.0
+        similarity = max(0.0, min(1.0, similarity))
+        return similarity, total
+
+    def _count_leaves(self, token_node: Any) -> float:
+        if isinstance(token_node, dict):
+            return sum(
+                self._count_leaves(child_value) for child_value in token_node.values()
+            )
+        if isinstance(token_node, list):
+            return sum(self._count_leaves(child_value) for child_value in token_node)
+        return 1.0
+
+    def _levenshtein(self, source_text: str, target_text: str) -> int:
+        if not source_text:
+            return len(target_text)
+        if not target_text:
+            return len(source_text)
+        source_len, target_len = len(source_text), len(target_text)
+        distance_matrix = [[0] * (target_len + 1) for _ in range(source_len + 1)]
+        for row_idx in range(source_len + 1):
+            distance_matrix[row_idx][0] = row_idx
+        for col_idx in range(target_len + 1):
+            distance_matrix[0][col_idx] = col_idx
+        for row_idx in range(1, source_len + 1):
+            for col_idx in range(1, target_len + 1):
+                substitution_cost = (
+                    0 if source_text[row_idx - 1] == target_text[col_idx - 1] else 1
+                )
+                distance_matrix[row_idx][col_idx] = min(
+                    distance_matrix[row_idx - 1][col_idx] + 1,  # deletion
+                    distance_matrix[row_idx][col_idx - 1] + 1,  # insertion
+                    distance_matrix[row_idx - 1][col_idx - 1]
+                    + substitution_cost,  # substitution
+                )
+        return distance_matrix[source_len][target_len]
+
+    def _is_number(self, value: Any) -> bool:
+        return isinstance(value, (int, float)) and not isinstance(value, bool)
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_llm_as_judge_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_llm_as_judge_evaluator.py
new file mode 100644
index 000000000..0c676ac9b
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_llm_as_judge_evaluator.py
@@ -0,0 +1,215 @@
+"""LLM-as-a-judge evaluator for subjective quality assessment of agent outputs."""
+
+import logging
+from typing import Any, Optional
+
+from pydantic import Field, field_validator
+
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+from uipath.platform.chat.llm_gateway import RequiredToolChoice
+
+from ..._utils.constants import COMMUNITY_agents_SUFFIX
+from .._execution_context import eval_set_run_id_context
+from .._helpers.helpers import is_empty_value
+from .._helpers.output_path import resolve_output_path
+from ..models import NumericEvaluationResult
+from ..models.models import (
+    AgentExecution,
+    EvaluationResult,
+    LLMResponse,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+from .base_legacy_evaluator import (
+    BaseLegacyEvaluator,
+    LegacyEvaluationCriteria,
+    LegacyEvaluatorConfig,
+)
+from .legacy_llm_helpers import create_evaluation_tool, extract_tool_call_response
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyLlmAsAJudgeEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy LLM-as-a-judge evaluators."""
+
+    name: str = "LegacyLlmAsAJudgeEvaluator"
+
+
+class LegacyLlmAsAJudgeEvaluator(BaseLegacyEvaluator[LegacyLlmAsAJudgeEvaluatorConfig]):
+    """Legacy evaluator that uses an LLM to judge the quality of agent output."""
+
+    prompt: str
+    model: str = Field(default="same-as-agent")
+    actual_output_placeholder: str = "{{ActualOutput}}"
+    expected_output_placeholder: str = "{{ExpectedOutput}}"
+    llm: Optional[UiPathLlmChatService] = None
+
+    @field_validator("prompt")
+    @classmethod
+    def validate_prompt_placeholders(cls, v: str) -> str:
+        """Auto-add missing placeholders to prompt if not present.
+
+        If both {{ActualOutput}} and {{ExpectedOutput}} are present, returns prompt as-is.
+        If one is missing, appends the missing one at the end in a new section with tags.
+        If both are missing, appends both at the end in separate sections with tags.
+
+        Tags are added to help the LLM distinguish between outputs, especially for large JSONs.
+        """
+        has_actual = "{{ActualOutput}}" in v
+        has_expected = "{{ExpectedOutput}}" in v
+
+        # If both are present, return as-is
+        if has_actual and has_expected:
+            return v
+
+        # Build the sections to add with opening and closing tags
+        sections_to_add = []
+
+        if not has_actual:
+            sections_to_add.append(
+                "\n\n## Actual Output\n"
+                "<ActualOutput>\n"
+                "{{ActualOutput}}\n"
+                "</ActualOutput>"
+            )
+
+        if not has_expected:
+            sections_to_add.append(
+                "\n\n## Expected Output\n"
+                "<ExpectedOutput>\n"
+                "{{ExpectedOutput}}\n"
+                "</ExpectedOutput>"
+            )
+
+        # Add missing sections to the end of the prompt
+        return v + "".join(sections_to_add)
+
+    def model_post_init(self, __context: Any):
+        """Initialize the evaluator after model creation."""
+        super().model_post_init(__context)
+
+    def _initialize_llm(self):
+        """Initialize the LLM used for evaluation."""
+        uipath = UiPath()
+        self.llm = UiPathLlmChatService(
+            uipath._config,
+            uipath._execution_context,
+            requesting_product="agentsplayground",
+            requesting_feature="agents-evaluations",
+            agenthub_config="agentsevals",
+            action_id=eval_set_run_id_context.get(),
+        )
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate using an LLM as a judge.
+
+        Sends the formatted prompt to the configured LLM and expects a JSON response
+        with a numerical score (0-100) and justification.
+
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - spans: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+
+        Returns:
+            EvaluationResult: Numerical score with LLM justification as details
+        """
+        # Lazily initialize the LLM on first evaluation call
+        if self.llm is None:
+            self._initialize_llm()
+
+        actual_output = agent_execution.agent_output
+        expected_output = evaluation_criteria.expected_output
+
+        if self.target_output_key and self.target_output_key != "*":
+            try:
+                actual_output = resolve_output_path(
+                    actual_output, self.target_output_key
+                )
+            except (KeyError, IndexError, TypeError):
+                pass
+
+            try:
+                expected_output = resolve_output_path(
+                    expected_output, self.target_output_key
+                )
+            except (KeyError, IndexError, TypeError):
+                pass
+
+        # Create the evaluation prompt
+        evaluation_prompt = self._create_evaluation_prompt(
+            expected_output=expected_output,
+            actual_output=actual_output,
+        )
+
+        llm_response = await self._get_llm_response(evaluation_prompt)
+
+        return NumericEvaluationResult(
+            score=llm_response.score,
+            details=llm_response.justification,
+        )
+
+    def _create_evaluation_prompt(
+        self, expected_output: Any, actual_output: Any
+    ) -> str:
+        """Create the evaluation prompt for the LLM."""
+        # Validate that expected output is not empty
+        if is_empty_value(expected_output):
+            logger.error(
+                "❌ EMPTY_EXPECTED_OUTPUT: Expected output is empty or contains only empty values. "
+                f"Received: {repr(expected_output)}"
+            )
+            raise UiPathEvaluationError(
+                code="EMPTY_EXPECTED_OUTPUT",
+                title="Expected output cannot be empty",
+                detail="The evaluation criteria must contain a non-empty expected output.",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        formatted_prompt = self.prompt.replace(
+            self.actual_output_placeholder,
+            str(actual_output),
+        )
+        formatted_prompt = formatted_prompt.replace(
+            self.expected_output_placeholder,
+            str(expected_output),
+        )
+
+        return formatted_prompt
+
+    async def _get_llm_response(self, evaluation_prompt: str) -> LLMResponse:
+        """Get response from the LLM using universal function calling.
+
+        Args:
+            evaluation_prompt: The formatted prompt to send to the LLM
+
+        Returns:
+            LLMResponse with score and justification
+        """
+        # remove community-agents suffix from llm model name
+        model = self.model
+        if model.endswith(COMMUNITY_agents_SUFFIX):
+            model = model.replace(COMMUNITY_agents_SUFFIX, "")
+
+        # Create evaluation tool for function calling (works across all models)
+        evaluation_tool = create_evaluation_tool()
+        tool_choice = RequiredToolChoice()
+
+        # Prepare the request with function calling
+        request_data = {
+            "model": model,
+            "messages": [{"role": "user", "content": evaluation_prompt}],
+            "tools": [evaluation_tool],
+            "tool_choice": tool_choice,
+        }
+
+        assert self.llm, "LLM should be initialized before calling this method."
+        response = await self.llm.chat_completions(**request_data)
+        return extract_tool_call_response(response, model)
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_llm_helpers.py b/packages/uipath/src/uipath/eval/evaluators/legacy_llm_helpers.py
new file mode 100644
index 000000000..67aaee0c3
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_llm_helpers.py
@@ -0,0 +1,105 @@
+"""Helper functions for legacy LLM evaluators using function calling."""
+
+import logging
+from typing import Any
+
+from uipath.platform.chat.llm_gateway import (
+    ToolDefinition,
+    ToolFunctionDefinition,
+    ToolParametersDefinition,
+    ToolPropertyDefinition,
+)
+
+from ..models.models import LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+def create_evaluation_tool() -> ToolDefinition:
+    """Create the standard evaluation tool definition for function calling.
+
+    Returns:
+        ToolDefinition with submit_evaluation function for structured output
+    """
+    return ToolDefinition(
+        type="function",
+        function=ToolFunctionDefinition(
+            name="submit_evaluation",
+            description="Submit the evaluation score and justification for the agent output",
+            parameters=ToolParametersDefinition(
+                type="object",
+                properties={
+                    "justification": ToolPropertyDefinition(
+                        type="string",
+                        description="Clear analysis of the evaluation explaining the reasoning behind the score",
+                    ),
+                    "score": ToolPropertyDefinition(
+                        type="number",
+                        description="Numeric score between 0 and 100 representing the evaluation result",
+                    ),
+                },
+                required=["justification", "score"],
+            ),
+        ),
+    )
+
+
+def extract_tool_call_response(response: Any, model: str) -> LLMResponse:
+    """Extract the evaluation response from the tool call.
+
+    Args:
+        response: The response from the LLM chat completions API
+        model: The model name used for the request (for error logging)
+
+    Returns:
+        LLMResponse: Parsed response with score and justification
+
+    Raises:
+        ValueError: If the response format is invalid or missing required fields
+    """
+    try:
+        if not response.choices or len(response.choices) == 0:
+            error_msg = f"No choices in response from model {model}"
+            logger.error(f"❌ {error_msg}")
+            raise ValueError(error_msg)
+
+        choice = response.choices[0]
+        message = choice.message
+
+        if not message.tool_calls or len(message.tool_calls) == 0:
+            error_msg = f"No tool calls in response from model {model}"
+            logger.error(f"❌ {error_msg}")
+            logger.debug(f"Response: {response}")
+            raise ValueError(error_msg)
+
+        tool_call = message.tool_calls[0]
+        arguments = tool_call.arguments
+
+        if "score" not in arguments:
+            error_msg = f"Missing 'score' in tool call arguments from model {model}"
+            logger.error(f"❌ {error_msg}")
+            logger.debug(f"Arguments: {arguments}")
+            raise ValueError(error_msg)
+
+        if "justification" not in arguments:
+            error_msg = (
+                f"Missing 'justification' in tool call arguments from model {model}"
+            )
+            logger.error(f"❌ {error_msg}")
+            logger.debug(f"Arguments: {arguments}")
+            raise ValueError(error_msg)
+
+        score = float(arguments["score"])
+        justification = str(arguments["justification"])
+
+        logger.debug(
+            f"✅ Extracted score: {score}, justification length: {len(justification)} chars"
+        )
+
+        return LLMResponse(score=score, justification=justification)
+
+    except (KeyError, IndexError, AttributeError) as e:
+        error_msg = f"Failed to extract tool call response from model {model}: {str(e)}"
+        logger.error(f"❌ {error_msg}")
+        logger.debug(f"Response: {response}")
+        raise ValueError(error_msg) from e
diff --git a/packages/uipath/src/uipath/eval/evaluators/legacy_trajectory_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/legacy_trajectory_evaluator.py
new file mode 100644
index 000000000..cff0e8788
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/legacy_trajectory_evaluator.py
@@ -0,0 +1,182 @@
+"""Trajectory evaluator for analyzing execution paths and decision sequences."""
+
+import logging
+from typing import Any, Optional
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import Field, field_validator
+
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+from uipath.platform.chat.llm_gateway import RequiredToolChoice
+
+from ..._utils.constants import COMMUNITY_agents_SUFFIX
+from .._execution_context import eval_set_run_id_context
+from .._helpers.evaluators_helpers import trace_to_str
+from .._helpers.helpers import is_empty_value
+from ..models import EvaluationResult
+from ..models.models import (
+    AgentExecution,
+    LLMResponse,
+    NumericEvaluationResult,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+from .base_legacy_evaluator import (
+    BaseLegacyEvaluator,
+    LegacyEvaluationCriteria,
+    LegacyEvaluatorConfig,
+)
+from .legacy_llm_helpers import create_evaluation_tool, extract_tool_call_response
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyTrajectoryEvaluatorConfig(LegacyEvaluatorConfig):
+    """Configuration for legacy trajectory evaluators."""
+
+    name: str = "LegacyTrajectoryEvaluator"
+
+
+class LegacyTrajectoryEvaluator(BaseLegacyEvaluator[LegacyTrajectoryEvaluatorConfig]):
+    """Legacy evaluator that analyzes the trajectory/path taken to reach outputs."""
+
+    prompt: str
+    model: str = Field(default="same-as-agent")
+    expected_agent_behavior_placeholder: str = "{{ExpectedAgentBehavior}}"
+    agent_run_history_placeholder: str = "{{AgentRunHistory}}"
+    llm: Optional[UiPathLlmChatService] = None
+
+    @field_validator("prompt")
+    @classmethod
+    def validate_prompt_placeholder(cls, v: str) -> str:
+        """Validate that prompt contains required placeholders."""
+        if "{{ExpectedAgentBehavior}}" not in v or "{{AgentRunHistory}}" not in v:
+            raise ValueError(
+                "Prompt must contain {ExpectedAgentBehavior} and {{AgentRunHistory}} placeholders"
+            )
+        return v
+
+    def model_post_init(self, __context: Any):
+        """Initialize the evaluator after model creation."""
+        super().model_post_init(__context)
+
+    def _initialize_llm(self):
+        """Initialize the LLM used for evaluation."""
+        uipath = UiPath()
+        self.llm = UiPathLlmChatService(
+            uipath._config,
+            uipath._execution_context,
+            requesting_product="agentsplayground",
+            requesting_feature="agents-evaluations",
+            agenthub_config="agentsevals",
+            action_id=eval_set_run_id_context.get(),
+        )
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: LegacyEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate using trajectory analysis.
+
+        Analyzes the execution path and decision sequence taken by the agent.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - actual_output: The actual output from the agent
+                - agent_trace: The execution spans to use for the evaluation
+                - expected_agent_behavior: The expected agent behavior
+            evaluation_criteria: The criteria to evaluate
+        Returns:
+            EvaluationResult: Score based on trajectory analysis
+
+        Raises:
+            NotImplementedError: This evaluator is not yet implemented
+        """
+        # Lazily initialize the LLM on first evaluation call
+        if self.llm is None:
+            self._initialize_llm()
+
+        evaluation_prompt = self._create_evaluation_prompt(
+            expected_agent_behavior=agent_execution.expected_agent_behavior,
+            agent_run_history=agent_execution.agent_trace,
+        )
+        llm_response = await self._get_llm_response(evaluation_prompt)
+
+        return NumericEvaluationResult(
+            score=llm_response.score,
+            details=llm_response.justification,
+        )
+
+    def _create_evaluation_prompt(
+        self,
+        expected_agent_behavior: Any,
+        agent_run_history: Any,
+    ) -> str:
+        """Create the evaluation prompt for the LLM."""
+        # Validate that expected agent behavior is not empty
+        if is_empty_value(expected_agent_behavior):
+            logger.error(
+                "❌ EMPTY_EXPECTED_AGENT_BEHAVIOR: Expected agent behavior is empty or contains only empty values. "
+                f"Received: {repr(expected_agent_behavior)}"
+            )
+            raise UiPathEvaluationError(
+                code="EMPTY_EXPECTED_AGENT_BEHAVIOR",
+                title="Expected agent behavior cannot be empty",
+                detail="The evaluation criteria must contain a non-empty expected agent behavior.",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        formatted_prompt = self.prompt.replace(
+            self.expected_agent_behavior_placeholder,
+            str(expected_agent_behavior),
+        )
+
+        # Trim extra properties from the spans (such as timestamps which are not relevant to the eval)
+        if (
+            isinstance(agent_run_history, list)
+            and agent_run_history
+            and isinstance(agent_run_history[0], ReadableSpan)
+        ):
+            agent_run_history = trace_to_str(agent_run_history)
+        else:
+            agent_run_history = str(agent_run_history)
+
+        formatted_prompt = formatted_prompt.replace(
+            self.agent_run_history_placeholder,
+            agent_run_history,
+        )
+
+        return formatted_prompt
+
+    async def _get_llm_response(self, evaluation_prompt: str) -> LLMResponse:
+        """Get response from the LLM using universal function calling.
+
+        Args:
+            evaluation_prompt: The formatted prompt to send to the LLM
+
+        Returns:
+            LLMResponse with score and justification
+        """
+        assert self.llm, "LLM should be initialized before calling this method."
+
+        model = self.model
+        if model.endswith(COMMUNITY_agents_SUFFIX):
+            model = model.replace(COMMUNITY_agents_SUFFIX, "")
+
+        # Create evaluation tool for function calling (works across all models)
+        evaluation_tool = create_evaluation_tool()
+        tool_choice = RequiredToolChoice()
+
+        # Prepare the request with function calling
+        request_data = {
+            "model": model,
+            "messages": [{"role": "user", "content": evaluation_prompt}],
+            "tools": [evaluation_tool],
+            "tool_choice": tool_choice,
+        }
+
+        response = await self.llm.chat_completions(**request_data)
+        return extract_tool_call_response(response, model)
diff --git a/packages/uipath/src/uipath/eval/evaluators/line_by_line_utils.py b/packages/uipath/src/uipath/eval/evaluators/line_by_line_utils.py
new file mode 100644
index 000000000..19182622c
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/line_by_line_utils.py
@@ -0,0 +1,204 @@
+"""Utilities for line-by-line evaluation."""
+
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from ..models import AgentExecution, EvaluationResult
+
+
+def split_into_lines(
+    text: Any, delimiter: str, target_output_key: str | None = None
+) -> list[str]:
+    """Split text into lines using the configured delimiter.
+
+    Args:
+        text: The text to split (can be str or dict)
+        delimiter: The delimiter to split on
+        target_output_key: Optional key to extract from dict before splitting
+
+    Returns:
+        List of lines (empty lines filtered out)
+    """
+    # Handle dict case (when target_output_key is provided and != "*")
+    if target_output_key and target_output_key != "*":
+        if isinstance(text, dict) and target_output_key in text:
+            text = text[target_output_key]
+
+    # Convert to string if needed
+    if not isinstance(text, str):
+        text = str(text)
+
+    # Split by delimiter and filter empty lines
+    lines = text.split(delimiter)
+    return [line for line in lines if line.strip()]
+
+
+def wrap_line_in_structure(
+    line: str, target_output_key: str | None = None
+) -> str | dict[str, str]:
+    """Wrap a line in the appropriate structure based on target_output_key.
+
+    Args:
+        line: The line to wrap
+        target_output_key: The target output key (use "*" or None for no wrapping)
+
+    Returns:
+        Either the line directly (if "*") or wrapped in a dict
+    """
+    if not target_output_key or target_output_key == "*":
+        return line
+    return {target_output_key: line}
+
+
+def aggregate_line_scores(line_results: list[tuple[int, Any]]) -> float:
+    """Aggregate scores from line evaluation results.
+
+    Args:
+        line_results: List of (line_number, result) tuples
+
+    Returns:
+        Average score across all lines
+    """
+    if not line_results:
+        return 0.0
+
+    scores = []
+    for _line_num, result in line_results:
+        if hasattr(result, "score"):
+            score = result.score
+            # Convert boolean to float
+            if isinstance(score, bool):
+                scores.append(1.0 if score else 0.0)
+            else:
+                scores.append(float(score))
+
+    return sum(scores) / len(scores) if scores else 0.0
+
+
+async def evaluate_lines(
+    actual_lines: list[str],
+    expected_lines: list[str],
+    target_output_key: str,
+    agent_execution: "AgentExecution",
+    evaluate_fn: Callable[[Any, Any], Any],
+    create_line_criteria_fn: Callable[[str], Any],
+) -> tuple[list[Any], list[tuple[int, "EvaluationResult"]]]:
+    """Evaluate each line and return details and results.
+
+    Args:
+        actual_lines: List of actual output lines
+        expected_lines: List of expected output lines
+        target_output_key: Key for wrapping lines
+        agent_execution: Original agent execution
+        evaluate_fn: Function to evaluate (line_execution, line_criteria) -> result
+        create_line_criteria_fn: Function to create criteria for a line (expected_line) -> criteria
+
+    Returns:
+        Tuple of (line_details, line_results)
+    """
+    # Import here to avoid circular dependency
+    from .output_evaluator import LineEvaluationDetail
+
+    line_details = []
+    line_results: list[tuple[int, Any]] = []
+    max_lines = max(len(actual_lines), len(expected_lines))
+
+    for i in range(max_lines):
+        actual_line = actual_lines[i] if i < len(actual_lines) else ""
+        expected_line = expected_lines[i] if i < len(expected_lines) else ""
+
+        # Wrap lines in the same structure as original output
+        line_agent_output = wrap_line_in_structure(actual_line, target_output_key)
+
+        # Create a modified agent execution for this line
+        from ..models.models import AgentExecution
+
+        line_agent_execution = AgentExecution(
+            agent_input=agent_execution.agent_input,
+            agent_output=line_agent_output,
+            agent_trace=agent_execution.agent_trace,
+            expected_agent_behavior=getattr(
+                agent_execution, "expected_agent_behavior", None
+            ),
+            simulation_instructions=getattr(
+                agent_execution, "simulation_instructions", ""
+            ),
+        )
+
+        # Create criteria for this line using the provided function
+        line_criteria = create_line_criteria_fn(expected_line)
+
+        # Evaluate this line
+        line_result = await evaluate_fn(line_agent_execution, line_criteria)
+
+        # Store line evaluation detail
+        score_value = line_result.score if hasattr(line_result, "score") else 0.0
+        line_details.append(
+            LineEvaluationDetail(
+                line_number=i + 1,
+                actual=actual_line,
+                expected=expected_line,
+                score=score_value,
+                details=line_result.details
+                if hasattr(line_result, "details")
+                else None,
+            )
+        )
+
+        # Store for runtime extraction
+        line_results.append((i + 1, line_result))
+
+    return line_details, line_results
+
+
+def build_line_by_line_result(
+    line_details: list[Any],
+    line_results: list[tuple[int, Any]],
+    actual_lines: list[str],
+    expected_lines: list[str],
+) -> Any:
+    """Build the final aggregated result with line-by-line details.
+
+    Args:
+        line_details: List of LineEvaluationDetail objects
+        line_results: List of (line_number, result) tuples
+        actual_lines: Original actual lines
+        expected_lines: Original expected lines
+
+    Returns:
+        NumericEvaluationResult with line-by-line details attached
+    """
+    from ..models.models import NumericEvaluationResult
+    from .output_evaluator import (
+        AggregationMethod,
+        LineByLineEvaluationDetails,
+        LineByLineEvaluationResult,
+    )
+
+    # Calculate aggregate score
+    aggregated_score = aggregate_line_scores(line_results)
+
+    # Create aggregated details
+    details = LineByLineEvaluationDetails(
+        line_by_line_results=line_details,
+        total_lines_actual=len(actual_lines),
+        total_lines_expected=len(expected_lines),
+        aggregation_method=AggregationMethod.AVERAGE,
+    )
+
+    # Create the aggregated result
+    aggregated_result = NumericEvaluationResult(
+        score=aggregated_score,
+        details=details,
+    )
+
+    # Attach line results container for runtime to extract
+    setattr(  # noqa: B010
+        aggregated_result,
+        "_line_by_line_results",
+        LineByLineEvaluationResult(
+            line_results=line_results, aggregation_method=AggregationMethod.AVERAGE
+        ),
+    )
+
+    return aggregated_result
diff --git a/packages/uipath/src/uipath/eval/evaluators/llm_as_judge_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/llm_as_judge_evaluator.py
new file mode 100644
index 000000000..c67212548
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/llm_as_judge_evaluator.py
@@ -0,0 +1,462 @@
+"""LLM-as-a-judge evaluator for subjective quality assessment of agent outputs."""
+
+import copy
+import json
+import logging
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
+
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+
+from .._execution_context import eval_set_run_id_context
+from .._helpers.evaluators_helpers import COMMUNITY_agents_SUFFIX
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    LLMResponse,
+    NumericEvaluationResult,
+)
+from ..models.llm_judge_types import (
+    LLMJudgeOutputSchema,
+    LLMJudgePromptTemplates,
+)
+from ..models.models import UiPathEvaluationError, UiPathEvaluationErrorCategory
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+
+T = TypeVar("T", bound=BaseEvaluationCriteria)
+
+logger = logging.getLogger(__name__)
+
+
+class LLMJudgeJustification(BaseEvaluatorJustification):
+    """Justification for LLM judge evaluators."""
+
+    justification: str
+
+
+class BaseLLMJudgeEvaluatorConfig(BaseEvaluatorConfig[T]):
+    """Base config for all LLM evaluators.
+
+    Generic over T (evaluation criteria type) to ensure type safety between
+    the config's default_evaluation_criteria and the evaluator's expected criteria type.
+    """
+
+    prompt: str
+    model: str = ""
+    temperature: float = 0.0
+    max_tokens: int | None = None
+
+
+C = TypeVar("C", bound=BaseLLMJudgeEvaluatorConfig[Any])
+
+
+class LLMJudgeMixin(BaseEvaluator[T, C, LLMJudgeJustification]):
+    """Mixin that provides common LLM judge functionality."""
+
+    system_prompt: str = LLMJudgePromptTemplates.LLM_JUDGE_SYSTEM_PROMPT
+    output_schema: type[BaseModel] = Field(default=LLMJudgeOutputSchema, exclude=True)
+    actual_output_placeholder: str = "{{ActualOutput}}"
+    expected_output_placeholder: str = "{{ExpectedOutput}}"
+    llm_service: Callable[..., Any] | None = Field(
+        default=None, exclude=True, description="The LLM service for evaluation"
+    )
+
+    @model_validator(mode="after")
+    def validate_prompt_placeholders(self) -> "LLMJudgeMixin[T, C]":
+        """Auto-add missing placeholders to prompt if not present.
+
+        If both {{ActualOutput}} and {{ExpectedOutput}} are present, returns prompt as-is.
+        If one is missing, appends the missing one at the end in a new section with tags.
+        If both are missing, appends both at the end in separate sections with tags.
+
+        Tags are added to help the LLM distinguish between outputs, especially for large JSONs.
+        """
+        has_actual = self.actual_output_placeholder in self.evaluator_config.prompt
+        has_expected = self.expected_output_placeholder in self.evaluator_config.prompt
+
+        # If both are present, return as-is
+        if has_actual and has_expected:
+            return self
+
+        # Build the sections to add with opening and closing tags
+        sections_to_add = []
+
+        if not has_actual:
+            sections_to_add.append(
+                f"\n\n## Actual Output\n"
+                f"<ActualOutput>\n"
+                f"{self.actual_output_placeholder}\n"
+                f"</ActualOutput>"
+            )
+
+        if not has_expected:
+            sections_to_add.append(
+                f"\n\n## Expected Output\n"
+                f"<ExpectedOutput>\n"
+                f"{self.expected_output_placeholder}\n"
+                f"</ExpectedOutput>"
+            )
+
+        # Add missing sections to the end of the prompt
+        self.evaluator_config.prompt += "".join(sections_to_add)
+
+        return self
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the evaluator after model creation."""
+        super().model_post_init(__context)
+
+    def _get_llm_service(self):
+        """Get the LLM service from the UiPath instance.
+
+        Uses the normalized API which supports multiple model providers (OpenAI, Anthropic, Gemini, etc.).
+        The normalized API endpoint checks against AllowedNormalizedModels configuration,
+        which includes multi-vendor models that agents use.
+        """
+        try:
+            uipath = UiPath()
+            llm = UiPathLlmChatService(
+                uipath._config,
+                uipath._execution_context,
+                requesting_product="agentsplayground",
+                requesting_feature="agents-evaluations",
+                agenthub_config="agentsevals",
+                action_id=eval_set_run_id_context.get(),
+            )
+            return llm.chat_completions
+        except Exception as e:
+            raise UiPathEvaluationError(
+                code="FAILED_TO_GET_LLM_SERVICE",
+                title="Failed to get LLM service from the SDK and no otherLLM service provided",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
+
+    @abstractmethod
+    def _get_actual_output(self, agent_execution: AgentExecution) -> Any:
+        """Get the actual output from the agent execution. Must be implemented by concrete evaluator classes."""
+        pass
+
+    @abstractmethod
+    def _get_expected_output(self, evaluation_criteria: T) -> Any:
+        """Get the expected output from the evaluation criteria. Must be implemented by concrete evaluator classes."""
+        pass
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: T,
+    ) -> EvaluationResult:
+        """Evaluate using an LLM as a judge."""
+        evaluation_prompt = self._create_evaluation_prompt(
+            agent_execution=agent_execution,
+            evaluation_criteria=evaluation_criteria,
+        )
+
+        llm_response = await self._get_llm_response(evaluation_prompt)
+        validated_justification = self.validate_justification(
+            {
+                "expected": str(self._get_expected_output(evaluation_criteria)),
+                "actual": str(self._get_actual_output(agent_execution)),
+                "justification": llm_response.justification,
+            }
+        )
+
+        return NumericEvaluationResult(
+            score=max(0.0, min(1.0, round(llm_response.score / 100.0, 2))),
+            details=validated_justification,
+        )
+
+    def _create_evaluation_prompt(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: T,
+    ) -> str:
+        """Create the evaluation prompt for the LLM."""
+        expected_output = self._get_expected_output(evaluation_criteria)
+
+        formatted_prompt = self.evaluator_config.prompt.replace(
+            self.actual_output_placeholder,
+            str(self._get_actual_output(agent_execution)),
+        )
+        formatted_prompt = formatted_prompt.replace(
+            self.expected_output_placeholder,
+            str(expected_output),
+        )
+
+        return formatted_prompt
+
+    async def _get_llm_response(self, evaluation_prompt: str) -> LLMResponse:
+        """Get response from the LLM using function calling for structured output.
+
+        This method uses the Normalized API's function calling feature to ensure
+        structured output across all model providers (OpenAI, Claude, Gemini).
+        Function calling is more reliable than prompt-based JSON instructions
+        and works consistently across all providers.
+        """
+        from uipath.platform.chat.llm_gateway import (
+            RequiredToolChoice,
+            ToolDefinition,
+            ToolFunctionDefinition,
+            ToolParametersDefinition,
+            ToolPropertyDefinition,
+        )
+
+        # Remove community-agents suffix from llm model name
+        model = self.evaluator_config.model
+        if model.endswith(COMMUNITY_agents_SUFFIX):
+            model = model.replace(COMMUNITY_agents_SUFFIX, "")
+
+        # Define function/tool for structured output (works for ALL models via Normalized API)
+        evaluation_tool = ToolDefinition(
+            type="function",
+            function=ToolFunctionDefinition(
+                name="submit_evaluation",
+                description="Submit the evaluation score and justification for the agent output",
+                parameters=ToolParametersDefinition(
+                    type="object",
+                    properties={
+                        "justification": ToolPropertyDefinition(
+                            type="string",
+                            description="Clear analysis of the evaluation explaining the reasoning behind the score",
+                        ),
+                        "score": ToolPropertyDefinition(
+                            type="number",
+                            description="Numeric score between 0 and 100 representing the evaluation result",
+                        ),
+                    },
+                    required=["justification", "score"],
+                ),
+            ),
+        )
+
+        # Prepare the tool_choice object
+        tool_choice = RequiredToolChoice()
+
+        # Prepare the request with function calling
+        request_data: dict[str, Any] = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": evaluation_prompt},
+            ],
+            "temperature": self.evaluator_config.temperature,
+            "tools": [evaluation_tool],
+            "tool_choice": tool_choice,
+        }
+
+        # Set max_tokens - use explicit config value, or default for Claude 4.5 models
+        max_tokens_value = self.evaluator_config.max_tokens
+        if max_tokens_value is None:
+            # Claude 4.5 models require max_tokens, set default to 8000
+            if "claude-haiku-4-5" in model or "claude-sonnet-4-5" in model:
+                max_tokens_value = 8000
+
+        # Only include max_tokens if set (don't pass None to API)
+        if max_tokens_value is not None:
+            request_data["max_tokens"] = max_tokens_value
+
+        # Lazy initialization - initialize LLM service only when needed
+        # This ensures eval_set_run_id context is set before creating UiPath instance
+        if self.llm_service is None:
+            self.llm_service = self._get_llm_service()
+
+        if self.llm_service is None:
+            raise UiPathEvaluationError(
+                code="LLM_SERVICE_NOT_INITIALIZED",
+                title="LLM service not initialized",
+                detail="LLM service not initialized",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            )
+
+        # Log the request details (exclude non-JSON-serializable objects)
+        logger.info(
+            f"🤖 Calling LLM evaluator with model: {model} (using function calling)"
+        )
+        max_tokens_str = (
+            str(max_tokens_value) if max_tokens_value is not None else "unset"
+        )
+        logger.debug(
+            f"Request data: model={model}, max_tokens={max_tokens_str}, temperature={self.evaluator_config.temperature}, tool_choice=required"
+        )
+
+        # Log full request body for debugging
+        request_body_for_log = copy.deepcopy(request_data)
+        # Convert tool_choice to dict for logging
+        if "tool_choice" in request_body_for_log:
+            request_body_for_log["tool_choice"] = request_body_for_log[
+                "tool_choice"
+            ].model_dump()
+        # Convert tools to dict for logging
+        if "tools" in request_body_for_log:
+            request_body_for_log["tools"] = [
+                t.model_dump() for t in request_body_for_log["tools"]
+            ]
+        logger.info(
+            f"📤 Full request body:\n{json.dumps(request_body_for_log, indent=2)}"
+        )
+
+        try:
+            response = await self.llm_service(**request_data)
+        except Exception as e:
+            # Enhanced error logging with details
+            logger.error("=" * 80)
+            logger.error("❌ LLM REQUEST FAILED")
+            logger.error("=" * 80)
+            logger.error(f"Model: {model}")
+            logger.error("API Endpoint: Normalized API (/llm/api/chat/completions)")
+            logger.error(f"Error Type: {type(e).__name__}")
+            logger.error(f"Error Message: {str(e)}")
+
+            # Try to extract HTTP error details if available
+            if hasattr(e, "response"):
+                logger.error(
+                    f"HTTP Status Code: {e.response.status_code if hasattr(e.response, 'status_code') else 'N/A'}"
+                )
+                try:
+                    error_body = (
+                        e.response.json()
+                        if hasattr(e.response, "json")
+                        else str(e.response.content)
+                    )
+                    logger.error(
+                        f"Response Body: {json.dumps(error_body, indent=2) if isinstance(error_body, dict) else error_body}"
+                    )
+                except Exception:
+                    logger.error(
+                        f"Response Body: {str(e.response.content) if hasattr(e.response, 'content') else 'N/A'}"
+                    )
+
+            max_tokens_str = (
+                str(self.evaluator_config.max_tokens)
+                if self.evaluator_config.max_tokens is not None
+                else "unset"
+            )
+            logger.error(
+                f"Request Details: model={model}, max_tokens={max_tokens_str}, temperature={self.evaluator_config.temperature}, tool_choice=required"
+            )
+            logger.error("=" * 80)
+
+            raise UiPathEvaluationError(
+                code="FAILED_TO_GET_LLM_RESPONSE",
+                title="Failed to get LLM response",
+                detail=f"Model: {model}, Error: {type(e).__name__}: {str(e)}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
+
+        # Log successful response
+        logger.info(f"✅ LLM response received successfully from {model}")
+        logger.debug(f"Response: {response}")
+
+        # Extract structured output from tool call
+        return self._extract_tool_call_response(response, model)
+
+    def _extract_tool_call_response(self, response: Any, model: str) -> LLMResponse:
+        """Extract the evaluation response from the tool call.
+
+        Args:
+            response: The chat completion response containing tool calls
+            model: The model name (for error logging)
+
+        Returns:
+            LLMResponse with score and justification
+
+        Raises:
+            UiPathEvaluationError: If tool call is missing or malformed
+        """
+        try:
+            # Get the first choice
+            if not response.choices or len(response.choices) == 0:
+                raise UiPathEvaluationError(
+                    code="INVALID_LLM_RESPONSE",
+                    title="No choices in LLM response",
+                    detail="The LLM response contained no choices",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            choice = response.choices[0]
+            message = choice.message
+
+            # Check for tool calls
+            if not message.tool_calls or len(message.tool_calls) == 0:
+                # Log the actual response for debugging
+                logger.error("=" * 80)
+                logger.error("❌ NO TOOL CALL IN RESPONSE")
+                logger.error("=" * 80)
+                logger.error(f"Model: {model}")
+                logger.error(f"Message content: {message.content}")
+                logger.error("=" * 80)
+
+                raise UiPathEvaluationError(
+                    code="NO_TOOL_CALL",
+                    title="LLM did not use the evaluation tool",
+                    detail=f"Expected tool call but got text response: {message.content}",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            # Extract the tool call arguments
+            tool_call = message.tool_calls[0]
+            arguments = tool_call.arguments
+
+            logger.debug(f"Tool call arguments: {arguments}")
+
+            # Validate required fields
+            if "score" not in arguments:
+                raise UiPathEvaluationError(
+                    code="MISSING_SCORE",
+                    title="Tool call missing required 'score' field",
+                    detail=f"Tool arguments: {arguments}",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            if "justification" not in arguments:
+                raise UiPathEvaluationError(
+                    code="MISSING_JUSTIFICATION",
+                    title="Tool call missing required 'justification' field",
+                    detail=f"Tool arguments: {arguments}",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                )
+
+            # Parse and validate
+            try:
+                score = float(arguments["score"])
+                justification = str(arguments["justification"])
+            except (ValueError, TypeError) as e:
+                raise UiPathEvaluationError(
+                    code="INVALID_TOOL_ARGUMENTS",
+                    title="Failed to parse tool call arguments",
+                    detail=f"Error: {e}, Arguments: {arguments}",
+                    category=UiPathEvaluationErrorCategory.SYSTEM,
+                ) from e
+
+            logger.info(f"📊 Parsed evaluation score: {score}")
+            return LLMResponse(score=score, justification=justification)
+
+        except UiPathEvaluationError:
+            # Re-raise UiPathEvaluationErrors as-is
+            raise
+        except Exception as e:
+            # Wrap unexpected errors
+            logger.error("=" * 80)
+            logger.error("❌ TOOL CALL EXTRACTION FAILED")
+            logger.error("=" * 80)
+            logger.error(f"Model: {model}")
+            logger.error(f"Error: {type(e).__name__}: {str(e)}")
+            logger.error(f"Response: {response}")
+            logger.error("=" * 80)
+
+            raise UiPathEvaluationError(
+                code="FAILED_TO_EXTRACT_TOOL_CALL",
+                title="Failed to extract evaluation from tool call",
+                detail=f"Error: {type(e).__name__}: {str(e)}",
+                category=UiPathEvaluationErrorCategory.SYSTEM,
+            ) from e
diff --git a/packages/uipath/src/uipath/eval/evaluators/llm_judge_output_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/llm_judge_output_evaluator.py
new file mode 100644
index 000000000..d533de237
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/llm_judge_output_evaluator.py
@@ -0,0 +1,114 @@
+"""LLM judge output evaluators for evaluating agent outputs."""
+
+from typing import TypeVar
+
+from pydantic import BaseModel, Field
+
+from ..models import AgentExecution, EvaluationResult, EvaluatorType
+from ..models.llm_judge_types import (
+    LLMJudgeOutputSchema,
+    LLMJudgePromptTemplates,
+    LLMJudgeStrictJSONSimilarityOutputSchema,
+)
+from .llm_as_judge_evaluator import (
+    BaseLLMJudgeEvaluatorConfig,
+    LLMJudgeJustification,
+    LLMJudgeMixin,
+)
+from .output_evaluator import (
+    OutputEvaluationCriteria,
+    OutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class BaseLLMJudgeOutputCriteriaEvaluatorConfig(
+    OutputEvaluatorConfig[OutputEvaluationCriteria],
+    BaseLLMJudgeEvaluatorConfig[OutputEvaluationCriteria],
+):
+    """Base configuration for LLM judge output criteria evaluators."""
+
+    pass
+
+
+class LLMJudgeOutputEvaluatorConfig(BaseLLMJudgeOutputCriteriaEvaluatorConfig):
+    """Configuration for the LLM judge output evaluator."""
+
+    name: str = "LLMJudgeOutputEvaluator"
+    prompt: str = LLMJudgePromptTemplates.LLM_JUDGE_DEFAULT_USER_PROMPT
+
+
+class LLMJudgeStrictJSONSimilarityOutputEvaluatorConfig(LLMJudgeOutputEvaluatorConfig):
+    """Configuration for the LLM judge strict JSON similarity output evaluator."""
+
+    name: str = "LLMJudgeStrictJSONSimilarityOutputEvaluator"
+    prompt: str = (
+        LLMJudgePromptTemplates.LLM_JUDGE_STRICT_JSON_SIMILARITY_DEFAULT_USER_PROMPT
+    )
+
+
+OC = TypeVar("OC", bound=LLMJudgeOutputEvaluatorConfig)
+
+
+# NOTE: This evaluator is only used in coded evaluators
+class BaseLLMOutputEvaluator(
+    OutputEvaluator[OutputEvaluationCriteria, OC, LLMJudgeJustification],
+    LLMJudgeMixin[OutputEvaluationCriteria, OC],
+):
+    """Base class for LLM judge output evaluators that contains all shared functionality.
+
+    This class encapsulates the common evaluation logic for output-based LLM evaluators,
+    combining OutputEvaluator (for output extraction) with LLMJudgeMixin (for LLM functionality).
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_OUTPUT.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: OutputEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate using an LLM as a judge."""
+        # Explicitly delegate to LLMJudgeMixin's evaluate method to override BaseEvaluator
+        return await LLMJudgeMixin.evaluate(self, agent_execution, evaluation_criteria)
+
+
+class LLMJudgeOutputEvaluator(BaseLLMOutputEvaluator[LLMJudgeOutputEvaluatorConfig]):
+    """Evaluator that uses an LLM to judge the quality of agent output.
+
+    Inherits all functionality from BaseLLMOutputEvaluator but uses the standard
+    system prompt and output schema for general output evaluation.
+    """
+
+    system_prompt: str = LLMJudgePromptTemplates.LLM_JUDGE_SYSTEM_PROMPT
+    output_schema: type[BaseModel] = Field(default=LLMJudgeOutputSchema, exclude=True)
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_OUTPUT_SEMANTIC_SIMILARITY.value
+
+
+class LLMJudgeStrictJSONSimilarityOutputEvaluator(
+    BaseLLMOutputEvaluator[LLMJudgeStrictJSONSimilarityOutputEvaluatorConfig]
+):
+    """Evaluator that uses an LLM to judge the quality of agent output with strict JSON similarity.
+
+    Inherits all functionality from BaseLLMOutputEvaluator but uses a different system prompt
+    and output schema specific to strict JSON similarity evaluation.
+    """
+
+    system_prompt: str = (
+        LLMJudgePromptTemplates.LLM_JUDGE_STRICT_JSON_SIMILARITY_SYSTEM_PROMPT
+    )
+    output_schema: type[BaseModel] = Field(
+        default=LLMJudgeStrictJSONSimilarityOutputSchema, exclude=True
+    )
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_OUTPUT_STRICT_JSON_SIMILARITY.value
diff --git a/packages/uipath/src/uipath/eval/evaluators/llm_judge_trajectory_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/llm_judge_trajectory_evaluator.py
new file mode 100644
index 000000000..69b14cd1f
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/llm_judge_trajectory_evaluator.py
@@ -0,0 +1,144 @@
+"""LLM judge trajectory evaluator for evaluating agent execution trajectories."""
+
+from typing import Any, TypeVar
+
+from pydantic import BaseModel, Field
+
+from .._helpers.evaluators_helpers import trace_to_str
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+)
+from ..models.llm_judge_types import (
+    LLMJudgePromptTemplates,
+    LLMJudgeTrajectoryOutputSchema,
+)
+from .base_evaluator import BaseEvaluationCriteria
+from .llm_as_judge_evaluator import (
+    BaseLLMJudgeEvaluatorConfig,
+    LLMJudgeMixin,
+)
+
+
+class TrajectoryEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for trajectory-based evaluations."""
+
+    expected_agent_behavior: str
+
+
+class LLMJudgeTrajectoryEvaluatorConfig(
+    BaseLLMJudgeEvaluatorConfig[TrajectoryEvaluationCriteria]
+):
+    """Configuration for the llm judge trajectory evaluator."""
+
+    name: str = "LLMJudgeTrajectoryEvaluator"
+    prompt: str = LLMJudgePromptTemplates.LLM_JUDGE_TRAJECTORY_DEFAULT_USER_PROMPT
+
+
+class LLMJudgeTrajectorySimulationEvaluatorConfig(
+    BaseLLMJudgeEvaluatorConfig[TrajectoryEvaluationCriteria]
+):
+    """Configuration for the llm judge simulation trajectory evaluator."""
+
+    name: str = "LLMJudgeTrajectorySimulationEvaluator"
+    prompt: str = (
+        LLMJudgePromptTemplates.LLM_JUDGE_SIMULATION_TRAJECTORY_DEFAULT_USER_PROMPT
+    )
+
+
+TC = TypeVar("TC", bound=BaseLLMJudgeEvaluatorConfig[TrajectoryEvaluationCriteria])
+
+
+class BaseLLMTrajectoryEvaluator(LLMJudgeMixin[TrajectoryEvaluationCriteria, TC]):
+    """Base class for LLM trajectory evaluators that contains all shared functionality.
+
+    This class encapsulates the common evaluation logic for trajectory-based LLM evaluators,
+    including output extraction, prompt formatting, and evaluation criteria handling.
+    """
+
+    output_schema: type[BaseModel] = Field(
+        default=LLMJudgeTrajectoryOutputSchema, exclude=True
+    )
+    actual_output_placeholder: str = "{{AgentRunHistory}}"
+    expected_output_placeholder: str = "{{ExpectedAgentBehavior}}"
+    user_input_placeholder: str = "{{UserOrSyntheticInput}}"
+    simulation_instructions_placeholder: str = "{{SimulationInstructions}}"
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_TRAJECTORY.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: TrajectoryEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate using trajectory analysis."""
+        return await super().evaluate(agent_execution, evaluation_criteria)
+
+    def _get_actual_output(self, agent_execution: AgentExecution) -> Any:
+        """Get the actual output from the agent execution."""
+        return trace_to_str(agent_execution.agent_trace)
+
+    def _get_expected_output(
+        self, evaluation_criteria: TrajectoryEvaluationCriteria
+    ) -> Any:
+        """Get the expected agent behavior from the evaluation criteria."""
+        return evaluation_criteria.expected_agent_behavior
+
+    def _create_evaluation_prompt(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: TrajectoryEvaluationCriteria,
+    ) -> str:
+        """Create the evaluation prompt for the LLM."""
+        formatted_prompt = super()._create_evaluation_prompt(
+            agent_execution, evaluation_criteria
+        )
+        formatted_prompt = formatted_prompt.replace(
+            self.user_input_placeholder,
+            str(agent_execution.agent_input),
+        )
+        formatted_prompt = formatted_prompt.replace(
+            self.simulation_instructions_placeholder,
+            agent_execution.simulation_instructions,
+        )
+        return formatted_prompt
+
+
+class LLMJudgeTrajectoryEvaluator(
+    BaseLLMTrajectoryEvaluator[LLMJudgeTrajectoryEvaluatorConfig]
+):
+    """Evaluator that uses an LLM to judge the quality of agent trajectory.
+
+    Inherits all functionality from BaseLLMTrajectoryEvaluator but uses the standard
+    system prompt and configuration for general trajectory evaluation.
+    """
+
+    system_prompt: str = LLMJudgePromptTemplates.LLM_JUDGE_TRAJECTORY_SYSTEM_PROMPT
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_TRAJECTORY_SIMILARITY.value
+
+
+class LLMJudgeTrajectorySimulationEvaluator(
+    BaseLLMTrajectoryEvaluator[LLMJudgeTrajectorySimulationEvaluatorConfig]
+):
+    """Evaluator that uses an LLM to judge the quality of agent trajectory for simulations.
+
+    Inherits all functionality from BaseLLMTrajectoryEvaluator but uses a different system prompt
+    and configuration specific to simulation evaluation.
+    """
+
+    system_prompt: str = (
+        LLMJudgePromptTemplates.LLM_JUDGE_SIMULATION_TRAJECTORY_SYSTEM_PROMPT
+    )
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.LLM_JUDGE_TRAJECTORY_SIMULATION.value
diff --git a/packages/uipath/src/uipath/eval/evaluators/multiclass_classification_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/multiclass_classification_evaluator.py
new file mode 100644
index 000000000..69790c3aa
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/multiclass_classification_evaluator.py
@@ -0,0 +1,198 @@
+"""Multiclass classification evaluator for agent outputs.
+
+Evaluates multiclass classification by comparing predicted vs expected class.
+Per-datapoint score is 1.0 (correct) or 0.0 (incorrect). The reduce_scores
+method reads predicted/expected from justification details to reconstruct a
+confusion matrix and compute precision, recall, or F-score with micro or
+macro averaging.
+"""
+
+from typing import Literal
+
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    EvaluatorType,
+    NumericEvaluationResult,
+)
+from ..models.models import (
+    EvaluationResultDto,
+    UiPathEvaluationError,
+    UiPathEvaluationErrorCategory,
+)
+from .base_evaluator import BaseEvaluationCriteria, BaseEvaluatorJustification
+from .output_evaluator import (
+    BaseOutputEvaluator,
+    OutputEvaluatorConfig,
+)
+
+
+class MulticlassClassificationEvaluationCriteria(BaseEvaluationCriteria):
+    """Per-datapoint criteria: which class this sample should belong to."""
+
+    expected_class: str
+
+
+class MulticlassClassificationEvaluatorConfig(
+    OutputEvaluatorConfig[MulticlassClassificationEvaluationCriteria]
+):
+    """Configuration for the multiclass classification evaluator."""
+
+    name: str = "MulticlassClassificationEvaluator"
+    classes: list[str]
+    metric_type: Literal["precision", "recall", "f-score"] = "f-score"
+    averaging: Literal["micro", "macro"] = "macro"
+    f_value: float = 1.0
+
+
+class MulticlassClassificationEvaluator(
+    BaseOutputEvaluator[
+        MulticlassClassificationEvaluationCriteria,
+        MulticlassClassificationEvaluatorConfig,
+        BaseEvaluatorJustification,
+    ]
+):
+    """Multiclass classification evaluator with micro/macro averaging.
+
+    Per-datapoint scores are 1.0 (correct) or 0.0 (incorrect). The reduce_scores
+    method reads predicted/expected from justification details to reconstruct the
+    confusion matrix and compute the configured metric.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.MULTICLASS_CLASSIFICATION.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: MulticlassClassificationEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate multiclass classification by comparing predicted vs expected class."""
+        predicted_class = str(self._get_actual_output(agent_execution)).lower()
+        expected_class = evaluation_criteria.expected_class.lower()
+        classes = [c.lower() for c in self.evaluator_config.classes]
+
+        if expected_class not in classes:
+            raise UiPathEvaluationError(
+                code="INVALID_EXPECTED_CLASS",
+                title="Expected class not in configured classes",
+                detail=f"Expected class '{expected_class}' is not in the configured classes: {classes}",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        if predicted_class not in classes:
+            raise UiPathEvaluationError(
+                code="INVALID_PREDICTED_CLASS",
+                title="Predicted class not in configured classes",
+                detail=f"Predicted class '{predicted_class}' is not in the configured classes: {classes}",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        score = 1.0 if predicted_class == expected_class else 0.0
+
+        justification = self.validate_justification(
+            {
+                "expected": expected_class,
+                "actual": predicted_class,
+            }
+        )
+        return NumericEvaluationResult(score=score, details=justification)
+
+    def reduce_scores(self, results: list[EvaluationResultDto]) -> float:
+        """Reconstruct confusion matrix from details and compute the configured metric."""
+        if not results:
+            return 0.0
+
+        classes = [c.lower() for c in self.evaluator_config.classes]
+        k = len(classes)
+        metric_type = self.evaluator_config.metric_type
+        averaging = self.evaluator_config.averaging
+        f_value = self.evaluator_config.f_value
+
+        # Reconstruct confusion matrix: confusion[pred_idx][exp_idx]
+        confusion = [[0] * k for _ in range(k)]
+        for r in results:
+            if isinstance(r.details, BaseEvaluatorJustification):
+                details = r.details
+            elif isinstance(r.details, dict):
+                try:
+                    details = BaseEvaluatorJustification.model_validate(r.details)
+                except Exception:
+                    continue
+            else:
+                continue
+            pred = details.actual
+            exp = details.expected
+            if pred in classes and exp in classes:
+                confusion[classes.index(pred)][classes.index(exp)] += 1
+
+        if averaging == "micro":
+            return _micro_metric(confusion, k, metric_type, f_value)
+        else:
+            return _macro_metric(confusion, k, metric_type, f_value)
+
+
+def _micro_metric(
+    confusion: list[list[int]],
+    k: int,
+    metric_type: str,
+    f_value: float,
+) -> float:
+    """Compute micro-averaged metric from confusion matrix."""
+    total_tp = sum(confusion[i][i] for i in range(k))
+    # For micro-averaging, sum TP/FP/FN across all classes
+    total_fp = sum(
+        sum(confusion[i][j] for j in range(k)) - confusion[i][i] for i in range(k)
+    )
+    total_fn = sum(
+        sum(confusion[j][i] for j in range(k)) - confusion[i][i] for i in range(k)
+    )
+
+    if metric_type == "precision":
+        denom = total_tp + total_fp
+        return total_tp / denom if denom > 0 else 0.0
+    elif metric_type == "recall":
+        denom = total_tp + total_fn
+        return total_tp / denom if denom > 0 else 0.0
+    elif metric_type == "f-score":
+        p = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0.0
+        rec = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0.0
+        beta_sq = f_value**2
+        f_denom = beta_sq * p + rec
+        return (1 + beta_sq) * p * rec / f_denom if f_denom > 0 else 0.0
+    return 0.0
+
+
+def _macro_metric(
+    confusion: list[list[int]],
+    k: int,
+    metric_type: str,
+    f_value: float,
+) -> float:
+    """Compute macro-averaged metric from confusion matrix."""
+    per_class_metrics: list[float] = []
+
+    for c in range(k):
+        tp = confusion[c][c]
+        fp = sum(confusion[c][j] for j in range(k)) - tp
+        fn = sum(confusion[j][c] for j in range(k)) - tp
+
+        if metric_type == "precision":
+            denom = tp + fp
+            per_class_metrics.append(tp / denom if denom > 0 else 0.0)
+        elif metric_type == "recall":
+            denom = tp + fn
+            per_class_metrics.append(tp / denom if denom > 0 else 0.0)
+        elif metric_type == "f-score":
+            p = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+            rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+            beta_sq = f_value**2
+            f_denom = beta_sq * p + rec
+            f_score = (1 + beta_sq) * p * rec / f_denom if f_denom > 0 else 0.0
+            per_class_metrics.append(f_score)
+
+    if not per_class_metrics:
+        return 0.0
+    return sum(per_class_metrics) / len(per_class_metrics)
diff --git a/packages/uipath/src/uipath/eval/evaluators/output_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/output_evaluator.py
new file mode 100644
index 000000000..5eb54e9e3
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/output_evaluator.py
@@ -0,0 +1,369 @@
+"""Base class for all output evaluator configurations."""
+
+import json
+from enum import Enum
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from pydantic import BaseModel, Field
+
+from .._helpers.output_path import resolve_output_path
+from ..models import AgentExecution
+from ..models.models import UiPathEvaluationError, UiPathEvaluationErrorCategory
+from .attachment_utils import (
+    download_attachment_as_string,
+    extract_attachment_id,
+    is_job_attachment_uri,
+)
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+from .line_by_line_utils import (
+    split_into_lines,
+)
+
+if TYPE_CHECKING:
+    from ..models import EvaluationResult
+
+
+class AggregationMethod(str, Enum):
+    """Aggregation methods for line-by-line evaluation scores."""
+
+    AVERAGE = "average"
+    MAX = "max"
+    MIN = "min"
+    MEDIAN = "median"
+
+
+class LineEvaluationDetail(BaseModel):
+    """Details for a single line evaluation."""
+
+    line_number: int
+    actual: str
+    expected: str
+    score: float | bool
+    details: Any = None
+
+
+class LineByLineEvaluationDetails(BaseModel):
+    """Aggregated details for line-by-line evaluation."""
+
+    line_by_line_results: list[LineEvaluationDetail]
+    total_lines_actual: int
+    total_lines_expected: int
+    aggregation_method: AggregationMethod = AggregationMethod.AVERAGE
+
+
+class LineByLineEvaluationResult(BaseModel):
+    """Container for line-by-line evaluation results.
+
+    This is attached to the aggregated NumericEvaluationResult to allow
+    the runtime to extract individual line results and store them separately.
+    """
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    line_results: list[tuple[int, Any]]  # (line_number, result)
+    aggregation_method: AggregationMethod = AggregationMethod.AVERAGE
+
+
+class OutputEvaluationCriteria(BaseEvaluationCriteria):
+    """Base class for all output evaluation criteria."""
+
+    expected_output: dict[str, Any] | str = Field(..., alias="expectedOutput")
+
+
+T = TypeVar("T", bound=BaseEvaluationCriteria)
+T_OutputCriteria = TypeVar("T_OutputCriteria", bound=OutputEvaluationCriteria)
+
+
+class OutputEvaluatorConfig(BaseEvaluatorConfig[T]):
+    """Base class for all output evaluator configurations.
+
+    Generic over T to allow subclasses to define their own
+    specific output evaluation criteria types while maintaining type safety.
+    """
+
+    target_output_key: str | list[str] = Field(
+        default="*",
+        description="Key or list of keys to extract output from agent execution",
+    )
+    line_by_line_evaluator: bool = Field(
+        default=False,
+        description="If True, split output by delimiter and evaluate each line separately",
+    )
+    line_delimiter: str = Field(
+        default="\n",
+        description="Delimiter to split output when line_by_line_evaluator is True",
+    )
+
+
+C = TypeVar("C", bound=OutputEvaluatorConfig[Any])
+J = TypeVar("J", bound=Union[str, BaseEvaluatorJustification])
+
+
+# NOTE: This evaluator is only used in coded evaluators
+class BaseOutputEvaluator(BaseEvaluator[T, C, J]):
+    """Abstract base class for all output evaluators.
+
+    Generic Parameters:
+        T_OutputCriteria: The output evaluation criteria type
+        C: The output evaluator config type (bound to OutputEvaluatorConfig[T_OutputCriteria])
+        J: The justification type
+    """
+
+    def _normalize_numbers(self, obj: Any) -> Any:
+        """Recursively normalize int/float to float for consistent numeric comparison.
+
+        Converts all numeric values (int, float) to float in nested structures
+        (dicts, lists), while preserving booleans and other data types.
+        """
+        if isinstance(obj, dict):
+            return {k: self._normalize_numbers(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [self._normalize_numbers(v) for v in obj]
+        if isinstance(obj, (int, float)) and not isinstance(obj, bool):
+            return float(obj)
+        return obj
+
+    def _get_actual_output(self, agent_execution: AgentExecution) -> Any:
+        """Get the actual output from the agent execution.
+
+        If the output is a job attachment URI, downloads the attachment
+        and returns its content as a string.
+        """
+        key = self.evaluator_config.target_output_key
+
+        if isinstance(key, list):
+            if not isinstance(agent_execution.agent_output, dict):
+                raise UiPathEvaluationError(
+                    code="INVALID_ACTUAL_OUTPUT",
+                    title="When target output keys are specified, actual output must be a dictionary",
+                    detail=f"Got {type(agent_execution.agent_output).__name__}",
+                    category=UiPathEvaluationErrorCategory.USER,
+                )
+            try:
+                list_result: dict[str, Any] = {
+                    k: resolve_output_path(agent_execution.agent_output, k) for k in key
+                }
+            except (KeyError, IndexError, TypeError) as e:
+                raise UiPathEvaluationError(
+                    code="TARGET_OUTPUT_KEY_NOT_FOUND",
+                    title="One or more target output keys not found in actual output",
+                    detail=f"Error: {e}",
+                    category=UiPathEvaluationErrorCategory.USER,
+                ) from e
+            for k, v in list_result.items():
+                if is_job_attachment_uri(v):
+                    attachment_id = extract_attachment_id(v)
+                    list_result[k] = download_attachment_as_string(attachment_id)
+            return self._normalize_numbers(list_result)
+        elif key != "*":
+            try:
+                result = resolve_output_path(agent_execution.agent_output, key)
+            except (KeyError, IndexError, TypeError) as e:
+                raise UiPathEvaluationError(
+                    code="TARGET_OUTPUT_KEY_NOT_FOUND",
+                    title="Target output key not found in actual output",
+                    detail=f"Error: {e}",
+                    category=UiPathEvaluationErrorCategory.USER,
+                ) from e
+        else:
+            result = agent_execution.agent_output
+
+        if is_job_attachment_uri(result):
+            attachment_id = extract_attachment_id(result)
+            result = download_attachment_as_string(attachment_id)
+
+        return self._normalize_numbers(result)
+
+    def _get_full_expected_output(self, evaluation_criteria: T) -> Any:
+        """Get the full expected output from the evaluation criteria."""
+        raise UiPathEvaluationError(
+            code="NOT_IMPLEMENTED",
+            title="This method was not implemented by the subclass.",
+            detail="This method was not implemented by the subclass.",
+            category=UiPathEvaluationErrorCategory.SYSTEM,
+        )
+
+    def _resolve_list_key_expected(
+        self, expected_output: Any, keys: list[str]
+    ) -> dict[str, Any]:
+        """Parse and resolve expected output for a list of keys."""
+        if isinstance(expected_output, str):
+            try:
+                expected_output = json.loads(expected_output)
+            except json.JSONDecodeError as e:
+                raise UiPathEvaluationError(
+                    code="INVALID_EXPECTED_OUTPUT",
+                    title="When target output keys are specified, expected output must be a dictionary or a valid JSON string",
+                    detail=f"Error: {e}",
+                    category=UiPathEvaluationErrorCategory.USER,
+                ) from e
+        if not isinstance(expected_output, dict):
+            raise UiPathEvaluationError(
+                code="INVALID_EXPECTED_OUTPUT",
+                title="When target output keys are specified, expected output must be a dictionary",
+                detail=f"Got {type(expected_output).__name__}",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+        try:
+            return {k: resolve_output_path(expected_output, k) for k in keys}
+        except (KeyError, IndexError, TypeError) as e:
+            raise UiPathEvaluationError(
+                code="TARGET_OUTPUT_KEY_NOT_FOUND",
+                title="One or more target output keys not found in expected output",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.USER,
+            ) from e
+
+    def _resolve_scalar_key_expected(self, expected_output: Any, key: str) -> Any:
+        """Parse and resolve expected output for a single key."""
+        if isinstance(expected_output, str):
+            try:
+                expected_output = json.loads(expected_output)
+            except json.JSONDecodeError as e:
+                raise UiPathEvaluationError(
+                    code="INVALID_EXPECTED_OUTPUT",
+                    title="When target output key is not '*', expected output must be a dictionary or a valid JSON string",
+                    detail=f"Error: {e}",
+                    category=UiPathEvaluationErrorCategory.USER,
+                ) from e
+        try:
+            return resolve_output_path(expected_output, key)
+        except (KeyError, IndexError, TypeError) as e:
+            raise UiPathEvaluationError(
+                code="TARGET_OUTPUT_KEY_NOT_FOUND",
+                title="Target output key not found in expected output",
+                detail=f"Error: {e}",
+                category=UiPathEvaluationErrorCategory.USER,
+            ) from e
+
+    def _get_expected_output(self, evaluation_criteria: T) -> Any:
+        """Load the expected output from the evaluation criteria."""
+        expected_output = self._get_full_expected_output(evaluation_criteria)
+        key = self.evaluator_config.target_output_key
+        if isinstance(key, list):
+            expected_output = self._resolve_list_key_expected(expected_output, key)
+        elif key != "*":
+            expected_output = self._resolve_scalar_key_expected(expected_output, key)
+        return self._normalize_numbers(expected_output)
+
+    async def validate_and_evaluate_criteria(
+        self,
+        agent_execution: "AgentExecution",
+        evaluation_criteria: Any,
+    ) -> "EvaluationResult":
+        """Validate evaluation criteria and evaluate the agent execution.
+
+        If line_by_line_evaluator is enabled, splits the output by delimiter
+        and evaluates each line separately, then aggregates the scores.
+
+        Args:
+            agent_execution: The agent execution to evaluate
+            evaluation_criteria: The evaluation criteria (dict or typed object)
+
+        Returns:
+            EvaluationResult with aggregated score if line-by-line, else single score
+        """
+        # Validate criteria first
+        if evaluation_criteria is None:
+            evaluation_criteria = self.evaluator_config.default_evaluation_criteria
+
+        if evaluation_criteria is None:
+            raise UiPathEvaluationError(
+                code="MISSING_EVALUATION_CRITERIA",
+                title="No evaluation criteria provided",
+                detail="Evaluation criteria must be provided either in the request or as default in config",
+                category=UiPathEvaluationErrorCategory.USER,
+            )
+
+        validated_criteria = self.validate_evaluation_criteria(evaluation_criteria)
+
+        # Check if line-by-line evaluation is enabled
+        if not self.evaluator_config.line_by_line_evaluator or isinstance(
+            self.evaluator_config.target_output_key, list
+        ):
+            # Standard evaluation
+            return await self.evaluate(agent_execution, validated_criteria)
+
+        # Line-by-line evaluation
+        return await self._evaluate_line_by_line(agent_execution, validated_criteria)
+
+    async def _evaluate_line_by_line(
+        self,
+        agent_execution: "AgentExecution",
+        evaluation_criteria: T,
+    ) -> "EvaluationResult":
+        """Evaluate output line by line and aggregate scores.
+
+        Args:
+            agent_execution: The agent execution to evaluate
+            evaluation_criteria: Validated evaluation criteria
+
+        Returns:
+            NumericEvaluationResult with aggregated score
+        """
+        from .line_by_line_utils import build_line_by_line_result, evaluate_lines
+
+        key_str = (
+            self.evaluator_config.target_output_key
+            if isinstance(self.evaluator_config.target_output_key, str)
+            else "*"
+        )
+
+        actual_output = self._get_actual_output(agent_execution)
+        expected_output = self._get_expected_output(evaluation_criteria)
+
+        actual_lines = split_into_lines(
+            actual_output, self.evaluator_config.line_delimiter, key_str
+        )
+        expected_lines = split_into_lines(
+            expected_output, self.evaluator_config.line_delimiter, key_str
+        )
+
+        original_agent_output = agent_execution.agent_output
+
+        def create_line_criteria(expected_line: str) -> Any:
+            from .line_by_line_utils import wrap_line_in_structure
+
+            line_expected_output = wrap_line_in_structure(expected_line, key_str)
+            line_criteria_dict = evaluation_criteria.model_dump()
+            if "expected_output" in line_criteria_dict:
+                line_criteria_dict["expected_output"] = line_expected_output
+            return type(evaluation_criteria).model_validate(line_criteria_dict)
+
+        line_details, line_results = await evaluate_lines(
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+            target_output_key=key_str,
+            agent_execution=agent_execution,
+            evaluate_fn=self.evaluate,
+            create_line_criteria_fn=create_line_criteria,
+        )
+
+        agent_execution.agent_output = original_agent_output
+
+        return build_line_by_line_result(
+            line_details=line_details,
+            line_results=line_results,
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+        )
+
+
+# NOTE: This evaluator is only used in coded evaluators.
+class OutputEvaluator(BaseOutputEvaluator[T_OutputCriteria, C, J]):
+    """Abstract base class for all output evaluators.
+
+    Generic Parameters:
+        T_OutputCriteria: The output evaluation criteria type
+        C: The output evaluator config type (bound to OutputEvaluatorConfig[T_OutputCriteria])
+        J: The justification type
+    """
+
+    def _get_full_expected_output(self, evaluation_criteria: T_OutputCriteria) -> Any:
+        """Get the full expected output from the evaluation criteria."""
+        return evaluation_criteria.expected_output
diff --git a/packages/uipath/src/uipath/eval/evaluators/registration.py b/packages/uipath/src/uipath/eval/evaluators/registration.py
new file mode 100644
index 000000000..deef50b7e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/registration.py
@@ -0,0 +1,187 @@
+"""Module for registering custom evaluators in the UiPath evaluation framework."""
+
+import ast
+import importlib.util
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from ..constants import CUSTOM_EVALUATOR_PREFIX, EVALS_FOLDER
+
+logger = logging.getLogger(__name__)
+
+
+class EvaluatorRegistrationError(Exception):
+    """Raised when evaluator registration fails."""
+
+    pass
+
+
+def to_kebab_case(text: str) -> str:
+    """Convert a given string to kebab-case."""
+    return re.sub(r"(?<!^)(?=[A-Z])", "-", text).lower()
+
+
+def find_evaluator_file(filename: str) -> Path | None:
+    """Find the evaluator file in evals/evaluators/custom folder."""
+    custom_evaluators_path = Path.cwd() / EVALS_FOLDER / "evaluators" / "custom"
+
+    if not custom_evaluators_path.exists():
+        return None
+
+    file_path = custom_evaluators_path / filename
+    if file_path.exists():
+        return file_path
+
+    return None
+
+
+def find_base_evaluator_class(file_path: Path) -> str | None:
+    """Parse the Python file and find the class that inherits from BaseEvaluator."""
+    try:
+        with open(file_path, "r") as f:
+            tree = ast.parse(f.read(), filename=str(file_path))
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                for base in node.bases:
+                    if isinstance(base, ast.Name) and base.id == "BaseEvaluator":
+                        return node.name
+                    elif isinstance(base, ast.Subscript):
+                        if (
+                            isinstance(base.value, ast.Name)
+                            and base.value.id == "BaseEvaluator"
+                        ):
+                            return node.name
+
+        return None
+    except Exception as e:
+        logger.error(f"Error parsing file: {e}")
+        return None
+
+
+def load_evaluator_class(file_path: Path, class_name: str) -> Any | None:
+    """Dynamically load the evaluator class from the file."""
+    try:
+        parent_dir = str(file_path.parent)
+        if parent_dir not in sys.path:
+            sys.path.insert(0, parent_dir)
+
+        spec = importlib.util.spec_from_file_location("custom_evaluator", file_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        if hasattr(module, class_name):
+            return getattr(module, class_name)
+
+        return None
+    except Exception as e:
+        logger.error(f"Error loading class: {e}")
+        return None
+    finally:
+        # Remove from sys.path
+        if parent_dir in sys.path:
+            sys.path.remove(parent_dir)
+
+
+def generate_evaluator_config(evaluator_class: Any, class_name: str) -> dict[str, Any]:
+    """Generate the evaluator config from the class."""
+    try:
+        config_type = evaluator_class._extract_config_type()
+        config_instance = config_type()
+        config_dict = config_instance.model_dump(by_alias=True, exclude_none=False)
+
+        return config_dict
+    except Exception as e:
+        raise EvaluatorRegistrationError(
+            f"Error inferring evaluator config: {e}"
+        ) from e
+
+
+def register_evaluator(filename: str) -> tuple[str, str]:
+    """Infers the schema and types of a custom evaluator.
+
+    Returns:
+        tuple[str, str]:
+            - The first string is the path to the python evaluator file.
+            - The second string is the evaluator type that corresponds to the schema file.
+
+    Raises:
+        EvaluatorRegistrationError: If registration fails at any step.
+    """
+    if not filename.endswith(".py"):
+        filename = filename + ".py"
+    file_path = find_evaluator_file(filename)
+    if file_path is None:
+        raise EvaluatorRegistrationError(
+            f"Could not find '{filename}' in {EVALS_FOLDER}/evaluators/custom folder"
+        )
+
+    logger.info(f"Found custom evaluator file: evals/evaluators/custom/{filename}")
+
+    class_name = find_base_evaluator_class(file_path)
+    if class_name is None:
+        raise EvaluatorRegistrationError(
+            f"Could not find a class inheriting from BaseEvaluator in {filename}"
+        )
+
+    logger.info(f"Found custom evaluator class: {class_name}")
+
+    evaluator_class = load_evaluator_class(file_path, class_name)
+    if evaluator_class is None:
+        raise EvaluatorRegistrationError(
+            f"Could not load class {class_name} from {filename}"
+        )
+
+    try:
+        evaluator_id = evaluator_class.get_evaluator_id()
+    except Exception as e:
+        raise EvaluatorRegistrationError(f"Error getting evaluator ID: {e}") from e
+
+    evaluator_config = generate_evaluator_config(evaluator_class, class_name)
+    evaluator_json_type = evaluator_class.generate_json_type()
+
+    evaluators_dir = Path.cwd() / EVALS_FOLDER / "evaluators"
+    evaluators_dir.mkdir(parents=True, exist_ok=True)
+
+    evaluator_types_dir = evaluators_dir / "custom" / "types"
+    evaluator_types_dir.mkdir(parents=True, exist_ok=True)
+
+    kebab_class_name = to_kebab_case(class_name)
+    output_file_evaluator_types = kebab_class_name + "-types.json"
+    evaluator_types_output_path = (
+        evaluators_dir / "custom" / "types" / output_file_evaluator_types
+    )
+
+    with open(evaluator_types_output_path, "w") as f:
+        json.dump(evaluator_json_type, f, indent=2)
+
+    logger.info(
+        f"Generated evaluator types: {EVALS_FOLDER}/evaluators/custom/types/{output_file_evaluator_types}"
+    )
+
+    output = {
+        "version": "1.0",
+        "id": evaluator_id,
+        "evaluatorTypeId": f"{CUSTOM_EVALUATOR_PREFIX}types/{output_file_evaluator_types}",
+        "evaluatorSchema": f"{CUSTOM_EVALUATOR_PREFIX}{filename}:{class_name}",
+        "description": evaluator_class.__doc__,
+        "evaluatorConfig": evaluator_config,
+    }
+
+    output_file_evaluator_spec = kebab_class_name + ".json"
+    evaluator_spec_output_path = evaluators_dir / output_file_evaluator_spec
+    with open(evaluator_spec_output_path, "w") as f:
+        json.dump(output, f, indent=2)
+
+    logger.info(
+        f"Generated evaluator spec: evals/evaluators/{output_file_evaluator_spec}"
+    )
+
+    return str(file_path), str(evaluator_types_output_path)
diff --git a/packages/uipath/src/uipath/eval/evaluators/tool_call_args_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/tool_call_args_evaluator.py
new file mode 100644
index 000000000..2703e3c76
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/tool_call_args_evaluator.py
@@ -0,0 +1,82 @@
+"""Tool call order evaluator for validating correct sequence of tool calls."""
+
+from .._helpers.evaluators_helpers import (
+    extract_tool_calls,
+    tool_calls_args_score,
+)
+from ..models import AgentExecution, EvaluationResult, NumericEvaluationResult, ToolCall
+from ..models.models import EvaluatorType
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+
+
+class ToolCallArgsEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the tool call order evaluator."""
+
+    # TODO: name field of ToolCall needs to be validated such that it contains only the tools available
+    tool_calls: list[ToolCall]
+
+
+class ToolCallArgsEvaluatorConfig(BaseEvaluatorConfig[ToolCallArgsEvaluationCriteria]):
+    """Configuration for the tool call count evaluator."""
+
+    name: str = "ToolCallArgsEvaluator"
+    strict: bool = False
+    subset: bool = False
+
+
+class ToolCallArgsEvaluatorJustification(BaseEvaluatorJustification):
+    """Justification for the tool call args evaluator."""
+
+    explained_tool_calls_args: dict[str, str]
+
+
+class ToolCallArgsEvaluator(
+    BaseEvaluator[
+        ToolCallArgsEvaluationCriteria,
+        ToolCallArgsEvaluatorConfig,
+        ToolCallArgsEvaluatorJustification,
+    ]
+):
+    """Evaluator that checks if the tool calls are in the correct order.
+
+    This evaluator returns True if the tool calls are in the correct order, and False otherwise.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.TOOL_CALL_ARGS.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: ToolCallArgsEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate if the tool calls are in the correct order.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The final output of the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+        Returns:
+            EvaluationResult: Boolean result indicating correct tool call order (True/False)
+        """
+        tool_calls_order = extract_tool_calls(agent_execution.agent_trace)
+        score, justification = tool_calls_args_score(
+            tool_calls_order,
+            evaluation_criteria.tool_calls,
+            self.evaluator_config.strict,
+            self.evaluator_config.subset,
+        )
+        validated_justification = self.validate_justification(justification)
+        return NumericEvaluationResult(
+            score=score,
+            details=validated_justification,
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators/tool_call_count_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/tool_call_count_evaluator.py
new file mode 100644
index 000000000..4df237e7e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/tool_call_count_evaluator.py
@@ -0,0 +1,86 @@
+"""Tool call count evaluator for validating expected tool usage patterns."""
+
+from .._helpers.evaluators_helpers import (
+    count_tool_calls_by_name_and_id,
+    extract_tool_calls,
+    tool_calls_count_score,
+)
+from ..models import AgentExecution, EvaluationResult, NumericEvaluationResult
+from ..models.models import EvaluatorType
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+
+
+class ToolCallCountEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the tool call count evaluator."""
+
+    # TODO: str field needs to be validated against some criteria that allows ">x", "<x", ">=x", "<=x", "x"
+    tool_calls_count: dict[str, tuple[str, int]]
+
+
+class ToolCallCountEvaluatorConfig(
+    BaseEvaluatorConfig[ToolCallCountEvaluationCriteria]
+):
+    """Configuration for the tool call count evaluator."""
+
+    name: str = "ToolCallCountEvaluator"
+    strict: bool = False
+
+
+class ToolCallCountEvaluatorJustification(BaseEvaluatorJustification):
+    """Justification for the tool call count evaluator."""
+
+    explained_tool_calls_count: dict[str, str]
+
+
+class ToolCallCountEvaluator(
+    BaseEvaluator[
+        ToolCallCountEvaluationCriteria,
+        ToolCallCountEvaluatorConfig,
+        ToolCallCountEvaluatorJustification,
+    ]
+):
+    """Evaluator that checks if the tool calls match the expected count.
+
+    This evaluator returns a score based on how well the actual tool call counts
+    match the expected counts specified in the criteria.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.TOOL_CALL_COUNT.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: ToolCallCountEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate if the tool calls are in the correct order.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The final output of the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+        Returns:
+            EvaluationResult: Boolean result indicating correct tool call order (True/False)
+        """
+        tool_calls_count = count_tool_calls_by_name_and_id(
+            extract_tool_calls(agent_execution.agent_trace, include_args=False)
+        )
+        score, justification = tool_calls_count_score(
+            tool_calls_count,
+            evaluation_criteria.tool_calls_count,
+            self.evaluator_config.strict,
+        )
+        validated_justification = self.validate_justification(justification)
+        return NumericEvaluationResult(
+            score=score,
+            details=validated_justification,
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators/tool_call_order_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/tool_call_order_evaluator.py
new file mode 100644
index 000000000..4676750d3
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/tool_call_order_evaluator.py
@@ -0,0 +1,84 @@
+"""Tool call order evaluator for validating correct sequence of tool calls."""
+
+from .._helpers.evaluators_helpers import (
+    extract_tool_calls,
+    tool_calls_order_score_with_ids,
+)
+from ..models import AgentExecution, EvaluationResult, NumericEvaluationResult
+from ..models.models import EvaluatorType
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+
+
+class ToolCallOrderEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the tool call order evaluator."""
+
+    # TODO: str field needs to be validated such that it contains only the tools available
+    tool_calls_order: list[str]
+
+
+class ToolCallOrderEvaluatorConfig(
+    BaseEvaluatorConfig[ToolCallOrderEvaluationCriteria]
+):
+    """Configuration for the tool call count evaluator."""
+
+    name: str = "ToolCallOrderEvaluator"
+    strict: bool = False
+
+
+class ToolCallOrderEvaluatorJustification(BaseEvaluatorJustification):
+    """Justification for the tool call order evaluator."""
+
+    lcs: list[str]
+
+
+class ToolCallOrderEvaluator(
+    BaseEvaluator[
+        ToolCallOrderEvaluationCriteria,
+        ToolCallOrderEvaluatorConfig,
+        ToolCallOrderEvaluatorJustification,
+    ]
+):
+    """Evaluator that checks if the tool calls are in the correct order.
+
+    This evaluator returns True if the tool calls are in the correct order, and False otherwise.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.TOOL_CALL_ORDER.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: ToolCallOrderEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate if the tool calls are in the correct order.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The final output of the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+        Returns:
+            EvaluationResult: Boolean result indicating correct tool call order (True/False)
+        """
+        actual_calls = extract_tool_calls(
+            agent_execution.agent_trace, include_args=False
+        )
+        score, justification = tool_calls_order_score_with_ids(
+            actual_calls,
+            evaluation_criteria.tool_calls_order,
+            self.evaluator_config.strict,
+        )
+        validated_justification = self.validate_justification(justification)
+        return NumericEvaluationResult(
+            score=score,
+            details=validated_justification,
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators/tool_call_output_evaluator.py b/packages/uipath/src/uipath/eval/evaluators/tool_call_output_evaluator.py
new file mode 100644
index 000000000..fff139daf
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators/tool_call_output_evaluator.py
@@ -0,0 +1,87 @@
+"""Tool call order evaluator for validating correct sequence of tool calls."""
+
+from .._helpers.evaluators_helpers import (
+    extract_tool_calls_outputs,
+    tool_calls_output_score,
+)
+from ..models import (
+    AgentExecution,
+    EvaluationResult,
+    NumericEvaluationResult,
+    ToolOutput,
+)
+from ..models.models import EvaluatorType
+from .base_evaluator import (
+    BaseEvaluationCriteria,
+    BaseEvaluator,
+    BaseEvaluatorConfig,
+    BaseEvaluatorJustification,
+)
+
+
+class ToolCallOutputEvaluationCriteria(BaseEvaluationCriteria):
+    """Evaluation criteria for the tool call order evaluator."""
+
+    # TODO: name field of ToolCall needs to be validated such that it contains only the tools available
+    tool_outputs: list[ToolOutput]
+
+
+class ToolCallOutputEvaluatorConfig(
+    BaseEvaluatorConfig[ToolCallOutputEvaluationCriteria]
+):
+    """Configuration for the tool call count evaluator."""
+
+    name: str = "ToolCallOutputEvaluator"
+    strict: bool = False
+
+
+class ToolCallOutputEvaluatorJustification(BaseEvaluatorJustification):
+    """Justification for the tool call output evaluator."""
+
+    explained_tool_calls_outputs: dict[str, str]
+
+
+class ToolCallOutputEvaluator(
+    BaseEvaluator[
+        ToolCallOutputEvaluationCriteria,
+        ToolCallOutputEvaluatorConfig,
+        ToolCallOutputEvaluatorJustification,
+    ]
+):
+    """Evaluator that checks if the tool calls are in the correct order.
+
+    This evaluator returns True if the tool calls are in the correct order, and False otherwise.
+    """
+
+    @classmethod
+    def get_evaluator_id(cls) -> str:
+        """Get the evaluator id."""
+        return EvaluatorType.TOOL_CALL_OUTPUT.value
+
+    async def evaluate(
+        self,
+        agent_execution: AgentExecution,
+        evaluation_criteria: ToolCallOutputEvaluationCriteria,
+    ) -> EvaluationResult:
+        """Evaluate if the tool calls are in the correct order.
+
+        Args:
+            agent_execution: The execution details containing:
+                - agent_input: The input received by the agent
+                - agent_output: The final output of the agent
+                - agent_trace: The execution spans to use for the evaluation
+            evaluation_criteria: The criteria to evaluate
+        Returns:
+            EvaluationResult: Boolean result indicating correct tool call order (True/False)
+        """
+        tool_calls_outputs = extract_tool_calls_outputs(agent_execution.agent_trace)
+        score, justification = tool_calls_output_score(
+            tool_calls_outputs,
+            evaluation_criteria.tool_outputs,
+            self.evaluator_config.strict,
+        )
+        validated_justification = self.validate_justification(justification)
+        return NumericEvaluationResult(
+            score=score,
+            details=validated_justification,
+        )
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ContainsEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ContainsEvaluator.json
new file mode 100644
index 000000000..9db709f59
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ContainsEvaluator.json
@@ -0,0 +1,79 @@
+{
+  "evaluatorTypeId": "uipath-contains",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "ContainsEvaluationCriteria": {
+        "description": "Evaluation criteria for the contains evaluator.",
+        "properties": {
+          "search_text": {
+            "title": "Search Text",
+            "type": "string"
+          }
+        },
+        "required": [
+          "search_text"
+        ],
+        "title": "ContainsEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the contains evaluator.",
+    "properties": {
+      "name": {
+        "default": "ContainsEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/ContainsEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "target_output_key": {
+        "default": "*",
+        "description": "Key to extract output from agent execution",
+        "title": "Target Output Key",
+        "type": "string"
+      },
+      "case_sensitive": {
+        "default": false,
+        "title": "Case Sensitive",
+        "type": "boolean"
+      },
+      "negated": {
+        "default": false,
+        "title": "Negated",
+        "type": "boolean"
+      }
+    },
+    "title": "ContainsEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for the contains evaluator.",
+    "properties": {
+      "search_text": {
+        "title": "Search Text",
+        "type": "string"
+      }
+    },
+    "required": [
+      "search_text"
+    ],
+    "title": "ContainsEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {}
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ExactMatchEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ExactMatchEvaluator.json
new file mode 100644
index 000000000..866b06416
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ExactMatchEvaluator.json
@@ -0,0 +1,95 @@
+{
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "OutputEvaluationCriteria": {
+        "description": "Base class for all output evaluation criteria.",
+        "properties": {
+          "expected_output": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "string"
+              }
+            ],
+            "title": "Expected Output"
+          }
+        },
+        "required": [
+          "expected_output"
+        ],
+        "title": "OutputEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the exact match evaluator.",
+    "properties": {
+      "name": {
+        "default": "ExactMatchEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/OutputEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "target_output_key": {
+        "default": "*",
+        "description": "Key to extract output from agent execution",
+        "title": "Target Output Key",
+        "type": "string"
+      },
+      "case_sensitive": {
+        "default": false,
+        "title": "Case Sensitive",
+        "type": "boolean"
+      },
+      "negated": {
+        "default": false,
+        "title": "Negated",
+        "type": "boolean"
+      }
+    },
+    "title": "ExactMatchEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Base class for all output evaluation criteria.",
+    "properties": {
+      "expected_output": {
+        "anyOf": [
+          {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          {
+            "type": "string"
+          }
+        ],
+        "title": "Expected Output"
+      }
+    },
+    "required": [
+      "expected_output"
+    ],
+    "title": "OutputEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {}
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/JsonSimilarityEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/JsonSimilarityEvaluator.json
new file mode 100644
index 000000000..ef17bf083
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/JsonSimilarityEvaluator.json
@@ -0,0 +1,87 @@
+{
+  "evaluatorTypeId": "uipath-json-similarity",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "OutputEvaluationCriteria": {
+        "description": "Base class for all output evaluation criteria.",
+        "properties": {
+          "expected_output": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "string"
+              }
+            ],
+            "title": "Expected Output"
+          }
+        },
+        "required": [
+          "expected_output"
+        ],
+        "title": "OutputEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the json similarity evaluator.",
+    "properties": {
+      "name": {
+        "default": "JsonSimilarityEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/OutputEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "target_output_key": {
+        "default": "*",
+        "description": "Key to extract output from agent execution",
+        "title": "Target Output Key",
+        "type": "string"
+      }
+    },
+    "title": "JsonSimilarityEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Base class for all output evaluation criteria.",
+    "properties": {
+      "expected_output": {
+        "anyOf": [
+          {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          {
+            "type": "string"
+          }
+        ],
+        "title": "Expected Output"
+      }
+    },
+    "required": [
+      "expected_output"
+    ],
+    "title": "OutputEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "type": "string"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeOutputEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeOutputEvaluator.json
new file mode 100644
index 000000000..06f731c1f
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeOutputEvaluator.json
@@ -0,0 +1,114 @@
+{
+  "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "OutputEvaluationCriteria": {
+        "description": "Base class for all output evaluation criteria.",
+        "properties": {
+          "expected_output": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "string"
+              }
+            ],
+            "title": "Expected Output"
+          }
+        },
+        "required": [
+          "expected_output"
+        ],
+        "title": "OutputEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the LLM judge output evaluator.",
+    "properties": {
+      "name": {
+        "default": "LLMJudgeOutputEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/OutputEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "prompt": {
+        "default": "As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nExpectedOutput:\n{{ExpectedOutput}}\n----\nActualOutput:\n{{ActualOutput}}",
+        "title": "Prompt",
+        "type": "string"
+      },
+      "model": {
+        "default": "",
+        "title": "Model",
+        "type": "string"
+      },
+      "temperature": {
+        "default": 0.0,
+        "title": "Temperature",
+        "type": "number"
+      },
+      "max_tokens": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "title": "Max Tokens"
+      },
+      "target_output_key": {
+        "default": "*",
+        "description": "Key to extract output from agent execution",
+        "title": "Target Output Key",
+        "type": "string"
+      }
+    },
+    "title": "LLMJudgeOutputEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Base class for all output evaluation criteria.",
+    "properties": {
+      "expected_output": {
+        "anyOf": [
+          {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          {
+            "type": "string"
+          }
+        ],
+        "title": "Expected Output"
+      }
+    },
+    "required": [
+      "expected_output"
+    ],
+    "title": "OutputEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "type": "string"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeStrictJSONSimilarityOutputEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeStrictJSONSimilarityOutputEvaluator.json
new file mode 100644
index 000000000..0fffbbe81
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeStrictJSONSimilarityOutputEvaluator.json
@@ -0,0 +1,114 @@
+{
+  "evaluatorTypeId": "uipath-llm-judge-output-strict-json-similarity",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "OutputEvaluationCriteria": {
+        "description": "Base class for all output evaluation criteria.",
+        "properties": {
+          "expected_output": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "string"
+              }
+            ],
+            "title": "Expected Output"
+          }
+        },
+        "required": [
+          "expected_output"
+        ],
+        "title": "OutputEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the LLM judge strict JSON similarity output evaluator.",
+    "properties": {
+      "name": {
+        "default": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/OutputEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "prompt": {
+        "default": "ExpectedOutput (ground truth):\n{{ExpectedOutput}}\n\nActualOutput (model answer):\n{{ActualOutput}}",
+        "title": "Prompt",
+        "type": "string"
+      },
+      "model": {
+        "default": "",
+        "title": "Model",
+        "type": "string"
+      },
+      "temperature": {
+        "default": 0.0,
+        "title": "Temperature",
+        "type": "number"
+      },
+      "max_tokens": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "title": "Max Tokens"
+      },
+      "target_output_key": {
+        "default": "*",
+        "description": "Key to extract output from agent execution",
+        "title": "Target Output Key",
+        "type": "string"
+      }
+    },
+    "title": "LLMJudgeStrictJSONSimilarityOutputEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Base class for all output evaluation criteria.",
+    "properties": {
+      "expected_output": {
+        "anyOf": [
+          {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          {
+            "type": "string"
+          }
+        ],
+        "title": "Expected Output"
+      }
+    },
+    "required": [
+      "expected_output"
+    ],
+    "title": "OutputEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "type": "string"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectoryEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectoryEvaluator.json
new file mode 100644
index 000000000..8695fb738
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectoryEvaluator.json
@@ -0,0 +1,92 @@
+{
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "TrajectoryEvaluationCriteria": {
+        "description": "Evaluation criteria for trajectory-based evaluations.",
+        "properties": {
+          "expected_agent_behavior": {
+            "title": "Expected Agent Behavior",
+            "type": "string"
+          }
+        },
+        "required": [
+          "expected_agent_behavior"
+        ],
+        "title": "TrajectoryEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the llm judge trajectory evaluator.",
+    "properties": {
+      "name": {
+        "default": "LLMJudgeTrajectoryEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/TrajectoryEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "prompt": {
+        "default": "As an expert evaluator, determine how well the agent performed on a scale of 0-100. Focus on whether the agent's actions and outputs matched the expected behavior, while allowing for alternative valid expressions and reasonable variations in language. Maintain high standards for accuracy and completeness. Provide your score with a brief and clear justification explaining your reasoning.\n----\nAgentInput:\n{{UserOrSyntheticInput}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+        "title": "Prompt",
+        "type": "string"
+      },
+      "model": {
+        "default": "",
+        "title": "Model",
+        "type": "string"
+      },
+      "temperature": {
+        "default": 0.0,
+        "title": "Temperature",
+        "type": "number"
+      },
+      "max_tokens": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "title": "Max Tokens"
+      }
+    },
+    "title": "LLMJudgeTrajectoryEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for trajectory-based evaluations.",
+    "properties": {
+      "expected_agent_behavior": {
+        "title": "Expected Agent Behavior",
+        "type": "string"
+      }
+    },
+    "required": [
+      "expected_agent_behavior"
+    ],
+    "title": "TrajectoryEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "type": "string"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectorySimulationEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectorySimulationEvaluator.json
new file mode 100644
index 000000000..006e24202
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/LLMJudgeTrajectorySimulationEvaluator.json
@@ -0,0 +1,92 @@
+{
+  "evaluatorTypeId": "uipath-llm-judge-trajectory-simulation",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "TrajectoryEvaluationCriteria": {
+        "description": "Evaluation criteria for trajectory-based evaluations.",
+        "properties": {
+          "expected_agent_behavior": {
+            "title": "Expected Agent Behavior",
+            "type": "string"
+          }
+        },
+        "required": [
+          "expected_agent_behavior"
+        ],
+        "title": "TrajectoryEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the llm judge simulation trajectory evaluator.",
+    "properties": {
+      "name": {
+        "default": "LLMJudgeTrajectorySimulationEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/TrajectoryEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "prompt": {
+        "default": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nAgentInput:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+        "title": "Prompt",
+        "type": "string"
+      },
+      "model": {
+        "default": "",
+        "title": "Model",
+        "type": "string"
+      },
+      "temperature": {
+        "default": 0.0,
+        "title": "Temperature",
+        "type": "number"
+      },
+      "max_tokens": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "title": "Max Tokens"
+      }
+    },
+    "title": "LLMJudgeTrajectorySimulationEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for trajectory-based evaluations.",
+    "properties": {
+      "expected_agent_behavior": {
+        "title": "Expected Agent Behavior",
+        "type": "string"
+      }
+    },
+    "required": [
+      "expected_agent_behavior"
+    ],
+    "title": "TrajectoryEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "type": "string"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ToolCallArgsEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallArgsEvaluator.json
new file mode 100644
index 000000000..645ada479
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallArgsEvaluator.json
@@ -0,0 +1,137 @@
+{
+  "evaluatorTypeId": "uipath-tool-call-args",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "ToolCall": {
+        "description": "Represents a tool call with its arguments.",
+        "properties": {
+          "name": {
+            "title": "Name",
+            "type": "string"
+          },
+          "args": {
+            "additionalProperties": true,
+            "title": "Args",
+            "type": "object"
+          }
+        },
+        "required": [
+          "name",
+          "args"
+        ],
+        "title": "ToolCall",
+        "type": "object"
+      },
+      "ToolCallArgsEvaluationCriteria": {
+        "description": "Evaluation criteria for the tool call order evaluator.",
+        "properties": {
+          "tool_calls": {
+            "items": {
+              "$ref": "#/$defs/ToolCall"
+            },
+            "title": "Tool Calls",
+            "type": "array"
+          }
+        },
+        "required": [
+          "tool_calls"
+        ],
+        "title": "ToolCallArgsEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the tool call count evaluator.",
+    "properties": {
+      "name": {
+        "default": "ToolCallArgsEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/ToolCallArgsEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "strict": {
+        "default": false,
+        "title": "Strict",
+        "type": "boolean"
+      },
+      "subset": {
+        "default": false,
+        "title": "Subset",
+        "type": "boolean"
+      }
+    },
+    "title": "ToolCallArgsEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "$defs": {
+      "ToolCall": {
+        "description": "Represents a tool call with its arguments.",
+        "properties": {
+          "name": {
+            "title": "Name",
+            "type": "string"
+          },
+          "args": {
+            "additionalProperties": true,
+            "title": "Args",
+            "type": "object"
+          }
+        },
+        "required": [
+          "name",
+          "args"
+        ],
+        "title": "ToolCall",
+        "type": "object"
+      }
+    },
+    "description": "Evaluation criteria for the tool call order evaluator.",
+    "properties": {
+      "tool_calls": {
+        "items": {
+          "$ref": "#/$defs/ToolCall"
+        },
+        "title": "Tool Calls",
+        "type": "array"
+      }
+    },
+    "required": [
+      "tool_calls"
+    ],
+    "title": "ToolCallArgsEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "description": "Justification for the tool call args evaluator.",
+    "properties": {
+      "explained_tool_calls_args": {
+        "additionalProperties": {
+          "type": "string"
+        },
+        "title": "Explained Tool Calls Args",
+        "type": "object"
+      }
+    },
+    "required": [
+      "explained_tool_calls_args"
+    ],
+    "title": "ToolCallArgsEvaluatorJustification",
+    "type": "object"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ToolCallCountEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallCountEvaluator.json
new file mode 100644
index 000000000..56b56d543
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallCountEvaluator.json
@@ -0,0 +1,110 @@
+{
+  "evaluatorTypeId": "uipath-tool-call-count",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "ToolCallCountEvaluationCriteria": {
+        "description": "Evaluation criteria for the tool call count evaluator.",
+        "properties": {
+          "tool_calls_count": {
+            "additionalProperties": {
+              "maxItems": 2,
+              "minItems": 2,
+              "prefixItems": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ],
+              "type": "array"
+            },
+            "title": "Tool Calls Count",
+            "type": "object"
+          }
+        },
+        "required": [
+          "tool_calls_count"
+        ],
+        "title": "ToolCallCountEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the tool call count evaluator.",
+    "properties": {
+      "name": {
+        "default": "ToolCallCountEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/ToolCallCountEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "strict": {
+        "default": false,
+        "title": "Strict",
+        "type": "boolean"
+      }
+    },
+    "title": "ToolCallCountEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for the tool call count evaluator.",
+    "properties": {
+      "tool_calls_count": {
+        "additionalProperties": {
+          "maxItems": 2,
+          "minItems": 2,
+          "prefixItems": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "integer"
+            }
+          ],
+          "type": "array"
+        },
+        "title": "Tool Calls Count",
+        "type": "object"
+      }
+    },
+    "required": [
+      "tool_calls_count"
+    ],
+    "title": "ToolCallCountEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "description": "Justification for the tool call count evaluator.",
+    "properties": {
+      "explained_tool_calls_count": {
+        "additionalProperties": {
+          "type": "string"
+        },
+        "title": "Explained Tool Calls Count",
+        "type": "object"
+      }
+    },
+    "required": [
+      "explained_tool_calls_count"
+    ],
+    "title": "ToolCallCountEvaluatorJustification",
+    "type": "object"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOrderEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOrderEvaluator.json
new file mode 100644
index 000000000..568890eb1
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOrderEvaluator.json
@@ -0,0 +1,106 @@
+{
+  "evaluatorTypeId": "uipath-tool-call-order",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "ToolCallOrderEvaluationCriteria": {
+        "description": "Evaluation criteria for the tool call order evaluator.",
+        "properties": {
+          "tool_calls_order": {
+            "items": {
+              "type": "string"
+            },
+            "title": "Tool Calls Order",
+            "type": "array"
+          }
+        },
+        "required": [
+          "tool_calls_order"
+        ],
+        "title": "ToolCallOrderEvaluationCriteria",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the tool call count evaluator.",
+    "properties": {
+      "name": {
+        "default": "ToolCallOrderEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/ToolCallOrderEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "strict": {
+        "default": false,
+        "title": "Strict",
+        "type": "boolean"
+      }
+    },
+    "title": "ToolCallOrderEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "description": "Evaluation criteria for the tool call order evaluator.",
+    "properties": {
+      "tool_calls_order": {
+        "items": {
+          "type": "string"
+        },
+        "title": "Tool Calls Order",
+        "type": "array"
+      }
+    },
+    "required": [
+      "tool_calls_order"
+    ],
+    "title": "ToolCallOrderEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "description": "Justification for the tool call order evaluator.",
+    "properties": {
+      "actual_tool_calls_order": {
+        "items": {
+          "type": "string"
+        },
+        "title": "Actual Tool Calls Order",
+        "type": "array"
+      },
+      "expected_tool_calls_order": {
+        "items": {
+          "type": "string"
+        },
+        "title": "Expected Tool Calls Order",
+        "type": "array"
+      },
+      "lcs": {
+        "items": {
+          "type": "string"
+        },
+        "title": "Lcs",
+        "type": "array"
+      }
+    },
+    "required": [
+      "actual_tool_calls_order",
+      "expected_tool_calls_order",
+      "lcs"
+    ],
+    "title": "ToolCallOrderEvaluatorJustification",
+    "type": "object"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOutputEvaluator.json b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOutputEvaluator.json
new file mode 100644
index 000000000..73455592a
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/ToolCallOutputEvaluator.json
@@ -0,0 +1,130 @@
+{
+  "evaluatorTypeId": "uipath-tool-call-output",
+  "evaluatorConfigSchema": {
+    "$defs": {
+      "ToolCallOutputEvaluationCriteria": {
+        "description": "Evaluation criteria for the tool call order evaluator.",
+        "properties": {
+          "tool_outputs": {
+            "items": {
+              "$ref": "#/$defs/ToolOutput"
+            },
+            "title": "Tool Outputs",
+            "type": "array"
+          }
+        },
+        "required": [
+          "tool_outputs"
+        ],
+        "title": "ToolCallOutputEvaluationCriteria",
+        "type": "object"
+      },
+      "ToolOutput": {
+        "description": "Represents a tool output with its output.",
+        "properties": {
+          "name": {
+            "title": "Name",
+            "type": "string"
+          },
+          "output": {
+            "title": "Output",
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "output"
+        ],
+        "title": "ToolOutput",
+        "type": "object"
+      }
+    },
+    "description": "Configuration for the tool call count evaluator.",
+    "properties": {
+      "name": {
+        "default": "ToolCallOutputEvaluator",
+        "title": "Name",
+        "type": "string"
+      },
+      "description": {
+        "default": "",
+        "description": "The description of the evaluator",
+        "title": "Description",
+        "type": "string"
+      },
+      "default_evaluation_criteria": {
+        "anyOf": [
+          {
+            "$ref": "#/$defs/ToolCallOutputEvaluationCriteria"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null
+      },
+      "strict": {
+        "default": false,
+        "title": "Strict",
+        "type": "boolean"
+      }
+    },
+    "title": "ToolCallOutputEvaluatorConfig",
+    "type": "object"
+  },
+  "evaluationCriteriaSchema": {
+    "$defs": {
+      "ToolOutput": {
+        "description": "Represents a tool output with its output.",
+        "properties": {
+          "name": {
+            "title": "Name",
+            "type": "string"
+          },
+          "output": {
+            "title": "Output",
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "output"
+        ],
+        "title": "ToolOutput",
+        "type": "object"
+      }
+    },
+    "description": "Evaluation criteria for the tool call order evaluator.",
+    "properties": {
+      "tool_outputs": {
+        "items": {
+          "$ref": "#/$defs/ToolOutput"
+        },
+        "title": "Tool Outputs",
+        "type": "array"
+      }
+    },
+    "required": [
+      "tool_outputs"
+    ],
+    "title": "ToolCallOutputEvaluationCriteria",
+    "type": "object"
+  },
+  "justificationSchema": {
+    "description": "Justification for the tool call output evaluator.",
+    "properties": {
+      "explained_tool_calls_outputs": {
+        "additionalProperties": {
+          "type": "string"
+        },
+        "title": "Explained Tool Calls Outputs",
+        "type": "object"
+      }
+    },
+    "required": [
+      "explained_tool_calls_outputs"
+    ],
+    "title": "ToolCallOutputEvaluatorJustification",
+    "type": "object"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/src/uipath/eval/evaluators_types/generate_types.py b/packages/uipath/src/uipath/eval/evaluators_types/generate_types.py
new file mode 100644
index 000000000..22fb38d65
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/evaluators_types/generate_types.py
@@ -0,0 +1,31 @@
+"""Generate the JSON types for all evaluators."""
+
+import json
+import os
+from typing import Any
+
+from ..evaluators import EVALUATORS
+
+
+def generate_evaluator_json_types(
+    write_to_file: bool = False, indent: int | str | None = None
+) -> dict[str, Any]:
+    """Generate the JSON types for all evaluators."""
+    OUTPUT_PATH = os.path.dirname(os.path.abspath(__file__))
+
+    os.makedirs(OUTPUT_PATH, exist_ok=True)
+
+    evaluator_json_types = {}
+    for evaluator in EVALUATORS:
+        evaluator_json_type = evaluator.generate_json_type()
+        evaluator_json_types[evaluator.__name__] = evaluator_json_type
+        if write_to_file:
+            with open(
+                os.path.join(OUTPUT_PATH, f"{evaluator.__name__}.json"), "w"
+            ) as f:
+                json.dump(evaluator_json_type, f, indent=indent)
+    return evaluator_json_types
+
+
+if __name__ == "__main__":
+    generate_evaluator_json_types(write_to_file=True, indent=2)
diff --git a/packages/uipath/src/uipath/eval/helpers.py b/packages/uipath/src/uipath/eval/helpers.py
new file mode 100644
index 000000000..8405e4a7a
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/helpers.py
@@ -0,0 +1,302 @@
+"""Helper functions for evaluation commands, including loading and parsing evaluation sets and evaluators."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+from .evaluators.base_evaluator import GenericBaseEvaluator
+from .evaluators.evaluator_factory import EvaluatorFactory
+from .mocks._types import InputMockingStrategy, LLMMockingStrategy
+from .models._conversational_utils import UiPathLegacyEvalChatMessagesMapper
+from .models.evaluation_set import (
+    EvaluationItem,
+    EvaluationSet,
+    LegacyEvaluationItem,
+    LegacyEvaluationSet,
+)
+
+logger = logging.getLogger(__name__)
+
+EVAL_SETS_DIRECTORY_NAME = "evaluations/eval-sets"
+
+
+def _apply_file_overrides_to_conversational_inputs(
+    conversational_inputs: Any,
+    overrides: dict[str, Any],
+) -> None:
+    """Apply file overrides to conversational input attachments before mapper conversion.
+
+    Extracts file objects from override values (single dict or array), matches them
+    to existing attachments by FullName, and replaces attachment fields in-place.
+    No-op if there are no file overrides or no matching attachments.
+    """
+    if not overrides:
+        return
+
+    file_overrides: list[dict[str, Any]] = []
+    for value in overrides.values():
+        if isinstance(value, list):
+            file_overrides.extend(f for f in value if isinstance(f, dict) and "ID" in f)
+        elif isinstance(value, dict) and "ID" in value:
+            file_overrides.append(value)
+
+    if not file_overrides:
+        return
+
+    override_by_name = {f["FullName"]: f for f in file_overrides if "FullName" in f}
+
+    def _override_attachments(attachments: list[Any] | None) -> None:
+        if not attachments:
+            return
+        for attachment in attachments:
+            override = override_by_name.get(attachment.full_name)
+            if override:
+                attachment.id = override["ID"]
+                if "FullName" in override:
+                    attachment.full_name = override["FullName"]
+                if "MimeType" in override:
+                    attachment.mime_type = override["MimeType"]
+
+    _override_attachments(conversational_inputs.current_user_prompt.attachments)
+
+    for exchange in conversational_inputs.conversation_history:
+        for message in exchange:
+            if hasattr(message, "attachments"):
+                _override_attachments(message.attachments)
+
+
+def discriminate_eval_set(data: dict[str, Any]) -> EvaluationSet | LegacyEvaluationSet:
+    """Discriminate and parse evaluation set based on version field.
+
+    Uses explicit version checking instead of Pydantic's smart union matching
+    to avoid incorrect type selection when both types have matching fields.
+
+    Args:
+        data: Dictionary containing evaluation set data
+
+    Returns:
+        Either EvaluationSet (for version 1.0) or LegacyEvaluationSet
+    """
+    version = data.get("version")
+    if isinstance(version, (int, float, str)) and float(version) >= 1:
+        return EvaluationSet.model_validate(data)
+    return LegacyEvaluationSet.model_validate(data)
+
+
+class EvalHelpers:
+    """Helper functions for evaluation commands, including loading and parsing evaluation sets and evaluators."""
+
+    @staticmethod
+    def load_eval_set(
+        eval_set_path: str,
+        eval_ids: list[str] | None = None,
+        input_overrides: dict[str, Any] | None = None,
+    ) -> tuple[EvaluationSet, str]:
+        """Load the evaluation set from file.
+
+        Args:
+            eval_set_path: Path to the evaluation set file
+            eval_ids: Optional list of evaluation IDs to filter
+            input_overrides: Optional input field overrides per evaluation ID.
+                For conversational agents, file overrides are applied to attachments
+                before the legacy-to-messages conversion so that overridden IDs
+                are baked into the messages before mapping.
+
+        Returns:
+            Tuple of (EvaluationSet, resolved_path)
+        """
+        # If the file doesn't exist at the given path, try looking in {EVAL_SETS_DIRECTORY_NAME}/
+        resolved_path = eval_set_path
+        if not Path(eval_set_path).exists():
+            # Check if it's just a filename, then search in {EVAL_SETS_DIRECTORY_NAME}/
+            if Path(eval_set_path).name == eval_set_path:
+                eval_sets_path = Path(EVAL_SETS_DIRECTORY_NAME) / eval_set_path
+                if eval_sets_path.exists():
+                    resolved_path = str(eval_sets_path)
+
+        try:
+            with open(resolved_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except FileNotFoundError as e:
+            raise ValueError(
+                f"Evaluation set file not found: '{eval_set_path}'. "
+                f"Searched in current directory and {EVAL_SETS_DIRECTORY_NAME}/ directory."
+            ) from e
+        except json.JSONDecodeError as e:
+            raise ValueError(
+                f"Invalid JSON in evaluation set file '{resolved_path}': {str(e)}. "
+                f"Please check the file for syntax errors."
+            ) from e
+
+        try:
+            eval_set = discriminate_eval_set(data)
+            if isinstance(eval_set, LegacyEvaluationSet):
+
+                def migrate_evaluation_item(
+                    evaluation: LegacyEvaluationItem, evaluators: list[str]
+                ) -> EvaluationItem:
+                    mocking_strategy = None
+                    input_mocking_strategy = None
+                    if (
+                        evaluation.simulate_input
+                        and evaluation.input_generation_instructions
+                    ):
+                        input_mocking_strategy = InputMockingStrategy(
+                            prompt=evaluation.input_generation_instructions,
+                        )
+                    if evaluation.simulate_tools:
+                        mocking_strategy = LLMMockingStrategy(
+                            prompt=evaluation.simulation_instructions or "",
+                            tools_to_simulate=evaluation.tools_to_simulate or [],
+                        )
+
+                    if evaluation.conversational_inputs:
+                        overrides_for_eval = (
+                            input_overrides.get(evaluation.id, {})
+                            if input_overrides
+                            else {}
+                        )
+                        _apply_file_overrides_to_conversational_inputs(
+                            evaluation.conversational_inputs,
+                            overrides_for_eval,
+                        )
+
+                        conversational_messages_input = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+                            evaluation.conversational_inputs
+                        )
+                        evaluation.inputs["messages"] = [
+                            message.model_dump(by_alias=True, exclude_none=True)
+                            for message in conversational_messages_input
+                        ]
+
+                    if evaluation.conversational_expected_output:
+                        conversational_messages_expected_output = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+                            evaluation.conversational_expected_output
+                        )
+                        evaluation.expected_output[
+                            "uipath__agent_response_messages"
+                        ] = [
+                            message.model_dump(by_alias=True, exclude_none=True)
+                            for message in conversational_messages_expected_output
+                        ]
+
+                    return EvaluationItem.model_validate(
+                        {
+                            "id": evaluation.id,
+                            "name": evaluation.name,
+                            "inputs": evaluation.inputs,
+                            "expectedAgentBehavior": evaluation.expected_agent_behavior,
+                            "mockingStrategy": mocking_strategy,
+                            "inputMockingStrategy": input_mocking_strategy,
+                            "evaluationCriterias": {
+                                k: {
+                                    "expectedOutput": evaluation.expected_output,
+                                    "expectedAgentBehavior": evaluation.expected_agent_behavior,
+                                }
+                                for k in evaluators
+                            },
+                        }
+                    )
+
+                eval_set = EvaluationSet(
+                    id=eval_set.id,
+                    name=eval_set.name,
+                    evaluator_refs=eval_set.evaluator_refs,
+                    evaluations=[
+                        migrate_evaluation_item(evaluation, eval_set.evaluator_refs)
+                        for evaluation in eval_set.evaluations
+                    ],
+                    model_settings=eval_set.model_settings,
+                )
+        except ValidationError as e:
+            raise ValueError(
+                f"Invalid evaluation set format in '{resolved_path}': {str(e)}. "
+                f"Please verify the evaluation set structure."
+            ) from e
+        if eval_ids:
+            eval_set.extract_selected_evals(eval_ids)
+        return eval_set, resolved_path
+
+    @staticmethod
+    async def load_evaluators(
+        eval_set_path: str,
+        evaluation_set: EvaluationSet,
+        agent_model: str | None = None,
+    ) -> list[GenericBaseEvaluator[Any, Any, Any]]:
+        """Load evaluators referenced by the evaluation set."""
+        evaluators = []
+        if evaluation_set is None:
+            raise ValueError("eval_set cannot be None")
+        evaluators_dir = Path(eval_set_path).parent.parent / "evaluators"
+
+        # If evaluatorConfigs is specified, use that (new field with weights)
+        # Otherwise, fall back to evaluatorRefs (old field without weights)
+        if (
+            hasattr(evaluation_set, "evaluator_configs")
+            and evaluation_set.evaluator_configs
+        ):
+            # Use new evaluatorConfigs field - supports weights
+            evaluator_ref_ids = {ref.ref for ref in evaluation_set.evaluator_configs}
+        else:
+            # Fall back to old evaluatorRefs field - plain strings
+            evaluator_ref_ids = set(evaluation_set.evaluator_refs)
+
+        found_evaluator_ids = set()
+
+        for file in evaluators_dir.glob("*.json"):
+            try:
+                with open(file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+            except json.JSONDecodeError as e:
+                raise ValueError(
+                    f"Invalid JSON in evaluator file '{file}': {str(e)}. "
+                    f"Please check the file for syntax errors."
+                ) from e
+
+            try:
+                evaluator_id = data.get("id")
+                if evaluator_id in evaluator_ref_ids:
+                    evaluator = EvaluatorFactory.create_evaluator(
+                        data, evaluators_dir, agent_model=agent_model
+                    )
+                    evaluators.append(evaluator)
+                    found_evaluator_ids.add(evaluator_id)
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to create evaluator from file '{file}': {str(e)}. "
+                    f"Please verify the evaluator configuration."
+                ) from e
+
+        missing_evaluators = evaluator_ref_ids - found_evaluator_ids
+        if missing_evaluators:
+            raise ValueError(
+                f"Could not find the following evaluators: {missing_evaluators}"
+            )
+
+        return evaluators
+
+
+def get_agent_model(schema: UiPathRuntimeSchema) -> str | None:
+    """Get agent model from the runtime schema metadata.
+
+    The model is read from schema.metadata["settings"]["model"] which is
+    populated by the low-code agents runtime from agent.json.
+
+    Returns:
+        The model name from agent settings, or None if not found.
+    """
+    try:
+        if schema.metadata and "settings" in schema.metadata:
+            settings = schema.metadata["settings"]
+            model = settings.get("model")
+            if model:
+                logger.debug(f"Got agent model from schema.metadata: {model}")
+                return model
+        return None
+    except Exception:
+        return None
diff --git a/packages/uipath/src/uipath/eval/mocks/__init__.py b/packages/uipath/src/uipath/eval/mocks/__init__.py
new file mode 100644
index 000000000..ddb76ca70
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/__init__.py
@@ -0,0 +1,39 @@
+"""Mock interface."""
+
+from ._mock_context import is_tool_simulated
+from ._mock_runtime import (
+    UiPathMockRuntime,
+    build_mocking_context,
+    build_mocking_context_from_dict,
+)
+from ._types import (
+    ComponentSimulationConfig,
+    ExampleCall,
+    MockingContext,
+    RuleOperator,
+    SimulationAnswer,
+    SimulationAnswerType,
+    SimulationBehavior,
+    SimulationCondition,
+    SimulationConfig,
+    SimulationStrategy,
+)
+from .mockable import mockable
+
+__all__ = [
+    "ComponentSimulationConfig",
+    "ExampleCall",
+    "MockingContext",
+    "RuleOperator",
+    "SimulationAnswer",
+    "SimulationAnswerType",
+    "SimulationBehavior",
+    "SimulationCondition",
+    "SimulationConfig",
+    "SimulationStrategy",
+    "UiPathMockRuntime",
+    "build_mocking_context",
+    "build_mocking_context_from_dict",
+    "is_tool_simulated",
+    "mockable",
+]
diff --git a/packages/uipath/src/uipath/eval/mocks/_cache_manager.py b/packages/uipath/src/uipath/eval/mocks/_cache_manager.py
new file mode 100644
index 000000000..fa92d6f80
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_cache_manager.py
@@ -0,0 +1,94 @@
+"""Cache manager for LLM and input mocker responses."""
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+class CacheManager:
+    """Manages caching for LLM and input mocker responses."""
+
+    def __init__(self, cache_dir: Path | None = None):
+        """Initialize the cache manager with in-memory cache."""
+        self.cache_dir = cache_dir or (Path.cwd() / ".uipath" / "eval_cache")
+        self._memory_cache: dict[str, Any] = {}
+        self._dirty_keys: set[str] = set()
+
+    def _compute_cache_key(self, cache_key_data: dict[str, Any]) -> str:
+        """Compute a hash from cache key data."""
+        serialized = json.dumps(cache_key_data, sort_keys=True)
+        return hashlib.sha256(serialized.encode()).hexdigest()
+
+    def _get_cache_key_string(
+        self,
+        mocker_type: str,
+        cache_key_data: dict[str, Any],
+        function_name: str,
+    ) -> str:
+        """Generate unique cache key string for memory lookup."""
+        cache_key_hash = self._compute_cache_key(cache_key_data)
+        return f"{mocker_type}/{function_name}/{cache_key_hash}"
+
+    def _get_cache_path(
+        self,
+        cache_key_string: str,
+    ) -> Path:
+        """Get the file path for a cache entry from cache key string."""
+        return self.cache_dir / f"{cache_key_string}.json"
+
+    def get(
+        self,
+        mocker_type: str,
+        cache_key_data: dict[str, Any],
+        function_name: str,
+    ) -> Any:
+        """Retrieve a cached response from memory first, then disk."""
+        cache_key_string = self._get_cache_key_string(
+            mocker_type, cache_key_data, function_name
+        )
+
+        # Check memory cache first
+        if cache_key_string in self._memory_cache:
+            return self._memory_cache[cache_key_string]
+
+        # Check disk cache
+        cache_path = self._get_cache_path(cache_key_string)
+        if not cache_path.exists():
+            return None
+
+        with open(cache_path, "r") as f:
+            cached_response = json.load(f)
+
+        # Populate memory cache
+        self._memory_cache[cache_key_string] = cached_response
+        return cached_response
+
+    def set(
+        self,
+        mocker_type: str,
+        cache_key_data: dict[str, Any],
+        response: Any,
+        function_name: str,
+    ) -> None:
+        """Store a response in memory cache and mark for later disk write."""
+        cache_key_string = self._get_cache_key_string(
+            mocker_type, cache_key_data, function_name
+        )
+
+        # Store in memory
+        self._memory_cache[cache_key_string] = response
+
+        # Mark as dirty for later flush
+        self._dirty_keys.add(cache_key_string)
+
+    def flush(self) -> None:
+        """Write all dirty cache entries to disk."""
+        for cache_key_string in self._dirty_keys:
+            cache_path = self._get_cache_path(cache_key_string)
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(cache_path, "w") as f:
+                json.dump(self._memory_cache[cache_key_string], f)
+
+        self._dirty_keys.clear()
diff --git a/packages/uipath/src/uipath/eval/mocks/_input_mocker.py b/packages/uipath/src/uipath/eval/mocks/_input_mocker.py
new file mode 100644
index 000000000..a542fc7ad
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_input_mocker.py
@@ -0,0 +1,158 @@
+"""LLM Input Mocker implementation."""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any
+
+from opentelemetry import trace
+
+from uipath.core.tracing import traced
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+from uipath.platform.chat._llm_gateway_service import ChatModels
+
+from .._execution_context import eval_set_run_id_context
+from ._mock_context import cache_manager_context
+from ._mocker import UiPathInputMockingError
+from ._structured_output import generate_structured_output
+from ._types import (
+    InputMockingStrategy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_input_mocking_prompt(
+    input_schema: str,
+    input_generation_instructions: str,
+    expected_behavior: str,
+    expected_output: str,
+) -> str:
+    """Generate the LLM input mocking prompt."""
+    current_datetime = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+
+    return f"""You are simulating input for automated testing purposes of an Agent as part of a simulation run.
+You will need to generate realistic input to a LLM agent which will call various tools to achieve a goal. This must be in the exact format of the INPUT_SCHEMA.
+You may need to follow specific INPUT_GENERATION_INSTRUCTIONS. If no relevant instructions are provided pertaining to input generation, use the other provided information and your own judgement to generate input.
+If the INPUT_GENERATION_INSTRUCTIONS are provided, you MUST follow them exactly. For example if the instructions say to generate a value for a field to be before a certain calendar date, you must generate a value that is before that date.
+
+The current date and time is: {current_datetime}
+
+#INPUT_SCHEMA: You MUST OUTPUT THIS EXACT JSON SCHEMA
+{input_schema}
+#END_INPUT_SCHEMA
+
+#INPUT_GENERATION_INSTRUCTIONS
+{input_generation_instructions}
+#END_INPUT_GENERATION_INSTRUCTIONS
+
+#EXPECTED_BEHAVIOR
+{expected_behavior}
+#END_EXPECTED_BEHAVIOR
+
+#EXPECTED_OUTPUT
+{expected_output}
+#END_EXPECTED_OUTPUT
+
+Based on the above information, provide a realistic input to the LLM agent. Your response should:
+1. Match the expected input format according to the INPUT_SCHEMA exactly
+2. Be consistent with the style and level of detail in the example inputs
+3. Consider the context of the the agent being tested
+4. Be realistic and representative of what a real user might say or ask
+
+OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA in valid JSON. Do not include any explanations, quotation marks, or markdown."""
+
+
+@traced(name="Simulate Input")
+async def generate_llm_input(
+    mocking_strategy: InputMockingStrategy,
+    input_schema: dict[str, Any],
+    expected_behavior: str,
+    expected_output: dict[str, Any],
+) -> dict[str, Any]:
+    """Generate synthetic input using an LLM based on the evaluation context."""
+    # Set custom span attributes to match agents repo pattern
+    current_span = trace.get_current_span()
+    if current_span and current_span.is_recording():
+        current_span.set_attribute("span_type", "simulatedInput")
+        current_span.set_attribute("type", "simulatedInput")
+        current_span.set_attribute("uipath.custom_instrumentation", True)
+
+    try:
+        uipath = UiPath()
+        llm = UiPathLlmChatService(
+            uipath._config,
+            uipath._execution_context,
+            requesting_product="agentsplayground",
+            requesting_feature="agents-evaluations",
+            agenthub_config="agentsevals",
+            action_id=eval_set_run_id_context.get(),
+        )
+        cache_manager = cache_manager_context.get()
+
+        # Ensure additionalProperties is set for strict mode compatibility
+        if "additionalProperties" not in input_schema:
+            input_schema["additionalProperties"] = False
+
+        prompt_generation_args = {
+            "input_schema": json.dumps(input_schema),
+            "input_generation_instructions": mocking_strategy.prompt
+            if mocking_strategy
+            else "",
+            "expected_behavior": expected_behavior or "",
+            "expected_output": json.dumps(expected_output),
+        }
+
+        prompt = get_input_mocking_prompt(**prompt_generation_args)
+
+        model_parameters = mocking_strategy.model if mocking_strategy else None
+        completion_kwargs = (
+            model_parameters.model_dump(by_alias=False, exclude_none=True)
+            if model_parameters
+            else {}
+        )
+
+        simulation_model = completion_kwargs.get(
+            "model", ChatModels.gpt_4_1_mini_2025_04_14
+        )
+        logger.info(f"Simulating input generation using model: {simulation_model}")
+
+        if cache_manager is not None:
+            cache_key_data = {
+                "input_schema": input_schema,
+                "completion_kwargs": completion_kwargs,
+                "prompt_generation_args": prompt_generation_args,
+            }
+
+            cached_response = cache_manager.get(
+                mocker_type="input_mocker",
+                cache_key_data=cache_key_data,
+                function_name="generate_llm_input",
+            )
+
+            if cached_response is not None:
+                return cached_response
+
+        result = await generate_structured_output(
+            llm,
+            [{"role": "user", "content": prompt}],
+            schema=input_schema,
+            response_format_name="agent_input",
+            description="Return the simulated agent input matching the required schema.",
+            completion_kwargs=completion_kwargs,
+        )
+
+        if cache_manager is not None:
+            cache_manager.set(
+                mocker_type="input_mocker",
+                cache_key_data=cache_key_data,
+                response=result,
+                function_name="generate_llm_input",
+            )
+
+        return result
+    except UiPathInputMockingError:
+        raise
+    except Exception as e:
+        raise UiPathInputMockingError(f"Failed to generate input: {str(e)}") from e
diff --git a/packages/uipath/src/uipath/eval/mocks/_llm_mocker.py b/packages/uipath/src/uipath/eval/mocks/_llm_mocker.py
new file mode 100644
index 000000000..a9ab7005e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_llm_mocker.py
@@ -0,0 +1,261 @@
+"""LLM mocker implementation."""
+
+import json
+import logging
+from typing import Any, Callable
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, TypeAdapter
+
+from uipath.core.tracing import traced
+from uipath.platform import UiPath
+from uipath.platform.chat import UiPathLlmChatService
+from uipath.platform.chat._llm_gateway_service import ChatModels, _cleanup_schema
+
+from .._execution_context import (
+    eval_set_run_id_context,
+    execution_id_context,
+    span_collector_context,
+)
+from ._mock_context import (
+    cache_manager_context,
+    mocking_context,
+)
+from ._mocker import (
+    Mocker,
+    R,
+    T,
+    UiPathMockResponseGenerationError,
+    UiPathNoMockFoundError,
+)
+from ._structured_output import generate_structured_output
+from ._types import (
+    ExampleCall,
+    LLMMockingStrategy,
+    MockingContext,
+)
+
+PROMPT = """You are simulating a tool call for automated testing purposes of an Agent.
+Your task is to provide a realistic response for the tool based on its schema, examples, and context.
+
+SELECTED TOOL INFORMATION:
+{toolInfo}
+
+SELECTED TOOL SCHEMA:
+{toolSchema}
+
+SELECTED TOOL EXAMPLES:
+{toolRunExamples}
+
+CHOSEN TOOL INPUT:
+{currentToolInput}
+
+CURRENT AGENT RUN SO FAR:
+{testRunHistory}
+
+HERE IS SOME INFORMATION ABOUT THE AGENT: DO NOT USE THIS INFORMATION TO MAKE THE RESPONSE, BUT RATHER TO UNDERSTAND THE CONTEXT IN WHICH THE TOOL IS BEING USED.
+{agentInfo}
+
+TEST RUN PROCTOR INSTRUCTIONS:
+You will need to simulate a real user's interaction with the tool.  This may require following some run specific instructions. If run instructions are provided, follow them exactly.
+Here are the instructions for this run:
+{testRunProctorInstructions}
+
+Based on the above information, provide a realistic response for this tool call. Your response should:
+1. Match the expected output format according to the tool schema
+2. Be very consistent with how the tool has responded in previous examples. Do no omit fields or properties.
+3. Always include the entire output regardless of token length.
+3. Consider the context of the current test run and the agent being tested.  If the agent is acting on a property, make sure the output includes that property.
+
+Respond ONLY with valid JSON that would be a realistic and complete tool response. Do not include any explanations or markdown.
+"""
+
+logger = logging.getLogger(__name__)
+
+
+def pydantic_to_dict_safe(obj: Any) -> Any:
+    """Serialize nested pydantic models to a dict."""
+    if isinstance(obj, BaseModel):
+        # Convert Pydantic model to dict recursively
+        return obj.model_dump(mode="json")
+    elif isinstance(obj, dict):
+        # Recursively convert dict entries
+        return {k: pydantic_to_dict_safe(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        # Recursively convert items in lists
+        return [pydantic_to_dict_safe(item) for item in obj]
+    return obj  # Return other types as is
+
+
+class LLMMocker(Mocker):
+    """LLM Based Mocker."""
+
+    def __init__(self, context: MockingContext):
+        """LLM Mocker constructor."""
+        self.context = context
+        assert isinstance(self.context.strategy, LLMMockingStrategy)
+
+    @traced(name="__mocker__", recording=False)
+    async def response(
+        self,
+        func: Callable[[T], R],
+        params: dict[str, Any],
+        invocation: tuple[tuple[Any, ...], dict[str, Any]],
+    ) -> R:
+        """Respond with mocked response generated by an LLM."""
+        assert isinstance(self.context.strategy, LLMMockingStrategy)
+
+        args, kwargs = invocation
+
+        function_name = params.get("name") or func.__name__
+        if function_name in [x.name for x in self.context.strategy.tools_to_simulate]:
+            uipath = UiPath()
+            llm = UiPathLlmChatService(
+                uipath._config,
+                uipath._execution_context,
+                requesting_product="agentsplayground",
+                requesting_feature="agents-evaluations",
+                agenthub_config="agentsevals",
+                action_id=eval_set_run_id_context.get(),
+            )
+            return_type: Any = func.__annotations__.get("return", None)
+            if return_type is None:
+                return_type = Any
+
+            output_schema = params.get(
+                "output_schema", TypeAdapter(return_type).json_schema()
+            )
+
+            cleaned_schema = _cleanup_schema(output_schema)
+            try:
+                # Safely pull examples from params.
+                example_calls = params.get("example_calls", [])
+                if not isinstance(example_calls, list):
+                    example_calls = []
+                example_calls = [
+                    call for call in example_calls if isinstance(call, ExampleCall)
+                ]
+
+                test_run_history = "(empty)"
+                ctx = mocking_context.get()
+                span_collector = span_collector_context.get()
+                execution_id = execution_id_context.get()
+                if ctx and span_collector and execution_id:
+                    spans = span_collector.get_spans(execution_id)
+                    test_run_history = self.spans_to_llm_context(spans)
+
+                prompt_input: dict[str, Any] = {
+                    "toolRunExamples": example_calls,
+                    "testRunHistory": test_run_history,
+                    "toolInfo": {
+                        "name": function_name,
+                        "description": params.get("description"),
+                        "arguments": params.get(
+                            "arguments"
+                        ),  # arguments could be passed into tool
+                        "settings": params.get(
+                            "settings"
+                        ),  # settings could be passed into tool
+                        "inputSchema": params.get("input_schema"),
+                    },
+                    "toolSchema": params.get("input_schema"),
+                    "currentToolInput": {
+                        "args": args,
+                        "kwargs": kwargs,
+                    },
+                    "agentInfo": {  # This is incomplete
+                        "agentName": self.context.name,
+                        "actionName": self.context.name,  # Not sure if this is right?
+                        "userInput": self.context.inputs,
+                    },
+                    "testRunProctorInstructions": self.context.strategy.prompt,
+                }
+                prompt_generation_args = {
+                    k: json.dumps(pydantic_to_dict_safe(v))
+                    for k, v in prompt_input.items()
+                }
+                model_parameters = self.context.strategy.model
+                completion_kwargs = (
+                    model_parameters.model_dump(by_alias=False, exclude_none=True)
+                    if model_parameters
+                    else {}
+                )
+
+                simulation_model = completion_kwargs.get(
+                    "model", ChatModels.gpt_4_1_mini_2025_04_14
+                )
+                logger.info(
+                    f"Simulating tool '{function_name}' using model: {simulation_model}"
+                )
+
+                formatted_prompt = PROMPT.format(**prompt_generation_args)
+
+                cache_key_data = {
+                    "output_schema": cleaned_schema,
+                    "completion_kwargs": completion_kwargs,
+                    "prompt_generation_args": prompt_generation_args,
+                }
+
+                cache_manager = cache_manager_context.get()
+                if cache_manager is not None:
+                    cached_response = cache_manager.get(
+                        mocker_type="llm_mocker",
+                        cache_key_data=cache_key_data,
+                        function_name=function_name,
+                    )
+
+                    if cached_response is not None:
+                        return cached_response
+
+                result = await generate_structured_output(
+                    llm,
+                    [{"role": "user", "content": formatted_prompt}],
+                    schema=cleaned_schema,
+                    response_format_name="OutputSchema",
+                    description=(
+                        "Return the simulated response for tool "
+                        f"'{function_name}' matching the required schema."
+                    ),
+                    completion_kwargs=completion_kwargs,
+                )
+
+                if cache_manager is not None:
+                    cache_manager.set(
+                        mocker_type="llm_mocker",
+                        cache_key_data=cache_key_data,
+                        response=result,
+                        function_name=function_name,
+                    )
+
+                return result
+            except Exception as e:
+                raise UiPathMockResponseGenerationError(str(e)) from e
+        else:
+            raise UiPathNoMockFoundError(f"Method '{function_name}' is not simulated.")
+
+    @staticmethod
+    def spans_to_llm_context(spans: list[ReadableSpan]) -> str:
+        """Convert spans to a formatted conversation history string suitable for LLM context.
+
+        Includes function calls (including LLM calls) with their inputs and outputs.
+        """
+        history = []
+        for span in spans:
+            attributes = dict(span.attributes) if span.attributes else {}
+
+            input_value = attributes.get("input.value")
+            output_value = attributes.get("output.value")
+            telemetry_filter = attributes.get("telemetry.filter")
+
+            if not input_value or not output_value or telemetry_filter == "drop":
+                continue
+
+            history.append(f"Function: {span.name}")
+            history.append(f"Input: {input_value}")
+            history.append(f"Output: {output_value}")
+            history.append("")
+
+        if not history:
+            return "(empty)"
+
+        return "\n".join(history)
diff --git a/packages/uipath/src/uipath/eval/mocks/_mock_context.py b/packages/uipath/src/uipath/eval/mocks/_mock_context.py
new file mode 100644
index 000000000..bd2f80df6
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_mock_context.py
@@ -0,0 +1,84 @@
+"""Mocking interface."""
+
+from contextvars import ContextVar
+from typing import Any, Callable
+
+from ._cache_manager import CacheManager
+from ._mocker import Mocker, UiPathNoMockFoundError
+from ._types import (
+    LLMMockingStrategy,
+    MockingContext,
+    MockitoMockingStrategy,
+)
+
+# Context variables for evaluation items and mockers
+mocking_context: ContextVar[MockingContext | None] = ContextVar(
+    "mocking_context", default=None
+)
+
+mocker_context: ContextVar[Mocker | None] = ContextVar("mocker", default=None)
+
+# Cache manager for LLM and input mocker responses
+cache_manager_context: ContextVar[CacheManager | None] = ContextVar(
+    "cache_manager", default=None
+)
+
+
+def _normalize_tool_name(name: str) -> str:
+    """Normalize tool name by replacing underscores with spaces.
+
+    Tool names may use spaces in configuration but underscores in execution.
+    """
+    return name.replace("_", " ")
+
+
+def is_tool_simulated(tool_name: str) -> bool:
+    """Check if a tool will be simulated based on the current mocking strategy context.
+
+    Args:
+        tool_name: The name of the tool to check.
+
+    Returns:
+        True if we're in an mocking strategy context and the tool is configured
+        to be simulated, False otherwise.
+    """
+    ctx = mocking_context.get()
+    if ctx is None:
+        return False
+
+    normalized_tool_name = _normalize_tool_name(tool_name)
+
+    if ctx.components:
+        return any(
+            _normalize_tool_name(c.component_id) == normalized_tool_name
+            for c in ctx.components
+        )
+
+    strategy = ctx.strategy
+    if strategy is None:
+        return False
+
+    if isinstance(strategy, LLMMockingStrategy):
+        return normalized_tool_name in [
+            _normalize_tool_name(t.name) for t in strategy.tools_to_simulate
+        ]
+    elif isinstance(strategy, MockitoMockingStrategy):
+        return any(
+            _normalize_tool_name(b.function) == normalized_tool_name
+            for b in strategy.behaviors
+        )
+
+    return False
+
+
+async def get_mocked_response(
+    func: Callable[[Any], Any],
+    params: dict[str, Any],
+    invocation: tuple[tuple[Any, ...], dict[str, Any]],
+) -> Any:
+    """Get a mocked response."""
+    mocker = mocker_context.get()
+    if mocker is None:
+        raise UiPathNoMockFoundError()
+    else:
+        return await mocker.response(func, params, invocation)
diff --git a/packages/uipath/src/uipath/eval/mocks/_mock_runtime.py b/packages/uipath/src/uipath/eval/mocks/_mock_runtime.py
new file mode 100644
index 000000000..60cc78c2b
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_mock_runtime.py
@@ -0,0 +1,241 @@
+"""Mock runtime delegate that manages mocking execution context."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import Any
+
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+)
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+from .._execution_context import (
+    ExecutionSpanCollector,
+    eval_set_run_id_context,
+    execution_id_context,
+    span_collector_context,
+)
+from ._mock_context import mocker_context, mocking_context
+from ._mocker_factory import MockerFactory
+from ._types import (
+    LLMMockingStrategy,
+    MockingContext,
+    MockingStrategyType,
+    ModelSettings,
+    SimulationConfig,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def build_mocking_context(
+    config: SimulationConfig, agent_model: str | None = None
+) -> MockingContext | None:
+    """Build a MockingContext from a validated SimulationConfig."""
+    if not config.enabled:
+        return None
+
+    # New per-component format → routes to simulate-component API
+    if config.components:
+        from uipath.platform.common._config import UiPathConfig
+
+        workload_id = (
+            getattr(UiPathConfig, "agent_id", None)
+            or getattr(UiPathConfig, "project_id", None)
+            or str(uuid.uuid4())
+        )
+        logger.debug(
+            f"Loaded simulation config for {len(config.components)} component(s)"
+        )
+        return MockingContext(
+            strategy=None,
+            name="debug-simulation",
+            inputs={},
+            components=config.components,
+            workload_id=workload_id,
+        )
+
+    # Legacy format (toolsToSimulate + instructions) → routes to local LLM mocker
+    if not config.tools_to_simulate:
+        return None
+
+    model = (
+        ModelSettings(model=config.model)
+        if config.model
+        else ModelSettings(model=agent_model)
+        if agent_model
+        else None
+    )
+
+    mocking_strategy = LLMMockingStrategy(
+        type=MockingStrategyType.LLM,
+        prompt=config.instructions,
+        tools_to_simulate=config.tools_to_simulate,
+        model=model,
+    )
+
+    logger.debug(
+        f"Loaded simulation config for {len(config.tools_to_simulate)} tool(s)"
+    )
+    return MockingContext(
+        strategy=mocking_strategy,
+        name="debug-simulation",
+        inputs={},
+    )
+
+
+def build_mocking_context_from_dict(
+    simulation_data: dict[str, Any], agent_model: str | None = None
+) -> MockingContext | None:
+    """Build a MockingContext from a simulation config dictionary.
+
+    Deprecated: prefer build_mocking_context with a validated SimulationConfig.
+
+    Args:
+        simulation_data: Parsed simulation config (same schema as simulation.json).
+        agent_model: Optional agent model name to use as fallback.
+
+    Returns:
+        MockingContext if valid and enabled, None otherwise.
+    """
+    config = SimulationConfig.model_validate(simulation_data)
+    return build_mocking_context(config, agent_model)
+
+
+def load_simulation_config(agent_model: str | None = None) -> MockingContext | None:
+    """Load simulation.json from current directory and convert to MockingContext.
+
+    Returns:
+        MockingContext with LLM mocking strategy if simulation.json exists and is valid,
+        None otherwise.
+    """
+    simulation_path = Path.cwd() / "simulation.json"
+
+    if not simulation_path.exists():
+        return None
+
+    try:
+        config = SimulationConfig.model_validate_json(
+            simulation_path.read_text(encoding="utf-8")
+        )
+        return build_mocking_context(config, agent_model)
+
+    except Exception as e:
+        logger.warning(f"Failed to load simulation.json: {e}")
+        return None
+
+
+def set_execution_context(
+    context: MockingContext | None,
+    span_collector: ExecutionSpanCollector,
+    execution_id: str | None = None,
+    eval_set_run_id: str | None = None,
+) -> None:
+    """Set the execution context for an evaluation run for mocking and trace access."""
+    mocking_context.set(context)
+
+    try:
+        if context and (context.strategy or context.components):
+            mocker = MockerFactory.create(context)
+            mocker_context.set(mocker)
+            logger.info(
+                "simulate-component: mocker created (%s)", type(mocker).__name__
+            )
+        else:
+            mocker_context.set(None)
+    except Exception:
+        logger.warning("Failed to create mocker.", exc_info=True)
+        mocker_context.set(None)
+
+    span_collector_context.set(span_collector)
+    execution_id_context.set(execution_id)
+    eval_set_run_id_context.set(eval_set_run_id)
+
+
+def clear_execution_context() -> None:
+    """Clear the execution context after evaluation completes."""
+    mocking_context.set(None)
+    mocker_context.set(None)
+    span_collector_context.set(None)
+    execution_id_context.set(None)
+
+
+class UiPathMockRuntime:
+    """Runtime delegate that manages mocking execution context.
+
+    Wraps an inner runtime and automatically sets/clears the mocking
+    execution context around each execute() and stream() call.
+
+    When no mocking_context is provided, falls back to loading
+    simulation.json from the current directory.
+    """
+
+    def __init__(
+        self,
+        delegate: UiPathRuntimeProtocol,
+        mocking_context: MockingContext | None = None,
+        span_collector: ExecutionSpanCollector | None = None,
+        execution_id: str | None = None,
+        eval_set_run_id: str | None = None,
+    ):
+        self.delegate = delegate
+        self._mocking_context = mocking_context or load_simulation_config()
+        self._span_collector = span_collector or ExecutionSpanCollector()
+        self._execution_id = execution_id or str(uuid.uuid4())
+        self._eval_set_run_id = eval_set_run_id
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        """Execute with mocking context set around the delegate call."""
+        if not self._mocking_context:
+            return await self.delegate.execute(input, options)
+
+        set_execution_context(
+            self._mocking_context,
+            self._span_collector,
+            self._execution_id,
+            self._eval_set_run_id,
+        )
+        try:
+            return await self.delegate.execute(input, options)
+        finally:
+            clear_execution_context()
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: Any | None = None,
+    ) -> AsyncGenerator[Any, None]:
+        """Stream with mocking context set around the delegate call."""
+        if not self._mocking_context:
+            async for event in self.delegate.stream(input, options):
+                yield event
+        else:
+            set_execution_context(
+                self._mocking_context,
+                self._span_collector,
+                self._execution_id,
+                self._eval_set_run_id,
+            )
+            try:
+                async for event in self.delegate.stream(input, options):
+                    yield event
+            finally:
+                clear_execution_context()
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        """Pass through to delegate."""
+        return await self.delegate.get_schema()
+
+    async def dispose(self) -> None:
+        """No-op; callers manage delegate disposal."""
+        pass
diff --git a/packages/uipath/src/uipath/eval/mocks/_mocker.py b/packages/uipath/src/uipath/eval/mocks/_mocker.py
new file mode 100644
index 000000000..99e5da1b2
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_mocker.py
@@ -0,0 +1,40 @@
+"""Mocker definitions and implementations."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class Mocker(ABC):
+    """Mocker interface."""
+
+    @abstractmethod
+    async def response(
+        self,
+        func: Callable[[T], R],
+        params: dict[str, Any],
+        invocation: tuple[tuple[Any, ...], dict[str, Any]],
+    ) -> R:
+        """Respond with mocked response."""
+        raise NotImplementedError()
+
+
+class UiPathNoMockFoundError(Exception):
+    """Exception when a mocker is unable to find a match with the invocation. This is a signal to invoke the real function."""
+
+    pass
+
+
+class UiPathMockResponseGenerationError(Exception):
+    """Exception when a mocker is configured unable to generate a response."""
+
+    pass
+
+
+class UiPathInputMockingError(Exception):
+    """Exception when input mocking fails."""
+
+    pass
diff --git a/packages/uipath/src/uipath/eval/mocks/_mocker_factory.py b/packages/uipath/src/uipath/eval/mocks/_mocker_factory.py
new file mode 100644
index 000000000..2f61162a4
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_mocker_factory.py
@@ -0,0 +1,28 @@
+"""Mocker Factory."""
+
+from ._llm_mocker import LLMMocker
+from ._mocker import Mocker
+from ._mockito_mocker import MockitoMocker
+from ._simulate_component_mocker import SimulateComponentMocker
+from ._types import (
+    LLMMockingStrategy,
+    MockingContext,
+    MockitoMockingStrategy,
+)
+
+
+class MockerFactory:
+    """Mocker factory."""
+
+    @staticmethod
+    def create(context: MockingContext) -> Mocker:
+        """Create a mocker instance."""
+        if context.components:
+            return SimulateComponentMocker(context)
+        match context.strategy:
+            case LLMMockingStrategy():
+                return LLMMocker(context)
+            case MockitoMockingStrategy():
+                return MockitoMocker(context)
+            case _:
+                raise ValueError("Unknown mocking strategy")
diff --git a/packages/uipath/src/uipath/eval/mocks/_mockito_mocker.py b/packages/uipath/src/uipath/eval/mocks/_mockito_mocker.py
new file mode 100644
index 000000000..a9b30230f
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_mockito_mocker.py
@@ -0,0 +1,134 @@
+"""Mockito mocker implementation. https://mockito-python.readthedocs.io/en/latest ."""
+
+import importlib
+from typing import Any, Callable
+
+from mockito import (  # type: ignore[import-untyped]
+    ARGS,
+    KWARGS,
+    invocation,
+    mocking,
+)
+from pydantic import JsonValue
+
+from ._mocker import (
+    Mocker,
+    R,
+    T,
+    UiPathMockResponseGenerationError,
+)
+from ._types import (
+    MockingAnswerType,
+    MockingContext,
+    MockitoMockingStrategy,
+)
+
+
+class Stub:
+    """Stub interface."""
+
+    def __getattr__(self, item):
+        """Return a wrapper function that raises an exception."""
+
+        def func(*_args, **_kwargs):
+            raise NotImplementedError()
+
+        return func
+
+
+def _resolve_value(config: JsonValue) -> Any:
+    if isinstance(config, dict):
+        if "_target_" in config:
+            target = config["_target_"]
+            assert isinstance(target, str), (
+                "Please check mocking configuration -- _target_ must be a string."
+            )
+            module_path, name = target.rsplit(".", 1)
+
+            module = importlib.import_module(module_path)
+            obj = getattr(module, name)
+
+            kwargs = {
+                k: _resolve_value(v) for k, v in config.items() if k != "_target_"
+            }
+            return obj(**kwargs)
+        else:
+            return {k: _resolve_value(v) for k, v in config.items()}
+
+    elif isinstance(config, list):
+        return [_resolve_value(v) for v in config]
+
+    else:
+        return config
+
+
+class MockitoMocker(Mocker):
+    """Mockito Mocker."""
+
+    def __init__(self, context: MockingContext):
+        """Instantiate a mockito mocker."""
+        self.context = context
+        assert isinstance(self.context.strategy, MockitoMockingStrategy)
+
+        self.stub = Stub()
+        mock_obj = mocking.Mock(self.stub)
+
+        for behavior in self.context.strategy.behaviors:
+            # If arguments is omitted (None), match any call signature
+            if behavior.arguments is None:
+                stubbed = invocation.StubbedInvocation(mock_obj, behavior.function)(
+                    *ARGS, **KWARGS
+                )
+            else:
+                resolved_args = _resolve_value(behavior.arguments.args)
+                resolved_kwargs = _resolve_value(behavior.arguments.kwargs)
+                args = resolved_args if resolved_args is not None else []
+                kwargs = resolved_kwargs if resolved_kwargs is not None else {}
+                stubbed = invocation.StubbedInvocation(mock_obj, behavior.function)(
+                    *args,
+                    **kwargs,
+                )
+
+            for answer in behavior.then:
+                answer_dict = answer.model_dump()
+
+                if answer.type == MockingAnswerType.RETURN:
+                    stubbed = stubbed.thenReturn(_resolve_value(answer_dict["value"]))
+
+                elif answer.type == MockingAnswerType.RAISE:
+                    stubbed = stubbed.thenRaise(_resolve_value(answer_dict["value"]))
+
+    async def response(
+        self,
+        func: Callable[[T], R],
+        params: dict[str, Any],
+        invocation: tuple[tuple[Any, ...], dict[str, Any]],
+    ) -> R:
+        """Return mocked response or raise appropriate errors."""
+        if not isinstance(self.context.strategy, MockitoMockingStrategy):
+            raise UiPathMockResponseGenerationError("Mocking strategy misconfigured.")
+
+        args, kwargs = invocation
+
+        # No behavior configured → call real function
+        is_mocked = any(
+            behavior.function == params["name"]
+            for behavior in self.context.strategy.behaviors
+        )
+
+        if not is_mocked:
+            import inspect
+
+            if inspect.iscoroutinefunction(func):
+                return await func(*args, **kwargs)
+            return func(*args, **kwargs)
+
+        # Behavioral mocking
+        try:
+            return getattr(self.stub, params["name"])(*args, **kwargs)
+
+        except NotImplementedError:
+            raise
+
+        except Exception as e:
+            raise UiPathMockResponseGenerationError() from e
diff --git a/packages/uipath/src/uipath/eval/mocks/_simulate_component_mocker.py b/packages/uipath/src/uipath/eval/mocks/_simulate_component_mocker.py
new file mode 100644
index 000000000..f35359ec4
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_simulate_component_mocker.py
@@ -0,0 +1,143 @@
+"""Mocker that routes tool calls through the simulate-component API."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, cast
+
+from pydantic import TypeAdapter
+
+from uipath.platform.chat._llm_gateway_service import _cleanup_schema
+
+from .._execution_context import execution_id_context, span_collector_context
+from ._llm_mocker import LLMMocker
+from ._mocker import (
+    Mocker,
+    R,
+    T,
+    UiPathMockResponseGenerationError,
+    UiPathNoMockFoundError,
+)
+from ._simulate_component_service import _create_simulate_component_service
+from ._types import ComponentSimulationConfig, MockingContext
+
+logger = logging.getLogger(__name__)
+
+
+class SimulateComponentMocker(Mocker):
+    """Routes each tool call to the simulate-component API based on per-component config."""
+
+    def __init__(self, context: MockingContext) -> None:
+        self._context = context
+        self._components: dict[str, ComponentSimulationConfig] = {
+            c.component_id: c for c in (context.components or [])
+        }
+        self._normalized: dict[str, ComponentSimulationConfig] = {
+            c.component_id.replace("_", " "): c for c in (context.components or [])
+        }
+        self._workload_id = context.workload_id or ""
+
+    def _find_component(self, tool_name: str) -> ComponentSimulationConfig | None:
+        return self._components.get(tool_name) or self._normalized.get(
+            tool_name.replace("_", " ")
+        )
+
+    async def response(
+        self,
+        func: Callable[[T], R],
+        params: dict[str, Any],
+        invocation: tuple[tuple[Any, ...], dict[str, Any]],
+    ) -> R:
+        tool_name = params.get("name") or func.__name__
+        component = self._find_component(tool_name)
+
+        if component is None:
+            raise UiPathNoMockFoundError(f"No simulation config for '{tool_name}'.")
+
+        args, kwargs = invocation
+
+        return_type: Any = func.__annotations__.get("return", None) or Any
+        raw_output_schema = (
+            params.get("output_schema") or TypeAdapter(return_type).json_schema()
+        )
+        output_schema = component.output_schema or _cleanup_schema(raw_output_schema)
+        input_payload = {"args": list(args), "kwargs": kwargs}
+        input_schema = component.input_schema or params.get("input_schema")
+
+        execution_history = self._build_execution_history()
+        trace_id, parent_span_id = self._get_span_context()
+        workload_info = {
+            "name": self._context.name,
+            "userInput": self._context.inputs,
+        }
+
+        example_calls = [
+            {"id": ex.id, "input": ex.input, "output": ex.output}
+            for ex in (params.get("example_calls") or [])
+        ]
+
+        payload: dict[str, Any] = {
+            "workloadId": self._workload_id,
+            "componentId": component.component_id,
+            "componentType": component.component_type or "tool",
+            "componentDescription": component.component_description
+            or params.get("description"),
+            "input": input_payload,
+            "inputSchema": input_schema,
+            "outputSchema": output_schema,
+            "simulationInstruction": component.simulation_instruction,
+            "simulationStrategy": int(component.simulation_strategy),
+            "mockValue": component.mock_value,
+            "behaviors": (
+                [b.model_dump() for b in component.behaviors]
+                if component.behaviors
+                else None
+            ),
+            "exampleCalls": example_calls or None,
+            "executionHistory": execution_history or None,
+            "workloadInfo": workload_info,
+            "traceId": trace_id,
+            "parentSpanId": parent_span_id,
+        }
+
+        logger.info("simulate-component: calling API for '%s'", tool_name)
+        try:
+            service = _create_simulate_component_service()
+            result = await service.simulate(payload)
+        except Exception as e:
+            logger.error(
+                "simulate-component: API call failed for '%s': %s", tool_name, e
+            )
+            raise UiPathMockResponseGenerationError(
+                f"simulate-component API call failed for '{tool_name}'"
+            ) from e
+
+        status = result.get("status")
+        if status == 1:  # Completed
+            logger.info("simulate-component: '%s' simulated successfully", tool_name)
+            return cast(R, result.get("simulatedOutput"))
+
+        error = result.get("error") or {}
+        error_message = error.get("message", f"Simulation failed for '{tool_name}'")
+        logger.error("simulate-component: '%s' failed — %s", tool_name, error_message)
+        raise UiPathMockResponseGenerationError(error_message)
+
+    def _build_execution_history(self) -> str | None:
+        span_collector = span_collector_context.get()
+        execution_id = execution_id_context.get()
+        if span_collector and execution_id:
+            spans = span_collector.get_spans(execution_id)
+            return LLMMocker.spans_to_llm_context(spans) if spans else None
+        return None
+
+    @staticmethod
+    def _get_span_context() -> tuple[str | None, str | None]:
+        """Return (traceId, parentSpanId) from the current OTel span, or (None, None)."""
+        from opentelemetry import trace
+
+        span_ctx = trace.get_current_span().get_span_context()
+        if not span_ctx.is_valid:
+            return None, None
+        trace_id = f"{span_ctx.trace_id:032x}"
+        span_id = f"{span_ctx.span_id:016x}"
+        return trace_id, span_id
diff --git a/packages/uipath/src/uipath/eval/mocks/_simulate_component_service.py b/packages/uipath/src/uipath/eval/mocks/_simulate_component_service.py
new file mode 100644
index 000000000..87a08bd37
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_simulate_component_service.py
@@ -0,0 +1,37 @@
+"""Service for calling the simulate-component API."""
+
+from typing import Any
+
+from uipath._utils import Endpoint
+from uipath.platform.common import BaseService
+
+
+class SimulateComponentService(BaseService):
+    async def simulate(self, payload: dict[str, Any]) -> dict[str, Any]:
+        from uipath.platform.common import UiPathConfig
+
+        headers: dict[str, str] = {}
+        if UiPathConfig.tenant_id:
+            headers["X-UiPath-Internal-TenantId"] = UiPathConfig.tenant_id
+        if UiPathConfig.organization_id:
+            headers["X-UiPath-Internal-AccountId"] = UiPathConfig.organization_id
+
+        response = await self.request_async(
+            "POST",
+            url=Endpoint(
+                "/agentsruntime_/api/execution/simulations/simulate-component"
+            ),
+            json=payload,
+            headers=headers,
+        )
+        return response.json()
+
+
+def _create_simulate_component_service() -> SimulateComponentService:
+    from uipath.platform import UiPath
+
+    uipath = UiPath()
+    return SimulateComponentService(
+        config=uipath._config,
+        execution_context=uipath._execution_context,
+    )
diff --git a/packages/uipath/src/uipath/eval/mocks/_structured_output.py b/packages/uipath/src/uipath/eval/mocks/_structured_output.py
new file mode 100644
index 000000000..599780353
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_structured_output.py
@@ -0,0 +1,259 @@
+"""Provider-aware structured output for the eval mockers.
+
+The normalized LLM Gateway handles OpenAI-style ``response_format``
+(json_schema) differently per provider — live-verified against the gateway:
+
+- **OpenAI**: honors ``response_format`` and returns valid JSON content,
+  including native ``$defs`` support.
+- **Anthropic (Claude)**: ignores it and answers with plain prose content.
+- **Gemini**: returns empty content.
+
+Forced function calling works across all three providers, so each provider
+gets a small strategy class: OpenAI prefers ``response_format`` (more reliable
+for it on some schemas) with a tool-call fallback; Claude and Gemini go
+straight to the forced tool call; unknown providers try ``response_format``
+first and fall back.
+"""
+
+import json
+import logging
+from typing import Any
+
+from uipath.platform.chat.llm_gateway import RequiredToolChoice
+
+RESPONSE_TOOL_NAME = "submit_tool_response"
+RESPONSE_KEY = "response"
+_DEFS_PREFIX = "#/$defs/"
+
+logger = logging.getLogger(__name__)
+
+
+def _inline_defs(
+    schema: dict[str, Any],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """Inline ``$defs``/``$ref`` into a self-contained schema.
+
+    Nested Pydantic models and enums emit root ``$defs`` referenced by ``$ref``.
+    The normalized gateway accepts those in ``response_format`` but not inside a
+    tool's ``parameters``, so they are inlined here. Sibling keys on a ``$ref``
+    node (e.g. a field ``description``) are merged over the inlined definition.
+    Self-referential definitions cannot be inlined without looping; any ``$ref``
+    reached while its target is already on the current resolution path is left
+    untouched and its definitions are returned so the caller can keep them
+    reachable.
+
+    Returns:
+        A tuple of (inlined schema, leftover ``$defs`` needed for cyclic refs).
+    """
+    defs = schema.get("$defs", {})
+    leftover: dict[str, Any] = {}
+
+    def resolve(node: Any, active: frozenset[str]) -> Any:
+        if isinstance(node, dict):
+            ref = node.get("$ref")
+            if isinstance(ref, str) and ref.startswith(_DEFS_PREFIX):
+                name = ref[len(_DEFS_PREFIX) :]
+                if name in defs and name not in active:
+                    resolved = resolve(defs[name], active | {name})
+                    siblings = {
+                        key: resolve(value, active)
+                        for key, value in node.items()
+                        if key not in ("$ref", "$defs")
+                    }
+                    if isinstance(resolved, dict):
+                        return {**resolved, **siblings}
+                    return resolved
+                # Cyclic or unknown ref: keep it and preserve its definition.
+                if name in defs:
+                    leftover[name] = defs[name]
+                return dict(node)
+            return {
+                key: resolve(value, active)
+                for key, value in node.items()
+                if key != "$defs"
+            }
+        if isinstance(node, list):
+            return [resolve(item, active) for item in node]
+        return node
+
+    root = {key: value for key, value in schema.items() if key != "$defs"}
+    inlined = resolve(root, frozenset())
+    return inlined, leftover
+
+
+def build_response_tool(schema: dict[str, Any], description: str) -> dict[str, Any]:
+    """Build a normalized-API function tool that wraps ``schema`` under ``response``.
+
+    Tool-call arguments are always a JSON object, so an arbitrary output schema
+    (which may be a scalar, array, or object) is nested under a single
+    ``response`` property and unwrapped after the call. ``$defs``/``$ref`` are
+    inlined so the tool parameters are self-contained, which the gateway requires
+    for tool schemas (unlike ``response_format``).
+    """
+    response_schema, leftover_defs = _inline_defs(schema)
+    parameters: dict[str, Any] = {
+        "type": "object",
+        "properties": {RESPONSE_KEY: response_schema},
+        "required": [RESPONSE_KEY],
+    }
+    if leftover_defs:
+        parameters["$defs"] = leftover_defs
+
+    return {
+        "name": RESPONSE_TOOL_NAME,
+        "description": description,
+        "parameters": parameters,
+    }
+
+
+def extract_response(response: Any) -> Any:
+    """Extract the wrapped value from the forced tool call.
+
+    Raises:
+        ValueError: if the response carries no usable tool call or is missing the
+            wrapped ``response`` key.
+    """
+    choices = getattr(response, "choices", None)
+    if not choices:
+        raise ValueError("LLM response contained no choices")
+
+    message = choices[0].message
+    tool_calls = getattr(message, "tool_calls", None)
+    if not tool_calls:
+        raise ValueError(
+            f"LLM response contained no tool calls (content={message.content!r})"
+        )
+
+    arguments = tool_calls[0].arguments
+    if RESPONSE_KEY not in arguments:
+        raise ValueError(
+            f"Tool call arguments missing '{RESPONSE_KEY}' key: {arguments}"
+        )
+
+    return arguments[RESPONSE_KEY]
+
+
+class ToolCallStructuredOutput:
+    """Structured output via a forced tool call — works on every provider."""
+
+    async def generate(
+        self,
+        llm: Any,
+        messages: list[dict[str, str]],
+        *,
+        schema: dict[str, Any],
+        response_format_name: str,
+        description: str,
+        completion_kwargs: dict[str, Any],
+    ) -> Any:
+        """Force a tool call wrapping ``schema`` and unwrap its arguments."""
+        tool = build_response_tool(schema, description)
+        response = await llm.chat_completions(
+            messages,
+            tools=[tool],
+            tool_choice=RequiredToolChoice(),
+            **completion_kwargs,
+        )
+        return extract_response(response)
+
+
+class ResponseFormatStructuredOutput(ToolCallStructuredOutput):
+    """Prefer ``response_format`` (json_schema); fall back to a forced tool call.
+
+    The fallback fires when the provider rejects the request, returns empty
+    content, or returns content that is not valid JSON (Claude's behavior on
+    the normalized gateway is to answer with plain prose).
+    """
+
+    async def generate(
+        self,
+        llm: Any,
+        messages: list[dict[str, str]],
+        *,
+        schema: dict[str, Any],
+        response_format_name: str,
+        description: str,
+        completion_kwargs: dict[str, Any],
+    ) -> Any:
+        """Try ``response_format`` first, falling back to a forced tool call."""
+        response_format = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": response_format_name,
+                "strict": False,
+                "schema": schema,
+            },
+        }
+
+        content: str | None = None
+        try:
+            response = await llm.chat_completions(
+                messages, response_format=response_format, **completion_kwargs
+            )
+            choices = getattr(response, "choices", None)
+            if choices:
+                content = choices[0].message.content
+        except Exception as e:
+            logger.info("response_format path failed, falling back to tools: %s", e)
+
+        if content:
+            try:
+                return json.loads(content)
+            except json.JSONDecodeError:
+                logger.info(
+                    "response_format content was not JSON, falling back to tools"
+                )
+
+        return await super().generate(
+            llm,
+            messages,
+            schema=schema,
+            response_format_name=response_format_name,
+            description=description,
+            completion_kwargs=completion_kwargs,
+        )
+
+
+class OpenAIStructuredOutput(ResponseFormatStructuredOutput):
+    """OpenAI honors ``response_format`` natively (including ``$defs``)."""
+
+
+class AnthropicStructuredOutput(ToolCallStructuredOutput):
+    """Claude answers ``response_format`` with prose; go straight to tools."""
+
+
+class GeminiStructuredOutput(ToolCallStructuredOutput):
+    """Gemini returns empty content for ``response_format``; go straight to tools."""
+
+
+def _strategy_for_model(model: str | None) -> ToolCallStructuredOutput:
+    name = (model or "").lower()
+    if "claude" in name or name.startswith("anthropic"):
+        return AnthropicStructuredOutput()
+    if "gemini" in name:
+        return GeminiStructuredOutput()
+    if name.startswith(("gpt", "o1", "o3", "o4")):
+        return OpenAIStructuredOutput()
+    # Unknown providers: try response_format, fall back to tools.
+    return ResponseFormatStructuredOutput()
+
+
+async def generate_structured_output(
+    llm: Any,
+    messages: list[dict[str, str]],
+    *,
+    schema: dict[str, Any],
+    response_format_name: str,
+    description: str,
+    completion_kwargs: dict[str, Any],
+) -> Any:
+    """Generate structured output using the strategy for the requested model."""
+    strategy = _strategy_for_model(completion_kwargs.get("model"))
+    return await strategy.generate(
+        llm,
+        messages,
+        schema=schema,
+        response_format_name=response_format_name,
+        description=description,
+        completion_kwargs=completion_kwargs,
+    )
diff --git a/packages/uipath/src/uipath/eval/mocks/_types.py b/packages/uipath/src/uipath/eval/mocks/_types.py
new file mode 100644
index 000000000..f1a15312c
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/_types.py
@@ -0,0 +1,271 @@
+"""Mocking types for evaluation and simulation."""
+
+from enum import Enum
+from typing import Annotated, Any, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MockingStrategyType(str, Enum):
+    """Supported mocking strategy types."""
+
+    LLM = "llm"
+    MOCKITO = "mockito"
+    UNKNOWN = "unknown"
+
+
+class BaseMockingStrategy(BaseModel):
+    """Base class for mocking strategies."""
+
+    pass
+
+
+class ToolSimulation(BaseModel):
+    """A tool to be simulated during evaluation."""
+
+    name: str = Field(..., alias="name")
+
+
+class ModelSettings(BaseModel):
+    """Model generation parameters for LLM-based mocking."""
+
+    model: str = Field(..., alias="model")
+    temperature: float | str | None = Field(default=None, alias="temperature")
+    top_p: float | None = Field(default=None, alias="topP")
+    top_k: int | None = Field(default=None, alias="topK")
+    frequency_penalty: float | None = Field(default=None, alias="frequencyPenalty")
+    presence_penalty: float | None = Field(default=None, alias="presencePenalty")
+    max_tokens: int | None = Field(default=None, alias="maxTokens")
+
+
+class LLMMockingStrategy(BaseMockingStrategy):
+    """Mocking strategy that uses an LLM to generate simulated tool responses."""
+
+    type: Literal[MockingStrategyType.LLM] = MockingStrategyType.LLM
+    prompt: str = Field(..., alias="prompt")
+    tools_to_simulate: list[ToolSimulation] = Field(..., alias="toolsToSimulate")
+    model: ModelSettings | None = Field(None, alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class InputMockingStrategy(BaseModel):
+    """Strategy for generating mocked inputs via LLM."""
+
+    prompt: str = Field(..., alias="prompt")
+    model: ModelSettings | None = Field(None, alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class MockingArgument(BaseModel):
+    """Arguments matcher for mockito-style mocking."""
+
+    args: list[Any] = Field(default_factory=lambda: [], alias="args")
+    kwargs: dict[str, Any] = Field(default_factory=lambda: {}, alias="kwargs")
+
+
+class MockingAnswerType(str, Enum):
+    """Type of answer a mock should produce."""
+
+    RETURN = "return"
+    RAISE = "raise"
+
+
+class MockingAnswer(BaseModel):
+    """A mock answer definition (return value or exception)."""
+
+    type: MockingAnswerType
+    value: Any = Field(..., alias="value")
+
+
+class MockingBehavior(BaseModel):
+    """Defines how a mocked function should behave."""
+
+    function: str = Field(..., alias="function")
+    arguments: MockingArgument | None = Field(default=None, alias="arguments")
+    then: list[MockingAnswer] = Field(..., alias="then")
+
+
+class MockitoMockingStrategy(BaseMockingStrategy):
+    """Mocking strategy using mockito-style behavior definitions."""
+
+    type: Literal[MockingStrategyType.MOCKITO] = MockingStrategyType.MOCKITO
+    behaviors: list[MockingBehavior] = Field(..., alias="config")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+KnownMockingStrategy = Annotated[
+    Union[LLMMockingStrategy, MockitoMockingStrategy],
+    Field(discriminator="type"),
+]
+
+
+class UnknownMockingStrategy(BaseMockingStrategy):
+    """Fallback for unrecognized mocking strategy types."""
+
+    type: str = Field(..., alias="type")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+MockingStrategy = Union[KnownMockingStrategy, UnknownMockingStrategy]
+
+
+# ---------------------------------------------------------------------------
+# Per-component simulation types — mirror the simulate-component API contract
+# ---------------------------------------------------------------------------
+
+
+class SimulationStrategy(int, Enum):
+    """Simulation strategy matching the simulate-component API.
+
+    Integer values are part of the cross-language API contract — do not reorder.
+    """
+
+    LLM = 0
+    MOCKITO = 1
+    STATIC = 2
+
+
+class RuleOperator(int, Enum):
+    """Comparison operator for Mockito condition matching.
+
+    Integer values are part of the cross-language API contract — do not reorder.
+    """
+
+    EQ = 0
+    NE = 1
+    GT = 2
+    GTE = 3
+    LT = 4
+    LTE = 5
+    CONTAINS = 6
+
+
+class SimulationAnswerType(int, Enum):
+    """Answer type for a Mockito simulation behavior.
+
+    Integer values are part of the cross-language API contract — do not reorder.
+    """
+
+    RETURN = 0
+    RAISE = 1
+
+
+class SimulationAnswer(BaseModel):
+    type: SimulationAnswerType = SimulationAnswerType.RETURN
+    value: Any = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class SimulationCondition(BaseModel):
+    field: str
+    op: RuleOperator = RuleOperator.EQ
+    value: Any = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class SimulationBehavior(BaseModel):
+    when: list[SimulationCondition] | None = None
+    then: list[SimulationAnswer]
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class ComponentSimulationConfig(BaseModel):
+    """Per-component simulation config matching the simulate-component API request schema.
+
+    Runtime-injected fields (workloadId, runId, input, traceId, parentSpanId,
+    folderKey) are supplied at call time. inputSchema and outputSchema can be
+    overridden here; if omitted they are derived from the function annotations.
+    """
+
+    component_id: str = Field(..., alias="componentId")
+    component_type: str | None = Field(None, alias="componentType")
+    component_description: str | None = Field(None, alias="componentDescription")
+    simulation_instruction: str | None = Field(None, alias="simulationInstruction")
+    simulation_strategy: SimulationStrategy = Field(
+        SimulationStrategy.LLM, alias="simulationStrategy"
+    )
+    mock_value: Any = Field(None, alias="mockValue")
+    behaviors: list[SimulationBehavior] | None = None
+    input_schema: dict[str, Any] | None = Field(None, alias="inputSchema")
+    output_schema: dict[str, Any] | None = Field(None, alias="outputSchema")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class MockingContext(BaseModel):
+    """Execution context for mocking, holding strategy and inputs."""
+
+    strategy: MockingStrategy | None
+    inputs: dict[str, Any] = Field(default_factory=lambda: {})
+    name: str = Field(default="debug")
+    # When set, SimulateComponentMocker routes each tool call to the simulate-component API.
+    components: list[ComponentSimulationConfig] | None = None
+    workload_id: str | None = None
+
+
+class SimulationConfig(BaseModel):
+    """Top-level schema for simulation.json / --simulation flag.
+
+    New format (routes to simulate-component API):
+        {
+            "enabled": true,
+            "components": [
+                {
+                    "componentId": "my_tool",
+                    "componentType": "tool",
+                    "simulationStrategy": 0,
+                    "simulationInstruction": "Simulate this tool by..."
+                }
+            ]
+        }
+
+    Legacy format (routes to local LLM mocker):
+        {
+            "enabled": true,
+            "toolsToSimulate": [{"name": "my_tool"}],
+            "instructions": "Simulate these tools by..."
+        }
+    """
+
+    enabled: bool = True
+    # New per-component format — when non-empty, routes to simulate-component API.
+    components: list[ComponentSimulationConfig] = Field(default_factory=list)
+    # Legacy flat format — used when components is empty; routes to local LLM mocker.
+    tools_to_simulate: list[ToolSimulation] = Field(
+        default_factory=list, alias="toolsToSimulate"
+    )
+    instructions: str = ""
+    model: str | None = None
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class ExampleCall(BaseModel):
+    """Example call for a resource containing resource I/O."""
+
+    id: str = Field(..., alias="id")
+    input: str = Field(..., alias="input")
+    output: str = Field(..., alias="output")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
diff --git a/packages/uipath/src/uipath/eval/mocks/mockable.py b/packages/uipath/src/uipath/eval/mocks/mockable.py
new file mode 100644
index 000000000..3e9a324b9
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/mocks/mockable.py
@@ -0,0 +1,116 @@
+"""Mockable interface."""
+
+import asyncio
+import functools
+import inspect
+import logging
+import threading
+from typing import Any
+
+from opentelemetry import trace
+from pydantic import TypeAdapter
+from pydantic_function_models import (  # type: ignore[import-untyped]
+    ValidatedFunction,
+)
+
+from uipath.core.tracing import UiPathSpanUtils
+
+from ._mock_context import get_mocked_response
+from ._mocker import UiPathNoMockFoundError
+from ._types import ExampleCall
+
+_event_loop = None
+logger = logging.getLogger(__name__)
+
+MOCKED_ANNOTATION_KEY = "__uipath_response_mocked"
+
+
+def run_coroutine(coro):
+    """Run a coroutine synchronously."""
+    global _event_loop
+    if not _event_loop or not _event_loop.is_running():
+        _event_loop = asyncio.new_event_loop()
+        threading.Thread(target=_event_loop.run_forever, daemon=True).start()
+    future = asyncio.run_coroutine_threadsafe(coro, _event_loop)
+    return future.result()
+
+
+def mocked_response_decorator(func, params: dict[str, Any]):
+    """Mocked response decorator."""
+
+    async def mock_response_generator(*args, **kwargs):
+        mocked_response = await get_mocked_response(func, params, (args, kwargs))
+
+        # Mocking successful.
+        context = UiPathSpanUtils.get_parent_context()
+        span = trace.get_current_span(context=context)
+        span.set_attribute(MOCKED_ANNOTATION_KEY, True)
+
+        return_type: Any = func.__annotations__.get("return", None)
+
+        if return_type is not None:
+            mocked_response = TypeAdapter(return_type).validate_python(mocked_response)
+        return mocked_response
+
+    is_async = inspect.iscoroutinefunction(func)
+    if is_async:
+
+        @functools.wraps(func)
+        async def decorated_func(*args, **kwargs):
+            try:
+                return await mock_response_generator(*args, **kwargs)
+            except UiPathNoMockFoundError:
+                return await func(*args, **kwargs)
+    else:
+
+        @functools.wraps(func)
+        def decorated_func(*args, **kwargs):
+            try:
+                return run_coroutine(mock_response_generator(*args, **kwargs))
+            except UiPathNoMockFoundError:
+                return func(*args, **kwargs)
+
+    return decorated_func
+
+
+def get_output_schema(func):
+    """Retrieves the JSON schema for a function's return type hint."""
+    try:
+        adapter = TypeAdapter(inspect.signature(func).return_annotation)
+        return adapter.json_schema()
+    except Exception:
+        logger.warning(f"Unable to extract output schema for function {func.__name__}")
+        return {}
+
+
+def get_input_schema(func):
+    """Retrieves the JSON schema for a function's input type."""
+    try:
+        return ValidatedFunction(func).model.model_json_schema()
+    except Exception:
+        logger.warning(f"Unable to extract input schema for function {func.__name__}")
+        return {}
+
+
+def mockable(
+    name: str | None = None,
+    description: str | None = None,
+    input_schema: dict[str, Any] | None = None,
+    output_schema: dict[str, Any] | None = None,
+    example_calls: list[ExampleCall] | None = None,
+    **kwargs,
+):
+    """Decorate a function to be a mockable."""
+
+    def decorator(func):
+        params = {
+            "name": name or func.__name__,
+            "description": description or func.__doc__,
+            "input_schema": input_schema or get_input_schema(func),
+            "output_schema": output_schema or get_output_schema(func),
+            "example_calls": example_calls,
+            **kwargs,
+        }
+        return mocked_response_decorator(func, params)
+
+    return decorator
diff --git a/packages/uipath/src/uipath/eval/models/__init__.py b/packages/uipath/src/uipath/eval/models/__init__.py
new file mode 100644
index 000000000..580ce812a
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/models/__init__.py
@@ -0,0 +1,36 @@
+"""UiPath evaluation module for agent performance assessment."""
+
+from uipath.eval.models.models import (
+    AgentExecution,
+    BooleanEvaluationResult,
+    ErrorEvaluationResult,
+    EvalItemResult,
+    EvaluationResult,
+    EvaluationResultDto,
+    EvaluatorType,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+    LLMResponse,
+    NumericEvaluationResult,
+    ScoreType,
+    ToolCall,
+    ToolOutput,
+)
+
+__all__ = [
+    "AgentExecution",
+    "EvaluationResult",
+    "EvaluationResultDto",
+    "LLMResponse",
+    "LegacyEvaluatorCategory",
+    "LegacyEvaluatorType",
+    "EvaluatorType",
+    "ScoreType",
+    "EvalItemResult",
+    "BooleanEvaluationResult",
+    "NumericEvaluationResult",
+    "ErrorEvaluationResult",
+    "ToolCall",
+    "EvaluatorType",
+    "ToolOutput",
+]
diff --git a/packages/uipath/src/uipath/eval/models/_conversational_utils.py b/packages/uipath/src/uipath/eval/models/_conversational_utils.py
new file mode 100644
index 000000000..9e3523acc
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/models/_conversational_utils.py
@@ -0,0 +1,304 @@
+import uuid
+from datetime import datetime, timezone
+from typing import Any, List, Literal
+
+from pydantic import BaseModel, Field
+
+from uipath.core.chat import (
+    UiPathConversationContentPart,
+    UiPathConversationContentPartData,
+    UiPathConversationMessage,
+    UiPathConversationMessageData,
+    UiPathConversationToolCall,
+    UiPathConversationToolCallData,
+    UiPathConversationToolCallResult,
+    UiPathExternalValue,
+    UiPathInlineValue,
+)
+
+# Types for legacy conversational-agent evaluation input/outputs.
+
+
+class LegacyConversationalEvalJobAttachmentReference(BaseModel):
+    """File attachment reference in eval messages."""
+
+    id: str = Field(..., alias="ID")
+    full_name: str = Field(..., alias="FullName")
+    mime_type: str = Field(..., alias="MimeType")
+
+
+class LegacyConversationalEvalOutputToolCall(BaseModel):
+    """Tool call in eval output schema (no result field)."""
+
+    name: str
+    arguments: dict[str, Any]
+
+
+class LegacyConversationalEvalInputToolCallResult(BaseModel):
+    """Tool call result in eval input schema."""
+
+    value: Any
+    is_error: bool | None = Field(default=None, alias="isError")
+
+
+class LegacyConversationalEvalInputToolCall(LegacyConversationalEvalOutputToolCall):
+    """Tool call in eval input schema (extends output tool call with result)."""
+
+    result: LegacyConversationalEvalInputToolCallResult
+
+
+class LegacyConversationalEvalMessage(BaseModel):
+    """Base eval message type."""
+
+    role: Literal["agent", "user"]
+    text: str
+
+
+class LegacyConversationalEvalUserMessage(LegacyConversationalEvalMessage):
+    """User message in eval schema."""
+
+    role: Literal["user"] = "user"
+    attachments: list[LegacyConversationalEvalJobAttachmentReference] | None = Field(
+        default=None
+    )
+
+
+class LegacyConversationalEvalInputAgentMessage(LegacyConversationalEvalMessage):
+    """Agent message in eval input schema (input tool-calls contain results field)."""
+
+    role: Literal["agent"] = "agent"
+    tool_calls: list[LegacyConversationalEvalInputToolCall] | None = Field(
+        default=None, alias="toolCalls"
+    )
+
+
+class LegacyConversationalEvalOutputAgentMessage(LegacyConversationalEvalMessage):
+    """Agent message in eval output schema (output tool-calls don't contain result field)."""
+
+    role: Literal["agent"] = "agent"
+    tool_calls: list[LegacyConversationalEvalOutputToolCall] | None = Field(
+        default=None, alias="toolCalls"
+    )
+
+
+class LegacyConversationalEvalInput(BaseModel):
+    """Complete conversational eval input schema.
+
+    conversationHistory: Array of exchanges, where each exchange is
+                        [userMessage, ...agentMessages[]]
+    currentUserPrompt: The current user message to evaluate
+    """
+
+    conversation_history: list[
+        list[
+            LegacyConversationalEvalUserMessage
+            | LegacyConversationalEvalInputAgentMessage
+        ]
+    ] = Field(alias="conversationHistory")
+    current_user_prompt: LegacyConversationalEvalUserMessage = Field(
+        alias="currentUserPrompt"
+    )
+
+
+class LegacyConversationalEvalOutput(BaseModel):
+    """Complete eval output schema matching TypeScript definition.
+
+    agentResponse: Sequence of agent messages ending with a message without tool calls
+    """
+
+    agent_response: list[LegacyConversationalEvalOutputAgentMessage] = Field(
+        alias="agentResponse"
+    )
+
+
+# Mapper functions to convert between UiPath standard Message format and legacy conversational formats
+
+
+class UiPathLegacyEvalChatMessagesMapper:
+    @staticmethod
+    def legacy_conversational_eval_input_to_uipath_message_list(
+        eval_input: LegacyConversationalEvalInput,
+    ) -> List[UiPathConversationMessage]:
+        """Convert legacy eval input format to list of UiPathConversationMessage."""
+        messages: List[UiPathConversationMessage] = []
+        timestamp = (
+            datetime.now(timezone.utc)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z")
+        )
+
+        # Process conversation history (list of exchanges)
+        for eval_exchange in eval_input.conversation_history:
+            for eval_message in eval_exchange:
+                if eval_message.role == "user":
+                    # Convert user message
+                    content_parts = (
+                        [
+                            UiPathConversationContentPart(
+                                content_part_id=str(uuid.uuid4()),
+                                mime_type="text/plain",
+                                data=UiPathInlineValue(inline=eval_message.text),
+                                citations=[],
+                                created_at=timestamp,
+                                updated_at=timestamp,
+                            )
+                        ]
+                        if eval_message.text
+                        else []
+                    )
+
+                    if eval_message.attachments:
+                        for attachment in eval_message.attachments:
+                            content_parts.append(
+                                UiPathConversationContentPart(
+                                    content_part_id=str(uuid.uuid4()),
+                                    mime_type=attachment.mime_type,
+                                    data=UiPathExternalValue(
+                                        uri=f"urn:uipath:cas:file:orchestrator:{attachment.id}"
+                                    ),
+                                    name=attachment.full_name,
+                                    citations=[],
+                                    created_at=timestamp,
+                                    updated_at=timestamp,
+                                )
+                            )
+                    messages.append(
+                        UiPathConversationMessage(
+                            message_id=str(uuid.uuid4()),
+                            role="user",
+                            content_parts=content_parts,
+                            tool_calls=[],
+                            created_at=timestamp,
+                            updated_at=timestamp,
+                        )
+                    )
+                elif eval_message.role == "agent":
+                    # Convert agent message
+                    content_parts = (
+                        [
+                            UiPathConversationContentPart(
+                                content_part_id=str(uuid.uuid4()),
+                                mime_type="text/markdown",
+                                data=UiPathInlineValue(inline=eval_message.text),
+                                citations=[],
+                                created_at=timestamp,
+                                updated_at=timestamp,
+                            )
+                        ]
+                        if eval_message.text
+                        else []
+                    )
+
+                    # Convert tool calls if present
+                    tool_calls: List[UiPathConversationToolCall] = []
+                    if eval_message.tool_calls:
+                        for tc in eval_message.tool_calls:
+                            tool_call = UiPathConversationToolCall(
+                                tool_call_id=str(uuid.uuid4()),
+                                name=tc.name,
+                                input=tc.arguments,
+                                timestamp=timestamp,
+                                result=UiPathConversationToolCallResult(
+                                    timestamp=timestamp,
+                                    output=tc.result.value,
+                                    is_error=tc.result.is_error,
+                                ),
+                                created_at=timestamp,
+                                updated_at=timestamp,
+                            )
+                            tool_calls.append(tool_call)
+
+                    messages.append(
+                        UiPathConversationMessage(
+                            message_id=str(uuid.uuid4()),
+                            role="assistant",
+                            content_parts=content_parts,
+                            tool_calls=tool_calls,
+                            created_at=timestamp,
+                            updated_at=timestamp,
+                        )
+                    )
+
+        # Add current user prompt
+        content_parts = (
+            [
+                UiPathConversationContentPart(
+                    content_part_id=str(uuid.uuid4()),
+                    mime_type="text/plain",
+                    data=UiPathInlineValue(inline=eval_input.current_user_prompt.text),
+                    citations=[],
+                    created_at=timestamp,
+                    updated_at=timestamp,
+                )
+            ]
+            if eval_input.current_user_prompt.text
+            else []
+        )
+
+        if eval_input.current_user_prompt.attachments:
+            for attachment in eval_input.current_user_prompt.attachments:
+                content_parts.append(
+                    UiPathConversationContentPart(
+                        content_part_id=str(uuid.uuid4()),
+                        mime_type=attachment.mime_type,
+                        data=UiPathExternalValue(
+                            uri=f"urn:uipath:cas:file:orchestrator:{attachment.id}"
+                        ),
+                        name=attachment.full_name,
+                        citations=[],
+                        created_at=timestamp,
+                        updated_at=timestamp,
+                    )
+                )
+
+        messages.append(
+            UiPathConversationMessage(
+                message_id=str(uuid.uuid4()),
+                role="user",
+                content_parts=content_parts,
+                tool_calls=[],
+                created_at=timestamp,
+                updated_at=timestamp,
+            )
+        )
+
+        return messages
+
+    @staticmethod
+    def legacy_conversational_eval_output_to_uipath_message_data_list(
+        eval_output: LegacyConversationalEvalOutput,
+    ) -> List[UiPathConversationMessageData]:
+        """Convert legacy eval output format to list of UiPathConversationMessageData."""
+        messages: List[UiPathConversationMessageData] = []
+
+        for eval_agent_message in eval_output.agent_response:
+            content_parts = (
+                [
+                    UiPathConversationContentPartData(
+                        mime_type="text/markdown",
+                        data=UiPathInlineValue(inline=eval_agent_message.text),
+                        citations=[],
+                    )
+                ]
+                if eval_agent_message.text
+                else []
+            )
+
+            tool_calls: List[UiPathConversationToolCallData] = []
+            if eval_agent_message.tool_calls:
+                for tc in eval_agent_message.tool_calls:
+                    tool_call = UiPathConversationToolCallData(
+                        name=tc.name,
+                        input=tc.arguments,
+                    )
+                    tool_calls.append(tool_call)
+
+            messages.append(
+                UiPathConversationMessageData(
+                    role="assistant",
+                    content_parts=content_parts,
+                    tool_calls=tool_calls,
+                )
+            )
+
+        return messages
diff --git a/packages/uipath/src/uipath/eval/models/evaluation_set.py b/packages/uipath/src/uipath/eval/models/evaluation_set.py
new file mode 100644
index 000000000..c80da8e14
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/models/evaluation_set.py
@@ -0,0 +1,225 @@
+"""Evaluation set models."""
+
+import re
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic.alias_generators import to_camel
+
+from ..mocks._types import (
+    InputMockingStrategy,
+    MockingStrategy,
+    ToolSimulation,
+)
+from ._conversational_utils import (
+    LegacyConversationalEvalInput,
+    LegacyConversationalEvalOutput,
+)
+
+_GUID_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+    r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+
+
+def normalize_eval_id(value: str) -> str:
+    """Canonicalize a GUID id to lowercase; leave non-GUID ids unchanged.
+
+    GUIDs are case-insensitive, but downstream correlation (selection,
+    span/cache keying) compares ids as plain strings, so a mixed-case id
+    must be normalized at ingestion to stay matchable.
+    """
+    return value.lower() if isinstance(value, str) and _GUID_RE.match(value) else value
+
+
+class EvaluatorReference(BaseModel):
+    """Reference to an evaluator with optional weight.
+
+    Can be constructed from:
+    - A string (evaluator ID): EvaluatorReference(ref="evaluator-id")
+    - A dict with ref and optional weight: EvaluatorReference(ref="evaluator-id", weight=2.0)
+    """
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    ref: str = Field(..., description="Path to the evaluator configuration file")
+    weight: float = Field(
+        default=1.0,
+        description="Weight for this evaluator in scoring calculations",
+        ge=0,
+    )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> Any:
+        """Allow creating EvaluatorReference from a string or dict."""
+        from pydantic_core import core_schema
+
+        def validate_from_str(value: str) -> dict[str, Any]:
+            """Convert a string to a dict with ref field."""
+            return {"ref": value}
+
+        def serialize(instance: "EvaluatorReference") -> Any:
+            if instance.weight != 1.0:
+                return {"ref": instance.ref, "weight": instance.weight}
+            return instance.ref
+
+        python_schema = handler(source_type)
+        return core_schema.union_schema(
+            [
+                core_schema.chain_schema(
+                    [
+                        core_schema.str_schema(),
+                        core_schema.no_info_plain_validator_function(validate_from_str),
+                        python_schema,
+                    ]
+                ),
+                python_schema,
+            ],
+            serialization=core_schema.plain_serializer_function_ser_schema(serialize),
+        )
+
+
+class EvaluationSetModelSettings(BaseModel):
+    """Model setting overrides within evaluation sets with ID."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str = Field(..., alias="id")
+    model_name: str = Field(..., alias="modelName")
+    temperature: float | str | None = Field(default=None, alias="temperature")
+
+
+class EvaluationItem(BaseModel):
+    """Individual evaluation item within an evaluation set."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    id: str
+    name: str
+    inputs: dict[str, Any]
+    expected_output: dict[str, Any] | str | None = Field(
+        default=None, alias="expectedOutput"
+    )
+    evaluation_criterias: dict[str, dict[str, Any] | None] = Field(
+        ..., alias="evaluationCriterias"
+    )
+    expected_agent_behavior: str = Field(default="", alias="expectedAgentBehavior")
+    mocking_strategy: MockingStrategy | None = Field(
+        default=None,
+        alias="mockingStrategy",
+    )
+    input_mocking_strategy: InputMockingStrategy | None = Field(
+        default=None,
+        alias="inputMockingStrategy",
+    )
+
+    @field_validator("id")
+    @classmethod
+    def _normalize_id(cls, value: str) -> str:
+        """Normalize GUID ids to canonical lowercase."""
+        return normalize_eval_id(value)
+
+
+class LegacyEvaluationItem(BaseModel):
+    """Individual evaluation item within an evaluation set."""
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, extra="allow"
+    )
+
+    id: str
+    name: str
+    inputs: dict[str, Any]
+    expected_output: dict[str, Any]
+    expected_agent_behavior: str = Field(default="", alias="expectedAgentBehavior")
+    eval_set_id: str = Field(alias="evalSetId")
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+    simulate_input: bool | None = Field(default=None, alias="simulateInput")
+    input_generation_instructions: str | None = Field(
+        default=None, alias="inputGenerationInstructions"
+    )
+    simulate_tools: bool | None = Field(default=None, alias="simulateTools")
+    simulation_instructions: str | None = Field(
+        default=None, alias="simulationInstructions"
+    )
+    tools_to_simulate: list[ToolSimulation] = Field(
+        default_factory=list, alias="toolsToSimulate"
+    )
+    conversational_inputs: LegacyConversationalEvalInput | None = Field(
+        default=None, alias="conversationalInputs"
+    )
+    conversational_expected_output: LegacyConversationalEvalOutput | None = Field(
+        default=None, alias="conversationalExpectedOutput"
+    )
+
+    @field_validator("id")
+    @classmethod
+    def _normalize_id(cls, value: str) -> str:
+        """Normalize GUID ids to canonical lowercase."""
+        return normalize_eval_id(value)
+
+
+class EvaluationSet(BaseModel):
+    """Complete evaluation set model."""
+
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, extra="allow"
+    )
+
+    id: str
+    name: str
+    version: Literal["1.0"] = "1.0"
+    evaluator_refs: list[str] = Field(default_factory=list)
+    evaluator_configs: list[EvaluatorReference] = Field(
+        default_factory=list, alias="evaluatorConfigs"
+    )
+    evaluations: list[EvaluationItem] = Field(default_factory=list)
+    model_settings: list[EvaluationSetModelSettings] = Field(
+        default_factory=list, alias="modelSettings"
+    )
+
+    def extract_selected_evals(self, eval_ids) -> None:
+        """Filter evaluations to only include those with specified IDs."""
+        selected_evals: list[EvaluationItem] = []
+        remaining_ids = {normalize_eval_id(eval_id) for eval_id in eval_ids}
+        for evaluation in self.evaluations:
+            if evaluation.id in remaining_ids:
+                selected_evals.append(evaluation)
+                remaining_ids.remove(evaluation.id)
+        if len(remaining_ids) > 0:
+            raise ValueError("Unknown evaluation ids: {}".format(remaining_ids))
+        self.evaluations = selected_evals
+
+
+class LegacyEvaluationSet(BaseModel):
+    """Complete evaluation set model."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    id: str
+    file_name: str = Field(..., alias="fileName")
+    evaluator_refs: list[str] = Field(default_factory=list)
+    evaluator_configs: list[EvaluatorReference] = Field(
+        default_factory=list, alias="evaluatorConfigs"
+    )
+    evaluations: list[LegacyEvaluationItem] = Field(default_factory=list)
+    name: str
+    batch_size: int = Field(10, alias="batchSize")
+    timeout_minutes: int = Field(default=20, alias="timeoutMinutes")
+    model_settings: list[EvaluationSetModelSettings] = Field(
+        default_factory=list, alias="modelSettings"
+    )
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+
+    def extract_selected_evals(self, eval_ids) -> None:
+        """Filter evaluations to only include those with specified IDs."""
+        selected_evals: list[LegacyEvaluationItem] = []
+        remaining_ids = {normalize_eval_id(eval_id) for eval_id in eval_ids}
+        for evaluation in self.evaluations:
+            if evaluation.id in remaining_ids:
+                selected_evals.append(evaluation)
+                remaining_ids.remove(evaluation.id)
+        if len(remaining_ids) > 0:
+            raise ValueError("Unknown evaluation ids: {}".format(remaining_ids))
+        self.evaluations = selected_evals
diff --git a/packages/uipath/src/uipath/eval/models/llm_judge_types.py b/packages/uipath/src/uipath/eval/models/llm_judge_types.py
new file mode 100644
index 000000000..9f488bce7
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/models/llm_judge_types.py
@@ -0,0 +1,196 @@
+"""Types for LLM judge evaluators."""
+
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class LLMJudgeOutputSchema(BaseModel):
+    """Schema for LLM judge output."""
+
+    justification: str = Field(
+        ...,
+        description="A clear analysis of the semantic similarity of the input contents that appears BEFORE reaching a numeric score. It must justify every penalty or lenience, and mention the effects of any deviation.",
+    )
+    score: float = Field(
+        ...,
+        description="The final rounded integer between 0 and 100, computed strictly from the rubric in the prompt. It must follow the reasoning and contain only the number-no additional text.",
+    )
+
+
+class LLMJudgeStrictJSONSimilarityOutputSchema(BaseModel):
+    """Schema for LLM judge strict JSON similarity output."""
+
+    justification: str = Field(
+        ...,
+        description="A clear, ≤250-word analysis that appears BEFORE the numeric score. It must discuss every key from ExpectedOutput, state whether each value in ActualOutput is equivalent, partially correct, or incorrect/missing, justify every penalty or lenience, and mention effects of extra keys.",
+    )
+    score: float = Field(
+        ...,
+        description="The final rounded integer between 0 and 100, computed strictly from the rubric in the prompt. It must follow the reasoning and contain only the number—no additional text.",
+    )
+
+
+class LLMJudgeTrajectoryOutputSchema(BaseModel):
+    """Schema for LLM judge trajectory output."""
+
+    justification: str = Field(
+        ...,
+        description="A clear analysis of the similarity between the expected behavior and the actual behavior of the agent that appears BEFORE reaching a numeric score. It must justify every penalty or lenience, and mention the effects of any deviation. Include the expected behavior, and the actual behavior of the agent.",
+    )
+    score: float = Field(
+        ...,
+        description="The final rounded integer between 0 and 100, computed strictly from the rubric in the prompt. It must follow the reasoning and contain only the number—no additional text.",
+    )
+
+
+class LLMJudgePromptTemplates(str, Enum):
+    """Templates for LLM judge prompts."""
+
+    LLM_JUDGE_SYSTEM_PROMPT = """You are an expert evaluator tasked with assessing text based on specific criteria. You will be given:
+1. An evaluation criterion or question.
+2. A text to evaluate.
+Your task is to carefully analyze the given text according to the specified criterion.
+If the criterion asks for a degree or extent, respond with a numerical score from 0 to 100:
+0 means the text does not meet the criterion at all.
+100 means the text fully meets the criterion.
+If the criterion is a yes/no question or can be answered with true/false, respond with a boolean: true or false.
+To submit your evaluation, use the correct tool for the score type.
+Never answer using text. Only use the tool to submit your score.
+"""
+
+    LLM_JUDGE_DEFAULT_USER_PROMPT = """As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
+----
+ExpectedOutput:
+{{ExpectedOutput}}
+----
+ActualOutput:
+{{ActualOutput}}"""
+
+    LLM_JUDGE_STRICT_JSON_SIMILARITY_SYSTEM_PROMPT = """You are an impartial grading agent.
+
+⚠️ STEP 1: MANDATORY KEY INVENTORY (EXACT COUNTING)
+List the exact top-level keys by copying them character-for-character:
+
+Expected keys: ['key1', 'key2', 'key3', ...]
+Actual keys: ['key1', 'key2', ...]
+N (total expected keys): [exact integer]
+
+⚠️ STEP 2: DETERMINISTIC KEY MATCHING
+For each expected key, check if EXACTLY THE SAME key name exists in actual output:
+
+Expected Key 'KeyName1': EXISTS in actual? [YES/NO]
+Expected Key 'KeyName2': EXISTS in actual? [YES/NO]
+[Continue for all expected keys]
+
+⚠️ STEP 3: EXTRA KEY IDENTIFICATION
+List any actual keys not in expected:
+Extra keys: ['extrakey1', 'extrakey2', ...] or [NONE]
+
+⚠️ STEP 4: CONTENT ASSESSMENT (ONLY FOR MATCHING KEYS)
+For keys that exist in both (from Step 2), assess content:
+Key 'KeyName': Content assessment [IDENTICAL/SIMILAR/DIFFERENT]
+[Only assess keys that showed YES in Step 2]
+
+⚠️ STEP 5: MECHANICAL SCORING
+Apply these exact penalties:
+- Missing key (not in actual): 100/N points each
+- Similar key (exists with similar content): 50/N points each
+- Wrong key (exists but SIGNIFICANTLY different content): 100/N points each
+- Identical key (exists with IDENTICAL content): 0 points each
+- Extra key (in actual but not expected): 10/N points each
+
+⚠️ MECHANICAL CATEGORIZATION:
+Based on Steps 1-4, categorize each expected key:
+
+1. 'ExpectedKey1' → [MISSING/WRONG/SIMILAR/IDENTICAL] → Penalty: [calculation]
+2. 'ExpectedKey2' → [MISSING/WRONG/SIMILAR/IDENTICAL] → Penalty: [calculation]
+[Continue for all expected keys]
+
+Extra keys: [count] × (10/N) = [calculation]
+
+⚠️ EXACT ARITHMETIC:
+Penalty calculations (show all work):
+- N = [number]
+- Missing keys: [count] × (100/[N]) = [count] × [decimal] = [total]
+- Wrong keys: [count] × (100/[N]) = [count] × [decimal] = [total]
+- Similar keys: [count] × (50/[N]) = [count] × [decimal] = [total]
+- Extra keys: [count] × (10/[N]) = [count] × [decimal] = [total]
+
+Total penalty: [sum all penalties] = [final penalty]
+Final score: 100 - [final penalty] = [score] (minimum 0)
+
+⚠️ VERIFICATION CHECKLIST:
+- Did I count N correctly by listing all expected keys?
+- Did I check EXACT key name matches (character-for-character)?
+- Did I only assess content for keys that exist in both?
+- Did I calculate exact penalty fractions (100/N, not 100)?
+- Did I show all arithmetic work step by step?
+- Is my final score between 0 and 100?
+
+⚠️ CRITICAL RULES FOR CONSISTENCY:
+- NEVER use semantic interpretation for key names (must be exact match)
+- NEVER assess content for missing keys
+- ALWAYS calculate penalties as fractions of N
+- ALWAYS show exact arithmetic work
+- IDENTICAL inputs MUST produce IDENTICAL outputs.
+
+⚠️ DETERMINISTIC REQUIREMENTS:
+• Key matching is purely textual (character-by-character comparison)
+• Content assessment is only for keys that exist in both outputs
+• All arithmetic must be shown with exact fractions"""
+
+    LLM_JUDGE_STRICT_JSON_SIMILARITY_DEFAULT_USER_PROMPT = """ExpectedOutput (ground truth):\n{{ExpectedOutput}}\n\nActualOutput (model answer):\n{{ActualOutput}}"""
+
+    LLM_JUDGE_SIMULATION_TRAJECTORY_SYSTEM_PROMPT = """You are an expert evaluator tasked with assessing an agent running through a simulation.
+The simulation engine was used to mock the tool responses given during the agent run based on the simulation instructions.
+The agent did not know that the tool responses are simulated.
+You will be given:
+1. The instructions the simulation engine was given to mock the tool responses given during the agent run.
+2. Expected behavior for the agent during the simulation.
+3. A trace/history of the agent run.
+4. The agent configuration used during the run.
+Your task is to carefully analyze the agent run trace and it's output according to the specified criterion.
+0 means the agent did not meet the criterion at all.
+100 means the agent fully met the criterion.
+To submit your evaluation, use the correct tool for the score type.
+Never answer using text. Only use the tool to submit your score.
+"""
+
+    LLM_JUDGE_SIMULATION_TRAJECTORY_DEFAULT_USER_PROMPT = """As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
+----
+AgentInput:
+{{UserOrSyntheticInput}}
+----
+SimulationInstructions:
+{{SimulationInstructions}}
+----
+ExpectedAgentBehavior:
+{{ExpectedAgentBehavior}}
+----
+AgentRunHistory:
+{{AgentRunHistory}}
+"""
+
+    LLM_JUDGE_TRAJECTORY_SYSTEM_PROMPT = """You are an expert evaluator tasked with assessing an agent's behavior based on its execution trajectory in a simulation or real environment.
+You will be given:
+1.	Expected behavior for the agent during the run.
+2.	A trace/history of the agent's actions and outputs.
+3.	The agent configuration used during the run.
+Your task is to carefully analyze the agent's trajectory and output according to the specified criterion.
+A score of 0 means the agent did not meet the criterion at all, while 100 means the agent fully met the criterion.
+To submit your evaluation, use the correct tool for the score type.
+Never answer using text. Only use the tool to submit your score.
+"""
+
+    LLM_JUDGE_TRAJECTORY_DEFAULT_USER_PROMPT = """As an expert evaluator, determine how well the agent performed on a scale of 0-100. Focus on whether the agent's actions and outputs matched the expected behavior, while allowing for alternative valid expressions and reasonable variations in language. Maintain high standards for accuracy and completeness. Provide your score with a brief and clear justification explaining your reasoning.
+----
+AgentInput:
+{{UserOrSyntheticInput}}
+----
+ExpectedAgentBehavior:
+{{ExpectedAgentBehavior}}
+----
+AgentRunHistory:
+{{AgentRunHistory}}
+"""
diff --git a/packages/uipath/src/uipath/eval/models/models.py b/packages/uipath/src/uipath/eval/models/models.py
new file mode 100644
index 000000000..14c130c92
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/models/models.py
@@ -0,0 +1,390 @@
+"""Models for evaluation framework including execution data and evaluation results."""
+
+import traceback
+from dataclasses import dataclass
+from enum import Enum, IntEnum
+from typing import Annotated, Any, Literal, Union
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, ConfigDict, Field, model_serializer
+from pydantic.alias_generators import to_camel
+from pydantic_core import core_schema
+
+
+class AgentExecution(BaseModel):
+    """Represents the execution data of an agent for evaluation purposes."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    agent_input: dict[str, Any] | None
+    agent_output: dict[str, Any] | str
+    agent_trace: list[ReadableSpan]
+    expected_agent_behavior: str | None = None
+    simulation_instructions: str = ""
+
+
+class LLMResponse(BaseModel):
+    """Response from an LLM evaluator."""
+
+    score: float
+    justification: str
+
+
+class ScoreType(IntEnum):
+    """Types of evaluation scores."""
+
+    BOOLEAN = 0
+    NUMERICAL = 1
+    ERROR = 2
+
+
+class BaseEvaluationResult(BaseModel):
+    """Base class for evaluation results."""
+
+    details: str | BaseModel | None = None
+    # this is marked as optional, as it is populated inside the 'measure_execution_time' decorator
+    evaluation_time: float | None = None
+
+
+class BooleanEvaluationResult(BaseEvaluationResult):
+    """Result of a boolean evaluation."""
+
+    score: bool
+    score_type: Literal[ScoreType.BOOLEAN] = ScoreType.BOOLEAN
+
+
+class NumericEvaluationResult(BaseEvaluationResult):
+    """Result of a numerical evaluation."""
+
+    score: float
+    score_type: Literal[ScoreType.NUMERICAL] = ScoreType.NUMERICAL
+
+
+class ErrorEvaluationResult(BaseEvaluationResult):
+    """Result of an error evaluation."""
+
+    score: float = 0.0
+    score_type: Literal[ScoreType.ERROR] = ScoreType.ERROR
+
+
+EvaluationResult = Annotated[
+    Union[BooleanEvaluationResult, NumericEvaluationResult, ErrorEvaluationResult],
+    Field(discriminator="score_type"),
+]
+
+
+class EvaluationResultDto(BaseModel):
+    """Serializable evaluation result used for aggregation and transport."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    score: float
+    details: str | dict[str, Any] | None = None
+    evaluation_time: float | None = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(
+        self,
+        serializer: core_schema.SerializerFunctionWrapHandler,
+        info: core_schema.SerializationInfo,
+    ) -> Any:
+        """Omit 'details' key from serialized output when it is None."""
+        data = serializer(self)
+        if self.details is None and isinstance(data, dict):
+            data.pop("details", None)
+        return data
+
+    @classmethod
+    def from_evaluation_result(
+        cls, evaluation_result: EvaluationResult
+    ) -> "EvaluationResultDto":
+        """Convert an EvaluationResult to a serializable DTO."""
+        score_type = evaluation_result.score_type
+        score: float
+        if score_type == ScoreType.BOOLEAN:
+            score = 100 if evaluation_result.score else 0
+        elif score_type == ScoreType.ERROR:
+            score = 0
+        else:
+            score = evaluation_result.score
+
+        # Convert BaseModel details to dict so Pydantic doesn't lose subclass fields
+        if isinstance(evaluation_result.details, BaseModel):
+            details: str | dict[str, Any] | None = (
+                evaluation_result.details.model_dump()
+            )
+        else:
+            details = evaluation_result.details
+
+        return cls(
+            score=score,
+            details=details,
+            evaluation_time=evaluation_result.evaluation_time,
+        )
+
+
+class EvalItemResult(BaseModel):
+    """Result of a single evaluation item."""
+
+    evaluator_id: str
+    result: EvaluationResult
+
+
+class LegacyEvaluatorCategory(IntEnum):
+    """Types of evaluators."""
+
+    Deterministic = 0
+    LlmAsAJudge = 1
+    AgentScorer = 2
+    Trajectory = 3
+
+    @classmethod
+    def from_int(cls, value: int) -> "LegacyEvaluatorCategory":
+        """Construct EvaluatorCategory from an int value."""
+        if value in cls._value2member_map_:
+            return cls(value)
+        else:
+            raise ValueError(f"{value} is not a valid EvaluatorCategory value")
+
+
+class LegacyEvaluatorType(IntEnum):
+    """Subtypes of evaluators."""
+
+    Unknown = 0
+    Equals = 1
+    Contains = 2
+    Regex = 3
+    Factuality = 4
+    Custom = 5
+    JsonSimilarity = 6
+    Trajectory = 7
+    ContextPrecision = 8
+    Faithfulness = 9
+    CSVColumnExactMatch = 10
+
+    @classmethod
+    def from_int(cls, value: int) -> "LegacyEvaluatorType":
+        """Construct EvaluatorCategory from an int value."""
+        if value in cls._value2member_map_:
+            return cls(value)
+        else:
+            raise ValueError(f"{value} is not a valid EvaluatorType value")
+
+
+@dataclass
+class TrajectoryEvaluationSpan:
+    """Simplified span representation for trajectory evaluation.
+
+    Contains span information needed for evaluating agent execution paths,
+    excluding timestamps which are not useful for trajectory analysis.
+    """
+
+    name: str
+    status: str
+    attributes: dict[str, Any]
+    parent_name: str | None = None
+    events: list[dict[str, Any]] | None = None
+
+    def __post_init__(self):
+        """Initialize default values."""
+        if self.events is None:
+            self.events = []
+
+    @classmethod
+    def from_readable_span(
+        cls, span: ReadableSpan, parent_spans: dict[int, str] | None = None
+    ) -> "TrajectoryEvaluationSpan":
+        """Convert a ReadableSpan to a TrajectoryEvaluationSpan.
+
+        Args:
+            span: The OpenTelemetry ReadableSpan to convert
+            parent_spans: Optional mapping of span IDs to names for parent lookup
+
+        Returns:
+            TrajectoryEvaluationSpan with relevant data extracted
+        """
+        # Extract status
+        status_map = {0: "unset", 1: "ok", 2: "error"}
+        status = status_map.get(span.status.status_code.value, "unknown")
+
+        # Extract attributes - keep all attributes for now
+        attributes = {}
+        if span.attributes:
+            attributes = dict(span.attributes)
+
+        # Get parent name if available
+        parent_name = None
+        if span.parent and parent_spans and span.parent.span_id in parent_spans:
+            parent_name = parent_spans[span.parent.span_id]
+
+        # Extract events (without timestamps)
+        events = []
+        if hasattr(span, "events") and span.events:
+            for event in span.events:
+                event_data = {
+                    "name": event.name,
+                    "attributes": dict(event.attributes) if event.attributes else {},
+                }
+                events.append(event_data)
+
+        return cls(
+            name=span.name,
+            status=status,
+            attributes=attributes,
+            parent_name=parent_name,
+            events=events,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "name": self.name,
+            "status": self.status,
+            "parent_name": self.parent_name,
+            "attributes": self.attributes,
+            "events": self.events,
+        }
+
+
+class TrajectoryEvaluationTrace(BaseModel):
+    """Container for a collection of trajectory evaluation spans."""
+
+    spans: list[TrajectoryEvaluationSpan]
+
+    @classmethod
+    def from_readable_spans(
+        cls, spans: list[ReadableSpan]
+    ) -> "TrajectoryEvaluationTrace":
+        """Convert a list of ReadableSpans to TrajectoryEvaluationTrace.
+
+        Args:
+            spans: List of OpenTelemetry ReadableSpans to convert
+
+        Returns:
+            TrajectoryEvaluationTrace with converted spans
+        """
+        # Create a mapping of span IDs to names for parent lookup
+        span_id_to_name = {
+            span.get_span_context().span_id: span.name  # pyright: ignore[reportOptionalMemberAccess]
+            for span in spans
+            if span.get_span_context() is not None
+        }
+
+        evaluation_spans = [
+            TrajectoryEvaluationSpan.from_readable_span(span, span_id_to_name)
+            for span in spans
+        ]
+
+        return cls(spans=evaluation_spans)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class EvaluatorType(str, Enum):
+    """Evaluator type."""
+
+    CONTAINS = "uipath-contains"
+    EXACT_MATCH = "uipath-exact-match"
+    JSON_SIMILARITY = "uipath-json-similarity"
+    LLM_JUDGE_OUTPUT_SEMANTIC_SIMILARITY = "uipath-llm-judge-output-semantic-similarity"
+    LLM_JUDGE_OUTPUT_STRICT_JSON_SIMILARITY = (
+        "uipath-llm-judge-output-strict-json-similarity"
+    )
+    LLM_JUDGE_TRAJECTORY_SIMILARITY = "uipath-llm-judge-trajectory-similarity"
+    LLM_JUDGE_TRAJECTORY_SIMULATION = "uipath-llm-judge-trajectory-simulation"
+    LLM_JUDGE_TRAJECTORY = "uipath-llm-judge-trajectory"
+    LLM_JUDGE_OUTPUT = "uipath-llm-judge-output"
+    TOOL_CALL_ARGS = "uipath-tool-call-args"
+    TOOL_CALL_COUNT = "uipath-tool-call-count"
+    TOOL_CALL_ORDER = "uipath-tool-call-order"
+    TOOL_CALL_OUTPUT = "uipath-tool-call-output"
+    BINARY_CLASSIFICATION = "uipath-binary-classification"
+    MULTICLASS_CLASSIFICATION = "uipath-multiclass-classification"
+
+
+class ToolCall(BaseModel):
+    """Represents a tool call with its arguments.
+
+    `id` is the stable identifier from the tool's resource definition (e.g. a
+    UUID from `bindings.json`). When present on both the actual call and the
+    expected criterion, scorers match by `id` so a rename of `name` does not
+    break eval sets. When `id` is absent on either side, scorers fall back to
+    matching by `name` (the legacy behavior).
+    """
+
+    name: str
+    args: dict[str, Any]
+    id: str | None = None
+
+
+class ToolOutput(BaseModel):
+    """Represents a tool output with its output.
+
+    See `ToolCall.id` for the id semantics.
+    """
+
+    name: str
+    output: str
+    id: str | None = None
+
+
+class UiPathEvaluationErrorCategory(str, Enum):
+    """Categories of evaluation errors."""
+
+    SYSTEM = "System"
+    USER = "User"
+    UNKNOWN = "Unknown"
+
+
+class UiPathEvaluationErrorContract(BaseModel):
+    """Standard error contract used across the runtime."""
+
+    code: str  # Human-readable code uniquely identifying this error type across the platform.
+    # Format: <Component>.<PascalCaseErrorCode> (e.g. LangGraph.InvaliGraphReference)
+    # Only use alphanumeric characters [A-Za-z0-9] and periods. No whitespace allowed.
+
+    title: str  # Short, human-readable summary of the problem that should remain consistent
+    # across occurrences.
+
+    detail: (
+        str  # Human-readable explanation specific to this occurrence of the problem.
+    )
+    # May include context, recommended actions, or technical details like call stacks
+    # for technical users.
+
+    category: UiPathEvaluationErrorCategory = UiPathEvaluationErrorCategory.UNKNOWN
+
+
+class UiPathEvaluationError(Exception):
+    """Base exception class for UiPath evaluation errors with structured error information."""
+
+    def __init__(
+        self,
+        code: str,
+        title: str,
+        detail: str,
+        category: UiPathEvaluationErrorCategory = UiPathEvaluationErrorCategory.UNKNOWN,
+        prefix: str = "Python",
+        include_traceback: bool = True,
+    ):
+        """Initialize the UiPathEvaluationError."""
+        # Get the current traceback as a string
+        if include_traceback:
+            tb = traceback.format_exc()
+            if (
+                tb and tb.strip() != "NoneType: None"
+            ):  # Ensure there's an actual traceback
+                detail = f"{detail}\n\n{tb}"
+
+        self.error_info = UiPathEvaluationErrorContract(
+            code=f"{prefix}.{code}",
+            title=title,
+            detail=detail,
+            category=category,
+        )
+        super().__init__(detail)
+
+    @property
+    def as_dict(self) -> dict[str, Any]:
+        """Get the error information as a dictionary."""
+        return self.error_info.model_dump()
diff --git a/packages/uipath/src/uipath/eval/runtime/__init__.py b/packages/uipath/src/uipath/eval/runtime/__init__.py
new file mode 100644
index 000000000..e56ebaf31
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/__init__.py
@@ -0,0 +1,15 @@
+"""Evaluation runtime."""
+
+from ._evaluate import evaluate
+from ._types import UiPathEvalOutput, UiPathEvalRunResult, UiPathEvalRunResultDto
+from .context import UiPathEvalContext
+from .runtime import UiPathEvalRuntime
+
+__all__ = [
+    "UiPathEvalContext",
+    "UiPathEvalRuntime",
+    "UiPathEvalRunResult",
+    "UiPathEvalRunResultDto",
+    "UiPathEvalOutput",
+    "evaluate",
+]
diff --git a/packages/uipath/src/uipath/eval/runtime/_evaluate.py b/packages/uipath/src/uipath/eval/runtime/_evaluate.py
new file mode 100644
index 000000000..e82274a75
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_evaluate.py
@@ -0,0 +1,27 @@
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.runtime import (
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeResult,
+)
+
+from .context import UiPathEvalContext
+from .runtime import UiPathEvalRuntime
+
+
+async def evaluate(
+    runtime_factory: UiPathRuntimeFactoryProtocol,
+    trace_manager: UiPathTraceManager,
+    eval_context: UiPathEvalContext,
+    event_bus: EventBus,
+) -> UiPathRuntimeResult:
+    """Main entry point for evaluation execution."""
+    async with UiPathEvalRuntime(
+        factory=runtime_factory,
+        context=eval_context,
+        trace_manager=trace_manager,
+        event_bus=event_bus,
+    ) as eval_runtime:
+        results = await eval_runtime.execute()
+        await event_bus.wait_for_all(timeout=10)
+        return results
diff --git a/packages/uipath/src/uipath/eval/runtime/_exporters.py b/packages/uipath/src/uipath/eval/runtime/_exporters.py
new file mode 100644
index 000000000..ecbbedff7
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_exporters.py
@@ -0,0 +1,98 @@
+import logging
+from collections import defaultdict
+from typing import Sequence
+
+from opentelemetry import context as context_api
+from opentelemetry.sdk.trace import ReadableSpan, Span
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+from uipath.core.tracing.processors import UiPathExecutionBatchTraceProcessor
+from uipath.runtime.logging import UiPathRuntimeExecutionLogHandler
+
+from .._execution_context import ExecutionSpanCollector, execution_id_context
+
+
+class ExecutionSpanExporter(SpanExporter):
+    """Custom exporter that stores spans grouped by execution ids."""
+
+    def __init__(self):
+        # { execution_id -> list of spans }
+        self._spans: dict[str, list[ReadableSpan]] = defaultdict(list)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        for span in spans:
+            if span.attributes is not None:
+                exec_id = span.attributes.get("execution.id")
+                if exec_id is not None and isinstance(exec_id, str):
+                    self._spans[exec_id].append(span)
+
+        return SpanExportResult.SUCCESS
+
+    def get_spans(self, execution_id: str) -> list[ReadableSpan]:
+        """Retrieve spans for a given execution id."""
+        return self._spans.get(execution_id, [])
+
+    def clear(self, execution_id: str | None = None) -> None:
+        """Clear stored spans for one or all executions."""
+        if execution_id:
+            self._spans.pop(execution_id, None)
+        else:
+            self._spans.clear()
+
+    def shutdown(self) -> None:
+        self.clear()
+
+
+class ExecutionSpanProcessor(UiPathExecutionBatchTraceProcessor):
+    """Span processor that adds spans to ExecutionSpanCollector when they start."""
+
+    def __init__(self, span_exporter: SpanExporter, collector: ExecutionSpanCollector):
+        super().__init__(span_exporter)
+        self.collector = collector
+
+    def on_start(
+        self, span: Span, parent_context: context_api.Context | None = None
+    ) -> None:
+        super().on_start(span, parent_context)
+
+        exec_id = span.attributes.get("execution.id") if span.attributes else None
+
+        # Fallback: if execution.id wasn't propagated (e.g., NonRecordingSpan
+        # parent on resume), get it from the execution context variable.
+        if exec_id is None:
+            ctx_exec_id = execution_id_context.get()
+            if ctx_exec_id:
+                span.set_attribute("execution.id", ctx_exec_id)
+                exec_id = ctx_exec_id
+
+        if span.attributes and "execution.id" in span.attributes:
+            exec_id = span.attributes["execution.id"]
+            if isinstance(exec_id, str):
+                self.collector.add_span(span, exec_id)
+
+
+class ExecutionLogsExporter:
+    """Custom exporter that stores multiple execution log handlers."""
+
+    def __init__(self):
+        self._log_handlers: dict[str, UiPathRuntimeExecutionLogHandler] = {}
+
+    def register(
+        self, execution_id: str, handler: UiPathRuntimeExecutionLogHandler
+    ) -> None:
+        self._log_handlers[execution_id] = handler
+
+    def get_logs(self, execution_id: str) -> list[logging.LogRecord]:
+        """Clear stored spans for one or all executions."""
+        log_handler = self._log_handlers.get(execution_id)
+        return log_handler.buffer if log_handler else []
+
+    def clear(self, execution_id: str | None = None) -> None:
+        """Clear stored spans for one or all executions."""
+        if execution_id:
+            self._log_handlers.pop(execution_id, None)
+        else:
+            self._log_handlers.clear()
diff --git a/packages/uipath/src/uipath/eval/runtime/_parallelization.py b/packages/uipath/src/uipath/eval/runtime/_parallelization.py
new file mode 100644
index 000000000..6dabe2ad2
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_parallelization.py
@@ -0,0 +1,60 @@
+import asyncio
+from typing import Awaitable, Iterable, TypeVar
+
+T = TypeVar("T")
+
+
+async def execute_parallel(
+    evaluation_result_iterable: Iterable[Awaitable[T]],
+    workers: int,
+) -> list[T]:
+    # Create a queue with max concurrency
+    queue: asyncio.Queue[tuple[int, Awaitable[T]] | None] = asyncio.Queue(
+        maxsize=workers
+    )
+
+    # Dictionary to store results with their original indices
+    results_dict: dict[int, T] = {}
+
+    # Producer task to fill the queue
+    async def producer() -> None:
+        for index, eval_item in enumerate(evaluation_result_iterable):
+            await queue.put((index, eval_item))
+        # Signal completion by putting None markers
+        for _ in range(workers):
+            await queue.put(None)
+
+    # Worker function to process items from the queue
+    async def worker(worker_id: int) -> None:
+        while True:
+            item = await queue.get()
+
+            # Check for termination signal
+            if item is None:
+                queue.task_done()
+                break
+
+            index, eval_item = item
+
+            try:
+                # Execute the evaluation
+                result = await eval_item
+
+                # Store result with its index to maintain order
+                results_dict[index] = result
+            finally:
+                # Mark the task as done
+                queue.task_done()
+
+    # Start producer
+    producer_task = asyncio.create_task(producer())
+
+    # Create worker tasks based on workers
+    worker_tasks = [asyncio.create_task(worker(i)) for i in range(workers)]
+
+    # Wait for producer and all workers to complete
+    await producer_task
+    await asyncio.gather(*worker_tasks)
+
+    # Return results in the original order
+    return [results_dict[i] for i in range(len(results_dict))]
diff --git a/packages/uipath/src/uipath/eval/runtime/_spans.py b/packages/uipath/src/uipath/eval/runtime/_spans.py
new file mode 100644
index 000000000..6f492388e
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_spans.py
@@ -0,0 +1,441 @@
+"""Helpers for serializing, deserializing, and configuring OpenTelemetry spans."""
+
+import json
+import logging
+from typing import Any
+
+from opentelemetry.sdk.trace import Event, ReadableSpan
+from opentelemetry.trace import (
+    Span,
+    SpanContext,
+    SpanKind,
+    Status,
+    StatusCode,
+    TraceFlags,
+)
+from pydantic import BaseModel, ConfigDict, Field
+
+from uipath.runtime import UiPathRuntimeStorageProtocol
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+logger = logging.getLogger(__name__)
+
+
+# --- Serialization / Deserialization ---
+
+
+def serialize_span(span: ReadableSpan) -> dict[str, Any]:
+    """Serialize a ReadableSpan to a JSON-compatible dict for storage."""
+    ctx = span.context
+    context_data = None
+    if ctx:
+        context_data = {
+            "trace_id": ctx.trace_id,
+            "span_id": ctx.span_id,
+            "trace_flags": int(ctx.trace_flags),
+        }
+
+    parent_data = None
+    if span.parent:
+        parent_data = {
+            "trace_id": span.parent.trace_id,
+            "span_id": span.parent.span_id,
+            "trace_flags": int(span.parent.trace_flags),
+        }
+
+    attrs: dict[str, Any] = {}
+    if span.attributes:
+        for k, v in span.attributes.items():
+            attrs[k] = list(v) if isinstance(v, tuple) else v
+
+    events_data = []
+    if span.events:
+        for e in span.events:
+            event_attrs: dict[str, Any] = {}
+            if e.attributes:
+                for k, v in e.attributes.items():
+                    event_attrs[k] = list(v) if isinstance(v, tuple) else v
+            events_data.append(
+                {
+                    "name": e.name,
+                    "attributes": event_attrs,
+                    "timestamp": e.timestamp,
+                }
+            )
+
+    return {
+        "name": span.name,
+        "context": context_data,
+        "parent": parent_data,
+        "attributes": attrs,
+        "events": events_data,
+        "status_code": span.status.status_code.value if span.status else 0,
+        "status_description": span.status.description if span.status else None,
+        "start_time": span.start_time,
+        "end_time": span.end_time,
+        "kind": span.kind.value if span.kind else 0,
+    }
+
+
+def deserialize_span(data: dict[str, Any]) -> ReadableSpan:
+    """Deserialize a dict back to a ReadableSpan."""
+    context = None
+    if data.get("context"):
+        context = SpanContext(
+            trace_id=data["context"]["trace_id"],
+            span_id=data["context"]["span_id"],
+            is_remote=False,
+            trace_flags=TraceFlags(data["context"].get("trace_flags", 0)),
+        )
+
+    parent = None
+    if data.get("parent"):
+        parent = SpanContext(
+            trace_id=data["parent"]["trace_id"],
+            span_id=data["parent"]["span_id"],
+            is_remote=False,
+            trace_flags=TraceFlags(data["parent"].get("trace_flags", 0)),
+        )
+
+    status = Status(
+        status_code=StatusCode(data.get("status_code", 0)),
+        description=data.get("status_description"),
+    )
+
+    events = []
+    for e in data.get("events", []):
+        events.append(
+            Event(
+                name=e["name"],
+                attributes=e.get("attributes"),
+                timestamp=e.get("timestamp"),
+            )
+        )
+
+    return ReadableSpan(
+        name=data["name"],
+        context=context,
+        parent=parent,
+        attributes=data.get("attributes"),
+        events=events,
+        status=status,
+        start_time=data.get("start_time"),
+        end_time=data.get("end_time"),
+        kind=SpanKind(data.get("kind", 0)),
+    )
+
+
+async def save_execution_spans(
+    storage: UiPathRuntimeStorageProtocol,
+    execution_id: str,
+    eval_item_id: str,
+    spans: list[ReadableSpan],
+) -> None:
+    """Save execution spans to storage so they survive across suspend/resume."""
+    serialized = [serialize_span(s) for s in spans]
+    await storage.set_value(
+        runtime_id=execution_id,
+        namespace="eval_execution_spans",
+        key=eval_item_id,
+        value={"spans": serialized},
+    )
+    logger.info(f"Saved {len(spans)} execution spans for eval_item {eval_item_id}")
+
+
+async def load_execution_spans(
+    storage: UiPathRuntimeStorageProtocol,
+    execution_id: str,
+    eval_item_id: str,
+) -> list[ReadableSpan]:
+    """Load saved execution spans from storage after resume."""
+    data = await storage.get_value(
+        runtime_id=execution_id,
+        namespace="eval_execution_spans",
+        key=eval_item_id,
+    )
+    if not data or "spans" not in data:
+        return []
+    spans = [deserialize_span(s) for s in data["spans"]]
+    logger.info(
+        f"Loaded {len(spans)} saved execution spans for eval_item {eval_item_id}"
+    )
+    return spans
+
+
+# --- Span attribute configuration ---
+
+
+class EvalSetRunOutput(BaseModel):
+    """Output model for Evaluation Set Run span."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    scores: dict[str, float] = Field(..., alias="scores")
+
+
+class EvaluationOutput(BaseModel):
+    """Output model for Evaluation span."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    scores: dict[str, float] = Field(..., alias="scores")
+
+
+class EvaluationOutputSpanOutput(BaseModel):
+    """Output model for Evaluation output span."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    type: int = Field(1, alias="type")
+    score: float = Field(..., alias="score")
+    evaluator_id: str | None = Field(None, alias="evaluatorId")
+    justification: str | None = Field(None, alias="justification")
+
+
+def normalize_score_to_100(score: float) -> float:
+    """Normalize score to 0-100 range.
+
+    Args:
+        score: Score value (can be 0-1 or 0-100)
+
+    Returns:
+        Score normalized to 0-100 range
+    """
+    # If score is between 0-1, scale to 0-100
+    if 0 <= score <= 1:
+        return round(score * 100, 2)
+    # Otherwise assume it's already 0-100
+    return round(min(max(score, 0), 100), 2)
+
+
+def extract_evaluator_scores(evaluation_run_results: Any) -> dict[str, float]:
+    """Extract scores per evaluator from evaluation run results.
+
+    Args:
+        evaluation_run_results: UiPathEvalRunResult object containing evaluation results
+
+    Returns:
+        Dictionary mapping evaluator names to their normalized scores (0-100)
+    """
+    scores: dict[str, float] = {}
+    if not evaluation_run_results.evaluation_run_results:
+        return scores
+
+    for result in evaluation_run_results.evaluation_run_results:
+        evaluator_name = result.evaluator_name
+        score = result.result.score
+        scores[evaluator_name] = normalize_score_to_100(score)
+
+    return scores
+
+
+def set_eval_set_run_output_and_metadata(
+    span: Span,
+    evaluator_scores: dict[str, float],
+    execution_id: str,
+    input_schema: dict[str, Any] | None,
+    output_schema: dict[str, Any] | None,
+    success: bool = True,
+) -> None:
+    """Set output and metadata attributes for Evaluation Set Run span.
+
+    Args:
+        span: The OpenTelemetry span to set attributes on
+        evaluator_scores: Dictionary mapping evaluator names to their average scores (0-100)
+        execution_id: The execution ID for the evaluation set run
+        input_schema: The input schema from the runtime
+        output_schema: The output schema from the runtime
+        success: Whether the evaluation set run was successful
+    """
+    # Set span output with scores per evaluator using Pydantic model (formatted for UI rendering)
+    output = EvalSetRunOutput(scores=evaluator_scores)
+    span.set_attribute("output", output.model_dump_json(by_alias=True, indent=2))
+
+    # Set metadata attributes
+    span.set_attribute("agentId", execution_id)
+    span.set_attribute("agentName", "N/A")
+
+    # Set schemas as formatted JSON strings for proper rendering in UI
+    if input_schema:
+        try:
+            span.set_attribute("inputSchema", json.dumps(input_schema, indent=2))
+        except (TypeError, ValueError):
+            span.set_attribute("inputSchema", "{}")
+    else:
+        span.set_attribute("inputSchema", "{}")
+
+    if output_schema:
+        try:
+            span.set_attribute("outputSchema", json.dumps(output_schema, indent=2))
+        except (TypeError, ValueError):
+            span.set_attribute("outputSchema", "{}")
+    else:
+        span.set_attribute("outputSchema", "{}")
+
+    # Set span status
+    if success:
+        span.set_status(Status(StatusCode.OK))
+
+
+def set_evaluation_output_and_metadata(
+    span: Span,
+    evaluator_scores: dict[str, float],
+    execution_id: str,
+    input_data: dict[str, Any] | None = None,
+    has_error: bool = False,
+    error_message: str | None = None,
+) -> None:
+    """Set output and metadata attributes for Evaluation span.
+
+    Args:
+        span: The OpenTelemetry span to set attributes on
+        evaluator_scores: Dictionary mapping evaluator names to their scores (0-100)
+        execution_id: The execution ID for this evaluation
+        input_data: The input data for this evaluation
+        has_error: Whether the evaluation had an error
+        error_message: Optional error message if has_error is True
+    """
+    # Set span output with scores per evaluator using Pydantic model (formatted for UI rendering)
+    output = EvaluationOutput(scores=evaluator_scores)
+    span.set_attribute("output", output.model_dump_json(by_alias=True, indent=2))
+
+    # Set input data if provided (formatted JSON for UI rendering)
+    if input_data is not None:
+        try:
+            span.set_attribute("input", json.dumps(input_data, indent=2))
+        except (TypeError, ValueError):
+            span.set_attribute("input", "{}")
+
+    # Set metadata attributes
+    span.set_attribute("agentId", execution_id)
+    span.set_attribute("agentName", "N/A")
+
+    # Set span status based on success
+    if has_error and error_message:
+        span.set_status(Status(StatusCode.ERROR, error_message))
+    elif not has_error:
+        span.set_status(Status(StatusCode.OK))
+
+
+def set_evaluation_output_span_output(
+    span: Span,
+    score: float,
+    evaluator_id: str | None = None,
+    justification: str | None = None,
+) -> None:
+    """Set output attribute for Evaluation output span.
+
+    Args:
+        span: The OpenTelemetry span to set attributes on
+        score: The evaluation score (0-100)
+        evaluator_id: The ID of the evaluator that produced this score
+        justification: Optional justification text for the score
+    """
+    # Normalize score to 0-100 range
+    normalized_score = normalize_score_to_100(score)
+
+    # Set output using Pydantic model (formatted for UI rendering)
+    output = EvaluationOutputSpanOutput(
+        score=normalized_score,
+        evaluator_id=evaluator_id,
+        justification=justification,
+    )
+    span.set_attribute(
+        "output", output.model_dump_json(by_alias=True, exclude_none=True, indent=2)
+    )
+
+
+# High-level wrapper functions that handle complete flow
+
+
+async def configure_eval_set_run_span(
+    span: Span,
+    evaluator_averages: dict[str, float],
+    execution_id: str,
+    schema: UiPathRuntimeSchema,
+    success: bool = True,
+) -> None:
+    """Configure Evaluation Set Run span with output and metadata.
+
+    This high-level function handles:
+    - Normalizing evaluator scores to 0-100 range
+    - Getting runtime schemas
+    - Setting all span attributes
+
+    Args:
+        span: The OpenTelemetry span to configure
+        evaluator_averages: Dictionary mapping evaluator names to their average scores
+        execution_id: The execution ID for the evaluation set run
+        schema: The runtime schema
+        success: Whether the evaluation set run was successful
+    """
+    # Normalize all scores to 0-100 range
+    evaluator_scores = {
+        evaluator_name: normalize_score_to_100(score)
+        for evaluator_name, score in evaluator_averages.items()
+    }
+
+    # Get runtime schemas
+    try:
+        input_schema = schema.input
+        output_schema = schema.output
+    except Exception:
+        input_schema = None
+        output_schema = None
+
+    # Set span output and metadata
+    set_eval_set_run_output_and_metadata(
+        span=span,
+        evaluator_scores=evaluator_scores,
+        execution_id=execution_id,
+        input_schema=input_schema,
+        output_schema=output_schema,
+        success=success,
+    )
+
+
+async def configure_evaluation_span(
+    span: Span,
+    evaluation_run_results: Any,
+    execution_id: str,
+    input_data: dict[str, Any] | None = None,
+    agent_execution_output: Any | None = None,
+) -> None:
+    """Configure Evaluation span with output and metadata.
+
+    This high-level function handles:
+    - Extracting scores per evaluator from evaluation results
+    - Normalizing scores to 0-100 range
+    - Determining error status
+    - Setting all span attributes
+
+    Args:
+        span: The OpenTelemetry span to configure
+        evaluation_run_results: UiPathEvalRunResult object containing evaluation results
+        execution_id: The execution ID for this evaluation
+        input_data: The input data for this evaluation
+        agent_execution_output: Optional agent execution output for error checking
+    """
+    # Extract evaluator scores (already normalized to 0-100)
+    evaluator_scores = extract_evaluator_scores(evaluation_run_results)
+
+    # Determine error status
+    has_error = False
+    error_message = None
+    if agent_execution_output is not None:
+        try:
+            if agent_execution_output.result.error:
+                has_error = True
+                error_message = str(agent_execution_output.result.error)
+        except (AttributeError, NameError, UnboundLocalError):
+            pass
+
+    # Set span output and metadata
+    set_evaluation_output_and_metadata(
+        span=span,
+        evaluator_scores=evaluator_scores,
+        execution_id=execution_id,
+        input_data=input_data,
+        has_error=has_error,
+        error_message=error_message,
+    )
diff --git a/packages/uipath/src/uipath/eval/runtime/_types.py b/packages/uipath/src/uipath/eval/runtime/_types.py
new file mode 100644
index 000000000..2aee5e599
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_types.py
@@ -0,0 +1,91 @@
+import logging
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from uipath.runtime import UiPathRuntimeResult
+
+from ..models.models import (
+    EvaluationResultDto,
+    TrajectoryEvaluationTrace,
+)
+
+
+class EvaluationRuntimeException(Exception):
+    def __init__(self, spans, logs, root_exception, execution_time):
+        self.spans = spans
+        self.logs = logs
+        self.root_exception = root_exception
+        self.execution_time = execution_time
+
+
+class UiPathEvalRunExecutionOutput(BaseModel):
+    """Result of a single agent response."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    execution_time: float
+    spans: list[ReadableSpan]
+    logs: list[logging.LogRecord]
+    result: UiPathRuntimeResult
+
+
+class UiPathSerializableEvalRunExecutionOutput(BaseModel):
+    execution_time: float
+    trace: TrajectoryEvaluationTrace
+    result: UiPathRuntimeResult
+
+
+def convert_eval_execution_output_to_serializable(
+    output: UiPathEvalRunExecutionOutput,
+) -> UiPathSerializableEvalRunExecutionOutput:
+    return UiPathSerializableEvalRunExecutionOutput(
+        execution_time=output.execution_time,
+        result=output.result,
+        trace=TrajectoryEvaluationTrace.from_readable_spans(output.spans),
+    )
+
+
+class UiPathEvalRunResultDto(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    evaluator_name: str
+    evaluator_id: str
+    result: EvaluationResultDto
+    is_line_result: bool = False  # True if this is a line-by-line sub-result
+
+
+class UiPathEvalRunResult(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    evaluation_name: str
+    evaluation_run_results: list[UiPathEvalRunResultDto]
+    agent_execution_output: UiPathSerializableEvalRunExecutionOutput | None = None
+
+    @property
+    def score(self) -> float:
+        """Compute average score for this single eval_item."""
+        if not self.evaluation_run_results:
+            return 0.0
+
+        total_score = sum(dto.result.score for dto in self.evaluation_run_results)
+        return total_score / len(self.evaluation_run_results)
+
+
+class UiPathEvalOutput(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    evaluation_set_name: str
+    evaluation_set_results: list[UiPathEvalRunResult]
+
+    @property
+    def score(self) -> float:
+        """Compute overall average score from evaluation results."""
+        if not self.evaluation_set_results:
+            return 0.0
+
+        eval_item_scores = [
+            eval_result.score for eval_result in self.evaluation_set_results
+        ]
+        return sum(eval_item_scores) / len(eval_item_scores)
diff --git a/packages/uipath/src/uipath/eval/runtime/_utils.py b/packages/uipath/src/uipath/eval/runtime/_utils.py
new file mode 100644
index 000000000..1c2d43597
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/_utils.py
@@ -0,0 +1,80 @@
+"""Utility functions for applying input overrides to evaluation inputs."""
+
+import copy
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Recursively merge override into base dictionary.
+
+    Args:
+        base: The base dictionary to merge into
+        override: The override dictionary to merge from
+
+    Returns:
+        A new dictionary with overrides recursively merged into base
+    """
+    result = copy.deepcopy(base)
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            # Recursively merge nested dicts
+            result[key] = deep_merge(result[key], value)
+        else:
+            # Direct replacement for non-dict or new keys
+            result[key] = value
+    return result
+
+
+def apply_input_overrides(
+    inputs: dict[str, Any],
+    input_overrides: dict[str, Any],
+    eval_id: str | None = None,
+) -> dict[str, Any]:
+    """Apply input overrides to inputs using direct field override.
+
+    Format: Per-evaluation overrides (keys are evaluation IDs):
+       {"eval-1": {"operator": "*"}, "eval-2": {"a": 100}}
+
+    Deep merge is supported for nested objects:
+    - {"filePath": {"ID": "new-id"}} - deep merges inputs["filePath"] with {"ID": "new-id"}
+
+    Args:
+        inputs: The original inputs dictionary
+        input_overrides: Dictionary mapping evaluation IDs to their override values
+        eval_id: The evaluation ID (required)
+
+    Returns:
+        A new dictionary with overrides applied
+    """
+    if not input_overrides:
+        return inputs
+
+    if not eval_id:
+        logger.warning(
+            "eval_id not provided, cannot apply input overrides. Input overrides require eval_id."
+        )
+        return inputs
+
+    result = copy.deepcopy(inputs)
+
+    # Check if there are overrides for this specific eval_id
+    if eval_id not in input_overrides:
+        logger.debug(f"No overrides found for eval_id='{eval_id}'")
+        return result
+
+    overrides_to_apply = input_overrides[eval_id]
+    logger.debug(f"Applying overrides for eval_id='{eval_id}': {overrides_to_apply}")
+
+    # Apply direct field overrides with recursive deep merge
+    for key, value in overrides_to_apply.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            # Recursive deep merge for dict values
+            result[key] = deep_merge(result[key], value)
+        else:
+            # Direct replacement for non-dict or new keys
+            result[key] = value
+
+    return result
diff --git a/packages/uipath/src/uipath/eval/runtime/context.py b/packages/uipath/src/uipath/eval/runtime/context.py
new file mode 100644
index 000000000..b8224718c
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/context.py
@@ -0,0 +1,29 @@
+"""Context class for evaluation runs."""
+
+from typing import Any
+
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+from ..evaluators.base_evaluator import GenericBaseEvaluator
+from ..models.evaluation_set import EvaluationSet
+
+
+class UiPathEvalContext:
+    """Context used for evaluation runs."""
+
+    # Required Fields
+    runtime_schema: UiPathRuntimeSchema
+    evaluation_set: EvaluationSet
+    evaluators: list[GenericBaseEvaluator[Any, Any, Any]]
+    execution_id: str
+
+    # Optional Fields
+    entrypoint: str | None = None
+    workers: int | None = 1
+    eval_set_run_id: str | None = None
+    verbose: bool = False
+    enable_mocker_cache: bool = False
+    report_coverage: bool = False
+    input_overrides: dict[str, Any] | None = None
+    resume: bool = False
+    job_id: str | None = None
diff --git a/packages/uipath/src/uipath/eval/runtime/events.py b/packages/uipath/src/uipath/eval/runtime/events.py
new file mode 100644
index 000000000..589f82ba7
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/events.py
@@ -0,0 +1,88 @@
+"""Evaluation runtime events."""
+
+import logging
+from enum import Enum
+from typing import Any, Union
+
+from opentelemetry.sdk.trace import ReadableSpan
+from pydantic import BaseModel, ConfigDict, SkipValidation, model_validator
+
+from ..evaluators.base_evaluator import GenericBaseEvaluator
+from ..models import EvalItemResult
+from ..models.evaluation_set import EvaluationItem
+
+
+class EvaluationEvents(str, Enum):
+    """Event types for evaluation runs."""
+
+    CREATE_EVAL_SET_RUN = "create_eval_set_run"
+    CREATE_EVAL_RUN = "create_eval_run"
+    UPDATE_EVAL_SET_RUN = "update_eval_set_run"
+    UPDATE_EVAL_RUN = "update_eval_run"
+
+
+class EvalSetRunCreatedEvent(BaseModel):
+    """Event emitted when an evaluation set run is created."""
+
+    execution_id: str
+    entrypoint: str
+    eval_set_id: str
+    eval_set_run_id: str | None = None
+    no_of_evals: int
+    # skip validation to avoid abstract class instantiation
+    evaluators: SkipValidation[list[GenericBaseEvaluator[Any, Any, Any]]]
+
+
+class EvalRunCreatedEvent(BaseModel):
+    """Event emitted when an individual evaluation run is created."""
+
+    execution_id: str
+    eval_item: EvaluationItem
+
+
+class EvalItemExceptionDetails(BaseModel):
+    """Details of an exception that occurred during an evaluation item."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    runtime_exception: bool = False
+    exception: Exception
+
+
+class EvalRunUpdatedEvent(BaseModel):
+    """Event emitted when an individual evaluation run is updated with results."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    execution_id: str
+    eval_item: EvaluationItem
+    eval_results: list[EvalItemResult]
+    success: bool
+    agent_output: Any
+    agent_execution_time: float
+    spans: list[ReadableSpan]
+    logs: list[logging.LogRecord]
+    exception_details: EvalItemExceptionDetails | None = None
+
+    @model_validator(mode="after")
+    def validate_exception_details(self):
+        """Ensure that exception details are provided when success is False."""
+        if not self.success and self.exception_details is None:
+            raise ValueError("exception_details must be provided when success is False")
+        return self
+
+
+class EvalSetRunUpdatedEvent(BaseModel):
+    """Event emitted when an evaluation set run is updated."""
+
+    execution_id: str
+    evaluator_scores: dict[str, float]
+    success: bool = True
+
+
+ProgressEvent = Union[
+    EvalSetRunCreatedEvent,
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunUpdatedEvent,
+]
diff --git a/packages/uipath/src/uipath/eval/runtime/runtime.py b/packages/uipath/src/uipath/eval/runtime/runtime.py
new file mode 100644
index 000000000..7f7614446
--- /dev/null
+++ b/packages/uipath/src/uipath/eval/runtime/runtime.py
@@ -0,0 +1,1225 @@
+"""Runtime for executing evaluation sets and runs, with support for parallel execution and resuming from checkpoints."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import defaultdict
+from contextlib import contextmanager
+from time import time
+from typing import (
+    Any,
+    Awaitable,
+    Iterable,
+    Iterator,
+    Tuple,
+)
+
+import coverage
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.trace import (
+    NonRecordingSpan,
+    SpanContext,
+    Status,
+    StatusCode,
+    TraceFlags,
+    use_span,
+)
+from pydantic import BaseModel
+
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathExecutionRuntime,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+    UiPathRuntimeStorageProtocol,
+)
+from uipath.runtime.errors import (
+    UiPathErrorCategory,
+    UiPathErrorContract,
+)
+from uipath.runtime.logging import UiPathRuntimeExecutionLogHandler
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+from .._execution_context import ExecutionSpanCollector
+from ..evaluators.base_evaluator import GenericBaseEvaluator
+from ..evaluators.output_evaluator import OutputEvaluationCriteria
+from ..helpers import get_agent_model
+from ..mocks._cache_manager import CacheManager
+from ..mocks._input_mocker import (
+    generate_llm_input,
+)
+from ..mocks._mock_context import cache_manager_context
+from ..mocks._mock_runtime import UiPathMockRuntime
+from ..mocks._types import LLMMockingStrategy, MockingContext, ModelSettings
+from ..models import EvaluationResult
+from ..models.evaluation_set import (
+    EvaluationItem,
+    EvaluationSet,
+)
+from ..models.models import AgentExecution, EvalItemResult, EvaluationResultDto
+from ._exporters import (
+    ExecutionLogsExporter,
+    ExecutionSpanExporter,
+    ExecutionSpanProcessor,
+)
+from ._parallelization import execute_parallel
+from ._spans import (
+    configure_eval_set_run_span,
+    configure_evaluation_span,
+    load_execution_spans,
+    save_execution_spans,
+    set_evaluation_output_span_output,
+)
+from ._types import (
+    EvaluationRuntimeException,
+    UiPathEvalOutput,
+    UiPathEvalRunExecutionOutput,
+    UiPathEvalRunResult,
+    UiPathEvalRunResultDto,
+    convert_eval_execution_output_to_serializable,
+)
+from ._utils import apply_input_overrides
+from .context import UiPathEvalContext
+from .events import (
+    EvalItemExceptionDetails,
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_evaluator_scores(
+    evaluation_set_results: list[UiPathEvalRunResult],
+    evaluators: Iterable[GenericBaseEvaluator[Any, Any, Any]],
+    evaluator_weights: dict[str, float] | None = None,
+    default_weight: float = 1.0,
+) -> tuple[float, dict[str, float]]:
+    """Aggregate evaluation results with deduplication and weighted scoring.
+
+    Steps:
+    1. Flatten nested evaluation_set_results structure
+    2. Deduplicate results by (datapoint_id, evaluator_name), averaging duplicates
+    3. Reduce results per evaluator across all datapoints
+    4. Compute final weighted score across evaluators
+
+    Args:
+        evaluation_set_results: The per-datapoint evaluation results
+        evaluators: The evaluator instances. Each must have a `name` attribute
+            and a `reduce_scores` method.
+        evaluator_weights: Optional dict mapping evaluator names to weights
+        default_weight: Default weight for evaluators not in evaluator_weights (default: 1.0)
+
+    Returns:
+        Tuple of (final_score, agg_metrics_per_evaluator)
+        - final_score: Weighted average across evaluators
+        - agg_metrics_per_evaluator: Dict mapping evaluator names to their reduced scores
+    """
+    if not evaluation_set_results:
+        return 0.0, {}
+
+    if evaluator_weights is None:
+        evaluator_weights = {}
+
+    evaluator_reducers: dict[str, GenericBaseEvaluator[Any, Any, Any]] = {
+        e.name: e for e in evaluators
+    }
+
+    # Step 1: Flatten and group by (datapoint_id, evaluator_name) for deduplication
+    grouped_by_datapoint_evaluator: defaultdict[
+        str, defaultdict[str, list[EvaluationResultDto]]
+    ] = defaultdict(lambda: defaultdict(list))
+
+    for eval_run_result in evaluation_set_results:
+        datapoint_id = eval_run_result.evaluation_name
+        for eval_run_result_dto in eval_run_result.evaluation_run_results:
+            evaluator_name = eval_run_result_dto.evaluator_name
+            # Skip validation for line-by-line sub-results
+            # These are individual line results that shouldn't be aggregated
+            if eval_run_result_dto.is_line_result:
+                continue
+            if evaluator_name not in evaluator_reducers:
+                known = sorted(evaluator_reducers.keys())
+                raise ValueError(
+                    f"Evaluator '{evaluator_name}' found in results for "
+                    f"datapoint '{datapoint_id}' but no matching evaluator "
+                    f"instance was provided. Known evaluators: {known}"
+                )
+            grouped_by_datapoint_evaluator[datapoint_id][evaluator_name].append(
+                eval_run_result_dto.result
+            )
+
+    # Step 2: Deduplicate by averaging same evaluator results for same datapoint
+    dedup_results: list[tuple[str, str, EvaluationResultDto]] = []
+    for datapoint_id, evaluators_dict in grouped_by_datapoint_evaluator.items():
+        for evaluator_name, results_list in evaluators_dict.items():
+            if results_list:
+                avg_score = sum(r.score for r in results_list) / len(results_list)
+                dedup_results.append(
+                    (
+                        datapoint_id,
+                        evaluator_name,
+                        EvaluationResultDto(
+                            score=avg_score,
+                            details=results_list[0].details,
+                        ),
+                    )
+                )
+
+    # Step 3: Group by evaluator and reduce using the evaluator's reducer
+    grouped_by_evaluator: defaultdict[str, list[EvaluationResultDto]] = defaultdict(
+        list
+    )
+    for _datapoint_id, evaluator_name, dp_result in dedup_results:
+        grouped_by_evaluator[evaluator_name].append(dp_result)
+
+    agg_metrics_per_evaluator = {}
+    for evaluator_name, results_list in grouped_by_evaluator.items():
+        reducer = evaluator_reducers[evaluator_name].reduce_scores
+        agg_metrics_per_evaluator[evaluator_name] = reducer(results_list)
+
+    # Step 4: Calculate final weighted score
+    if not agg_metrics_per_evaluator:
+        return 0.0, {}
+
+    total_weighted_score = 0.0
+    total_weight = 0.0
+
+    for evaluator_name, avg_score in agg_metrics_per_evaluator.items():
+        weight = evaluator_weights.get(evaluator_name, default_weight)
+        total_weighted_score += avg_score * weight
+        total_weight += weight
+
+    final_score = total_weighted_score / total_weight if total_weight > 0 else 0.0
+
+    return final_score, agg_metrics_per_evaluator
+
+
+class UiPathEvalRuntime:
+    """Specialized runtime for evaluation runs, with access to the factory."""
+
+    def __init__(
+        self,
+        context: UiPathEvalContext,
+        factory: UiPathRuntimeFactoryProtocol,
+        trace_manager: UiPathTraceManager,
+        event_bus: EventBus,
+    ):
+        """Initialize the evaluation runtime."""
+        self.context: UiPathEvalContext = context
+        self.factory: UiPathRuntimeFactoryProtocol = factory
+        self.event_bus: EventBus = event_bus
+        self.trace_manager: UiPathTraceManager = trace_manager
+        self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
+        self.span_collector: ExecutionSpanCollector = ExecutionSpanCollector()
+
+        # Span processor feeds both exporter and collector
+        span_processor = ExecutionSpanProcessor(self.span_exporter, self.span_collector)
+        self.trace_manager.tracer_span_processors.append(span_processor)
+        self.trace_manager.tracer_provider.add_span_processor(span_processor)
+
+        self.logs_exporter: ExecutionLogsExporter = ExecutionLogsExporter()
+        logger.debug(
+            f"EVAL RUNTIME INIT: job_id={context.job_id}, "
+            f"eval_set_run_id={context.eval_set_run_id}"
+        )
+        self.execution_id = context.execution_id
+        logger.debug(f"EVAL RUNTIME: execution_id set to: {self.execution_id}")
+        self.coverage = coverage.Coverage(branch=True)
+
+        self._storage: UiPathRuntimeStorageProtocol | None = None
+
+    async def __aenter__(self) -> UiPathEvalRuntime:
+        """Async context manager entry - initialize storage and start coverage if enabled."""
+        if self.context.report_coverage:
+            self.coverage.start()
+        self._storage = await self.factory.get_storage()
+
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        """Async context manager exit - stop coverage and clean up execution context."""
+        if self.context.report_coverage:
+            self.coverage.stop()
+            self.coverage.report(include=["./*"], show_missing=True)
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get the runtime schema from context."""
+        return self.context.runtime_schema
+
+    @contextmanager
+    def _mocker_cache(self) -> Iterator[None]:
+        # Create cache manager if enabled
+        if self.context.enable_mocker_cache:
+            cache_mgr = CacheManager()
+            cache_manager_context.set(cache_mgr)
+        try:
+            yield
+        finally:
+            # Flush cache to disk at end of eval set and cleanup
+            if self.context.enable_mocker_cache:
+                cache_manager = cache_manager_context.get()
+                if cache_manager is not None:
+                    cache_manager.flush()
+                cache_manager_context.set(None)
+
+    async def initiate_evaluation(
+        self,
+    ) -> Tuple[
+        EvaluationSet,
+        list[GenericBaseEvaluator[Any, Any, Any]],
+        Iterable[Awaitable[UiPathEvalRunResult]],
+    ]:
+        """Initiate the evaluation by publishing the create eval set run event and preparing the evaluation iterable."""
+        # Validate that resume mode is not used with multiple evaluations
+        if self.context.resume and len(self.context.evaluation_set.evaluations) > 1:
+            raise ValueError(
+                f"Resume mode is not supported with multiple evaluations. "
+                f"Found {len(self.context.evaluation_set.evaluations)} evaluations in the set. "
+                f"Please run with a single evaluation using --eval-ids to specify one evaluation."
+            )
+
+        await self.event_bus.publish(
+            EvaluationEvents.CREATE_EVAL_SET_RUN,
+            EvalSetRunCreatedEvent(
+                execution_id=self.execution_id,
+                entrypoint=self.context.entrypoint or "",
+                eval_set_run_id=self.context.eval_set_run_id,
+                eval_set_id=self.context.evaluation_set.id,
+                no_of_evals=len(self.context.evaluation_set.evaluations),
+                evaluators=self.context.evaluators,
+            ),
+        )
+
+        return (
+            self.context.evaluation_set,
+            self.context.evaluators,
+            (
+                self._execute_eval(eval_item, self.context.evaluators)
+                for eval_item in self.context.evaluation_set.evaluations
+            ),
+        )
+
+    async def execute(self) -> UiPathRuntimeResult:
+        """Execute the evaluation runtime."""
+        logger.debug("=" * 80)
+        logger.debug("EVAL RUNTIME: Starting evaluation execution")
+        logger.debug(f"EVAL RUNTIME: Execution ID: {self.execution_id}")
+        logger.debug(f"EVAL RUNTIME: Job ID: {self.context.job_id}")
+        logger.debug(f"EVAL RUNTIME: Resume mode: {self.context.resume}")
+        logger.debug("=" * 80)
+
+        with self._mocker_cache():
+            tracer = self.trace_manager.tracer_provider.get_tracer(__name__)
+
+            # During resume, restore the parent "Evaluation Set Run" span context
+            # This prevents creating duplicate eval set run spans across jobs
+            eval_set_parent_span = await self._restore_parent_span(
+                "eval_set_run", "Evaluation Set Run"
+            )
+
+            # Create "Evaluation Set Run" span or use restored parent context
+            # NOTE: Do NOT set execution.id on this parent span, as the mixin in
+            # UiPathExecutionBatchTraceProcessor propagates execution.id from parent
+            # to child spans, which would overwrite the per-eval execution.id
+            span_attributes: dict[str, str | bool] = {
+                "span_type": "eval_set_run",
+                "uipath.custom_instrumentation": True,
+            }
+            if self.context.eval_set_run_id:
+                span_attributes["eval_set_run_id"] = self.context.eval_set_run_id
+
+            eval_set_span_context_manager = (
+                use_span(
+                    eval_set_parent_span, end_on_exit=False
+                )  # Don't end the remote span
+                if eval_set_parent_span
+                else tracer.start_as_current_span(
+                    "Evaluation Set Run", attributes=span_attributes
+                )
+            )
+
+            with eval_set_span_context_manager as span:
+                await self._save_span_context_for_resume(
+                    span, "eval_set_run", "Evaluation Set Run"
+                )
+
+                try:
+                    (
+                        evaluation_set,
+                        evaluators,
+                        evaluation_iterable,
+                    ) = await self.initiate_evaluation()
+                    workers = self.context.workers or 1
+                    assert workers >= 1
+                    eval_run_result_list: list[
+                        UiPathEvalRunResult
+                    ] = await execute_parallel(evaluation_iterable, workers)
+
+                    results = UiPathEvalOutput(
+                        evaluation_set_name=evaluation_set.name,
+                        evaluation_set_results=eval_run_result_list,
+                    )
+
+                    # Check for failures
+                    any_failed = any(
+                        eval_run_result.agent_execution_output
+                        and eval_run_result.agent_execution_output.result.error
+                        for eval_run_result in results.evaluation_set_results
+                    )
+
+                    # Compute evaluator averages using each evaluator's reducer
+                    _, evaluator_averages = compute_evaluator_scores(
+                        results.evaluation_set_results,
+                        evaluators,
+                    )
+
+                    # Configure span with output and metadata
+                    await configure_eval_set_run_span(
+                        span=span,
+                        evaluator_averages=evaluator_averages,
+                        execution_id=self.execution_id,
+                        schema=await self.get_schema(),
+                        success=not any_failed,
+                    )
+
+                    await self.event_bus.publish(
+                        EvaluationEvents.UPDATE_EVAL_SET_RUN,
+                        EvalSetRunUpdatedEvent(
+                            execution_id=self.execution_id,
+                            evaluator_scores=evaluator_averages,
+                            success=not any_failed,
+                        ),
+                        wait_for_completion=False,
+                    )
+
+                    # Collect triggers from all evaluation runs (pass-through from inner runtime)
+                    logger.debug("=" * 80)
+                    logger.debug(
+                        "EVAL RUNTIME: Collecting triggers from all evaluation runs"
+                    )
+                    all_triggers = []
+                    for eval_run_result in results.evaluation_set_results:
+                        if (
+                            eval_run_result.agent_execution_output
+                            and eval_run_result.agent_execution_output.result
+                        ):
+                            runtime_result = (
+                                eval_run_result.agent_execution_output.result
+                            )
+                            if runtime_result.triggers:
+                                all_triggers.extend(runtime_result.triggers)
+
+                    if all_triggers:
+                        logger.debug(
+                            f"EVAL RUNTIME: ✅ Passing through {len(all_triggers)} trigger(s) to top-level result"
+                        )
+                        for i, trigger in enumerate(all_triggers, 1):
+                            logger.debug(
+                                f"EVAL RUNTIME: Pass-through trigger {i}: {trigger.model_dump(by_alias=True)}"
+                            )
+                    else:
+                        logger.debug("EVAL RUNTIME: No triggers to pass through")
+                    logger.debug("=" * 80)
+
+                    # Determine overall status - propagate status from inner runtime
+                    # This is critical for serverless executor to know to save state and suspend job
+                    # Priority: SUSPENDED > FAULTED > SUCCESSFUL
+                    overall_status = UiPathRuntimeStatus.SUCCESSFUL
+                    for eval_run_result in results.evaluation_set_results:
+                        if (
+                            eval_run_result.agent_execution_output
+                            and eval_run_result.agent_execution_output.result
+                        ):
+                            inner_status = (
+                                eval_run_result.agent_execution_output.result.status
+                            )
+                            if inner_status == UiPathRuntimeStatus.SUSPENDED:
+                                overall_status = UiPathRuntimeStatus.SUSPENDED
+                                logger.debug(
+                                    "EVAL RUNTIME: Propagating SUSPENDED status from inner runtime"
+                                )
+                                break  # SUSPENDED takes highest priority, stop checking
+                            elif inner_status == UiPathRuntimeStatus.FAULTED:
+                                overall_status = UiPathRuntimeStatus.FAULTED
+                                # Continue checking in case a later eval is SUSPENDED
+
+                    result = UiPathRuntimeResult(
+                        output={**results.model_dump(by_alias=True)},
+                        status=overall_status,
+                        triggers=all_triggers if all_triggers else None,
+                    )
+                    return result
+                except Exception as e:
+                    # Set span status to ERROR on exception
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                    # Publish failure event for eval set run
+                    await self.event_bus.publish(
+                        EvaluationEvents.UPDATE_EVAL_SET_RUN,
+                        EvalSetRunUpdatedEvent(
+                            execution_id=self.execution_id,
+                            evaluator_scores={},
+                            success=False,
+                        ),
+                        wait_for_completion=False,
+                    )
+                    raise
+
+    async def _execute_eval(
+        self,
+        eval_item: EvaluationItem,
+        evaluators: list[GenericBaseEvaluator[Any, Any, Any]],
+    ) -> UiPathEvalRunResult:
+        execution_id = str(eval_item.id)
+
+        tracer = self.trace_manager.tracer_provider.get_tracer(__name__)
+
+        # During resume, restore the parent span context from the previous execution
+        # This allows evaluators to be properly parented to the original "Evaluation" span
+        parent_span = await self._restore_parent_span(eval_item.id, "Evaluation")
+
+        # Create "Evaluation" span or use restored parent context
+        # use_span() handles context management automatically (no manual attach/detach)
+        span_context_manager = (
+            use_span(parent_span, end_on_exit=False)  # Don't end the remote span
+            if parent_span
+            else tracer.start_as_current_span(
+                "Evaluation",
+                attributes={
+                    "execution.id": execution_id,
+                    "span_type": "evaluation",
+                    "eval_item_id": eval_item.id,
+                    "eval_item_name": eval_item.name,
+                    "uipath.custom_instrumentation": True,
+                },
+            )
+        )
+
+        with span_context_manager as span:
+            await self._save_span_context_for_resume(span, eval_item.id, "Evaluation")
+
+            evaluation_run_results = UiPathEvalRunResult(
+                evaluation_name=eval_item.name, evaluation_run_results=[]
+            )
+
+            try:
+                try:
+                    # Generate LLM-based input if input_mocking_strategy is defined
+                    if eval_item.input_mocking_strategy:
+                        eval_item = await self._generate_input_for_eval(eval_item)
+
+                    # Only create eval run entry if NOT resuming from a checkpoint
+                    # When resuming, the entry already exists from the suspend phase
+                    # The progress reporter will load the eval_run_id from persisted state
+                    if not self.context.resume:
+                        await self.event_bus.publish(
+                            EvaluationEvents.CREATE_EVAL_RUN,
+                            EvalRunCreatedEvent(
+                                execution_id=execution_id,
+                                eval_item=eval_item,
+                            ),
+                        )
+                    # Set agent model on the mocking strategy if not already set
+                    mocking_strategy = eval_item.mocking_strategy
+                    if (
+                        mocking_strategy
+                        and isinstance(mocking_strategy, LLMMockingStrategy)
+                        and not mocking_strategy.model
+                    ):
+                        mocking_model = get_agent_model(self.context.runtime_schema)
+                        if mocking_model:
+                            mocking_strategy = mocking_strategy.model_copy(
+                                update={"model": ModelSettings(model=mocking_model)}
+                            )
+
+                    agent_execution_output = await self.execute_runtime(
+                        eval_item,
+                        execution_id,
+                        input_overrides=self.context.input_overrides,
+                        mocking_context=MockingContext(
+                            strategy=mocking_strategy,
+                            name=eval_item.name,
+                            inputs=eval_item.inputs,
+                        ),
+                        eval_set_run_id=self.context.eval_set_run_id,
+                    )
+
+                    logger.debug(
+                        f"DEBUG: Agent execution result status: {agent_execution_output.result.status}"
+                    )
+                    logger.debug(
+                        f"DEBUG: Agent execution result trigger: {agent_execution_output.result.trigger}"
+                    )
+
+                except Exception as e:
+                    if self.context.verbose:
+                        if isinstance(e, EvaluationRuntimeException):
+                            spans = e.spans
+                            logs = e.logs
+                            execution_time = e.execution_time
+                            loggable_error = e.root_exception
+                        else:
+                            spans = []
+                            logs = []
+                            execution_time = 0
+                            loggable_error = e
+
+                        error_info = UiPathErrorContract(
+                            code="RUNTIME_SHUTDOWN_ERROR",
+                            title="Runtime shutdown failed",
+                            detail=f"Error: {str(loggable_error)}",
+                            category=UiPathErrorCategory.UNKNOWN,
+                        )
+                        error_result = UiPathRuntimeResult(
+                            status=UiPathRuntimeStatus.FAULTED,
+                            error=error_info,
+                        )
+                        evaluation_run_results.agent_execution_output = (
+                            convert_eval_execution_output_to_serializable(
+                                UiPathEvalRunExecutionOutput(
+                                    execution_time=execution_time,
+                                    result=error_result,
+                                    spans=spans,
+                                    logs=logs,
+                                )
+                            )
+                        )
+                    raise
+
+                # Check if execution was suspended (e.g., waiting for RPA job completion)
+                if (
+                    agent_execution_output.result.status
+                    == UiPathRuntimeStatus.SUSPENDED
+                ):
+                    # For suspended executions, we don't run evaluators yet
+                    # The serverless executor should save the triggers and resume later
+                    logger.debug("=" * 80)
+                    logger.debug(
+                        f"🔴 EVAL RUNTIME: DETECTED SUSPENSION for eval '{eval_item.name}' (id: {eval_item.id})"
+                    )
+                    logger.debug("EVAL RUNTIME: Agent returned SUSPENDED status")
+
+                    # Extract triggers from result
+                    triggers = []
+                    if agent_execution_output.result.trigger:
+                        triggers.append(agent_execution_output.result.trigger)
+                    if agent_execution_output.result.triggers:
+                        triggers.extend(agent_execution_output.result.triggers)
+
+                    logger.debug(
+                        f"EVAL RUNTIME: Extracted {len(triggers)} trigger(s) from suspended execution"
+                    )
+                    for i, trigger in enumerate(triggers, 1):
+                        logger.debug(
+                            f"EVAL RUNTIME: Trigger {i}: {trigger.model_dump(by_alias=True)}"
+                        )
+
+                    logger.debug("=" * 80)
+
+                    # IMPORTANT: Always include execution output with triggers when suspended
+                    # This ensures triggers are visible in the output JSON for serverless executor
+                    evaluation_run_results.agent_execution_output = (
+                        convert_eval_execution_output_to_serializable(
+                            agent_execution_output
+                        )
+                    )
+
+                    # DO NOT update evalRun status when suspended!
+                    # The evalRun should remain in IN_PROGRESS state until the agent completes
+                    # and evaluators run. When the execution resumes, the evaluators will run
+                    # and the evalRun will be properly updated with results.
+                    logger.debug(
+                        "EVAL RUNTIME: Skipping evalRun update - keeping status as IN_PROGRESS until resume"
+                    )
+
+                    # Return partial results with trigger information
+                    # The evaluation will be completed when resumed
+                    return evaluation_run_results
+
+                if self.context.verbose:
+                    evaluation_run_results.agent_execution_output = (
+                        convert_eval_execution_output_to_serializable(
+                            agent_execution_output
+                        )
+                    )
+                evaluation_item_results: list[EvalItemResult] = []
+
+                for evaluator in evaluators:
+                    if evaluator.id not in eval_item.evaluation_criterias:
+                        # Skip!
+                        continue
+                    evaluation_criteria = eval_item.evaluation_criterias[evaluator.id]
+
+                    # Inject eval-level expectedOutput for output-based evaluators
+                    if eval_item.expected_output is not None and issubclass(
+                        evaluator.evaluation_criteria_type,
+                        OutputEvaluationCriteria,
+                    ):
+                        if evaluation_criteria is None:
+                            evaluation_criteria = {
+                                "expectedOutput": eval_item.expected_output
+                            }
+                        elif "expectedOutput" not in evaluation_criteria:
+                            evaluation_criteria = {
+                                **evaluation_criteria,
+                                "expectedOutput": eval_item.expected_output,
+                            }
+                        # else: per-evaluator expectedOutput takes precedence
+
+                    evaluation_result = await self.run_evaluator(
+                        evaluator=evaluator,
+                        execution_output=agent_execution_output,
+                        eval_item=eval_item,
+                        # If evaluation criteria is None, validate_and_evaluate defaults to the default
+                        evaluation_criteria=evaluator.evaluation_criteria_type(
+                            **evaluation_criteria
+                        )
+                        if evaluation_criteria
+                        else None,
+                    )
+
+                    # Check if this is a line-by-line evaluation result
+                    if hasattr(evaluation_result, "_line_by_line_results"):
+                        line_by_line_container = evaluation_result._line_by_line_results
+
+                        # Store each line result as a separate entry
+                        for (
+                            line_number,
+                            line_result,
+                        ) in line_by_line_container.line_results:
+                            line_dto_result = (
+                                EvaluationResultDto.from_evaluation_result(line_result)
+                            )
+
+                            # Add line number to the evaluator name for identification
+                            line_evaluator_name = (
+                                f"{evaluator.name} (Line {line_number})"
+                            )
+
+                            evaluation_run_results.evaluation_run_results.append(
+                                UiPathEvalRunResultDto(
+                                    evaluator_name=line_evaluator_name,
+                                    result=line_dto_result,
+                                    evaluator_id=f"{evaluator.id}_line_{line_number}",
+                                    is_line_result=True,
+                                )
+                            )
+
+                    # Store the aggregated result
+                    dto_result = EvaluationResultDto.from_evaluation_result(
+                        evaluation_result
+                    )
+
+                    evaluation_run_results.evaluation_run_results.append(
+                        UiPathEvalRunResultDto(
+                            evaluator_name=evaluator.name,
+                            result=dto_result,
+                            evaluator_id=evaluator.id,
+                        )
+                    )
+                    evaluation_item_results.append(
+                        EvalItemResult(
+                            evaluator_id=evaluator.id,
+                            result=evaluation_result,
+                        )
+                    )
+
+                exception_details = None
+                agent_output = agent_execution_output.result.output
+                if agent_execution_output.result.status == UiPathRuntimeStatus.FAULTED:
+                    error = agent_execution_output.result.error
+                    if error is not None:
+                        # we set the exception details for the run event
+                        # Convert error contract to exception
+                        error_exception = Exception(
+                            f"{error.title}: {error.detail} (code: {error.code})"
+                        )
+                        exception_details = EvalItemExceptionDetails(
+                            exception=error_exception
+                        )
+                        agent_output = error.model_dump()
+
+                await self.event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    EvalRunUpdatedEvent(
+                        execution_id=execution_id,
+                        eval_item=eval_item,
+                        eval_results=evaluation_item_results,
+                        success=not agent_execution_output.result.error,
+                        agent_output=agent_output,
+                        agent_execution_time=agent_execution_output.execution_time,
+                        spans=agent_execution_output.spans,
+                        logs=agent_execution_output.logs,
+                        exception_details=exception_details,
+                    ),
+                    wait_for_completion=False,
+                )
+
+            except Exception as e:
+                exception_details = EvalItemExceptionDetails(exception=e)
+
+                for evaluator in evaluators:
+                    evaluation_run_results.evaluation_run_results.append(
+                        UiPathEvalRunResultDto(
+                            evaluator_name=evaluator.name,
+                            evaluator_id=evaluator.id,
+                            result=EvaluationResultDto(score=0),
+                        )
+                    )
+
+                eval_run_updated_event = EvalRunUpdatedEvent(
+                    execution_id=execution_id,
+                    eval_item=eval_item,
+                    eval_results=[],
+                    success=False,
+                    agent_output={},
+                    agent_execution_time=0.0,
+                    exception_details=exception_details,
+                    spans=[],
+                    logs=[],
+                )
+                if isinstance(e, EvaluationRuntimeException):
+                    eval_run_updated_event.spans = e.spans
+                    eval_run_updated_event.logs = e.logs
+                    if eval_run_updated_event.exception_details:
+                        eval_run_updated_event.exception_details.exception = (
+                            e.root_exception
+                        )
+                        eval_run_updated_event.exception_details.runtime_exception = (
+                            True
+                        )
+
+                await self.event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    eval_run_updated_event,
+                    wait_for_completion=False,
+                )
+            # Configure span with output and metadata
+            await configure_evaluation_span(
+                span=span,
+                evaluation_run_results=evaluation_run_results,
+                execution_id=execution_id,
+                input_data=eval_item.inputs,
+                agent_execution_output=agent_execution_output
+                if "agent_execution_output" in locals()
+                else None,
+            )
+
+            return evaluation_run_results
+
+    async def _generate_input_for_eval(
+        self,
+        eval_item: EvaluationItem,
+    ) -> EvaluationItem:
+        """Use LLM to generate a mock input for an evaluation item."""
+        expected_output = (
+            getattr(eval_item, "evaluation_criterias", None)
+            or getattr(eval_item, "expected_output", None)
+            or {}
+        )
+        # Set agent model on the input mocking strategy if not already set
+        input_strategy = eval_item.input_mocking_strategy
+        # If input strategy does not specify a model, extract it
+        if input_strategy and not input_strategy.model:
+            input_generation_model = get_agent_model(self.context.runtime_schema)
+            if input_generation_model:
+                input_strategy = input_strategy.model_copy(
+                    update={"model": ModelSettings(model=input_generation_model)}
+                )
+
+        generated_input = await generate_llm_input(
+            input_strategy,
+            (await self.get_schema()).input,
+            expected_behavior=eval_item.expected_agent_behavior or "",
+            expected_output=expected_output,
+        )
+        updated_eval_item = eval_item.model_copy(update={"inputs": generated_input})
+        return updated_eval_item
+
+    def _get_and_clear_execution_data(
+        self, execution_id: str
+    ) -> tuple[list[ReadableSpan], list[logging.LogRecord]]:
+        spans = self.span_exporter.get_spans(execution_id)
+        self.span_exporter.clear(execution_id)
+        self.span_collector.clear(execution_id)
+
+        logs = self.logs_exporter.get_logs(execution_id)
+        self.logs_exporter.clear(execution_id)
+
+        return spans, logs
+
+    async def execute_runtime(
+        self,
+        eval_item: EvaluationItem,
+        execution_id: str,
+        input_overrides: dict[str, Any] | None = None,
+        mocking_context: MockingContext | None = None,
+        eval_set_run_id: str | None = None,
+    ) -> UiPathEvalRunExecutionOutput:
+        """Execute the runtime for a single evaluation item, with support for input overrides and capturing spans/logs for error handling."""
+        log_handler = self._setup_execution_logging(execution_id)
+        attributes: dict[str, Any] = {
+            "evalId": eval_item.id,
+            "span_type": "eval",
+            "uipath.custom_instrumentation": True,
+        }
+
+        # Create a new runtime with runtime_id for this eval execution.
+        # Use eval_item.id to maintain consistent thread_id across suspend and resume.
+        # This ensures checkpoints can be found when resuming from suspended state.
+        runtime_id = eval_item.id
+
+        eval_runtime = None
+        try:
+            eval_runtime = await self.factory.new_runtime(
+                entrypoint=self.context.entrypoint or "",
+                runtime_id=runtime_id,
+            )
+
+            delegate = eval_runtime
+            if mocking_context:
+                delegate = UiPathMockRuntime(
+                    delegate=eval_runtime,
+                    mocking_context=mocking_context,
+                    span_collector=self.span_collector,
+                    execution_id=execution_id,
+                    eval_set_run_id=eval_set_run_id,
+                )
+
+            execution_runtime = UiPathExecutionRuntime(
+                delegate=delegate,
+                trace_manager=self.trace_manager,
+                log_handler=log_handler,
+                execution_id=execution_id,
+                span_attributes=attributes,
+            )
+
+            start_time = time()
+            try:
+                # Apply input overrides to inputs if configured
+                inputs_with_overrides = apply_input_overrides(
+                    eval_item.inputs,
+                    input_overrides or {},
+                    eval_id=eval_item.id,
+                )
+
+                # In resume mode, pass None as input
+                # The UiPathResumableRuntime wrapper will automatically:
+                # 1. Fetch triggers from storage
+                # 2. Read resume data via trigger_manager.read_trigger()
+                # 3. Build resume map: {interrupt_id: resume_data}
+                # 4. Pass this map to the delegate runtime
+                if self.context.resume:
+                    logger.debug(f"Resuming evaluation {eval_item.id}")
+                    input = input_overrides if self.context.job_id is None else None
+                else:
+                    input = inputs_with_overrides
+
+                # Always pass UiPathExecuteOptions explicitly for consistency with debug flow
+                options = UiPathExecuteOptions(resume=self.context.resume)
+                result = await execution_runtime.execute(
+                    input=input,
+                    options=options,
+                )
+
+                # Log suspend status if applicable
+                if result.status == UiPathRuntimeStatus.SUSPENDED:
+                    logger.debug(f"Evaluation {eval_item.id} suspended")
+
+            except Exception as e:
+                end_time = time()
+                spans, logs = self._get_and_clear_execution_data(execution_id)
+
+                raise EvaluationRuntimeException(
+                    spans=spans,
+                    logs=logs,
+                    root_exception=e,
+                    execution_time=end_time - start_time,
+                ) from e
+
+            end_time = time()
+            spans, logs = self._get_and_clear_execution_data(execution_id)
+
+            if result is None:
+                raise ValueError("Execution result cannot be None for eval runs")
+
+            # Persist spans across the suspend/resume process boundary.
+            # On resume: load spans saved during the initial (pre-suspend) run
+            # and prepend them so evaluators see the full execution trace.
+            if self.context.resume and self._storage is not None:
+                saved_spans = await load_execution_spans(
+                    self._storage, self.execution_id, eval_item.id
+                )
+                if saved_spans:
+                    spans = saved_spans + spans
+
+            # On suspend: save current spans so they're available after resume.
+            if (
+                result.status == UiPathRuntimeStatus.SUSPENDED
+                and self._storage is not None
+            ):
+                await save_execution_spans(
+                    self._storage, self.execution_id, eval_item.id, spans
+                )
+
+            return UiPathEvalRunExecutionOutput(
+                execution_time=end_time - start_time,
+                spans=spans,
+                logs=logs,
+                result=result,
+            )
+        finally:
+            if eval_runtime is not None:
+                await eval_runtime.dispose()
+
+    def _setup_execution_logging(
+        self, eval_item_id: str
+    ) -> UiPathRuntimeExecutionLogHandler:
+        execution_log_handler = UiPathRuntimeExecutionLogHandler(eval_item_id)
+        self.logs_exporter.register(eval_item_id, execution_log_handler)
+        return execution_log_handler
+
+    async def run_evaluator(
+        self,
+        evaluator: GenericBaseEvaluator[Any, Any, Any],
+        execution_output: UiPathEvalRunExecutionOutput,
+        eval_item: EvaluationItem,
+        *,
+        evaluation_criteria: Any,
+    ) -> EvaluationResult:
+        """Run a single evaluator against the execution output, with support for creating spans with appropriate attributes and handling evaluation criteria."""
+        # Create span for evaluator execution
+        # Use tracer from trace_manager's provider to ensure spans go through
+        # the ExecutionSpanProcessor
+        tracer = self.trace_manager.tracer_provider.get_tracer(__name__)
+        with tracer.start_as_current_span(
+            f"Evaluator: {evaluator.name}",
+            attributes={
+                "span_type": "evaluator",
+                "evaluator_id": evaluator.id,
+                "evaluator_name": evaluator.name,
+                "eval_item_id": eval_item.id,
+                "uipath.custom_instrumentation": True,
+            },
+        ):
+            output_data: dict[str, Any] | str = {}
+            if execution_output.result.output:
+                if isinstance(execution_output.result.output, BaseModel):
+                    output_data = execution_output.result.output.model_dump()
+                else:
+                    output_data = execution_output.result.output
+
+            agent_execution = AgentExecution(
+                agent_input=eval_item.inputs,
+                agent_output=output_data,
+                agent_trace=execution_output.spans,
+                expected_agent_behavior=eval_item.expected_agent_behavior,
+            )
+
+            result = await evaluator.validate_and_evaluate_criteria(
+                agent_execution=agent_execution,
+                evaluation_criteria=evaluation_criteria,
+            )
+
+            # Create "Evaluation output" child span with the result
+            eval_output_attrs: dict[str, Any] = {
+                "span.type": "evalOutput",
+                "openinference.span.kind": "CHAIN",
+                "value": result.score,
+                "evaluatorId": evaluator.id,
+                "uipath.custom_instrumentation": True,
+            }
+
+            # Add justification if available
+            justification = None
+            if result.details:
+                if isinstance(result.details, BaseModel):
+                    details_dict = result.details.model_dump()
+                    justification = details_dict.get(
+                        "justification", json.dumps(details_dict)
+                    )
+                else:
+                    justification = str(result.details)
+                eval_output_attrs["justification"] = justification
+
+            with tracer.start_as_current_span(
+                "Evaluation output",
+                attributes=eval_output_attrs,
+            ) as span:
+                # Set output using utility function
+                set_evaluation_output_span_output(
+                    span=span,
+                    score=result.score,
+                    evaluator_id=evaluator.id,
+                    justification=justification,
+                )
+
+            return result
+
+    async def _restore_parent_span(
+        self, span_key: str, span_type: str
+    ) -> NonRecordingSpan | None:
+        """Restore parent span from storage during resume.
+
+        Creates a NonRecordingSpan from saved span context to continue the trace
+        across job boundaries without creating duplicate spans.
+
+        Args:
+            span_key: Storage key for the span. Examples:
+                - "eval_set_run" (string literal) for Evaluation Set Run span
+                - eval_item.id (e.g., "eval-001") for individual Evaluation span
+            span_type: Human-readable span type for logging (e.g., "Evaluation Set Run")
+
+        Returns:
+            NonRecordingSpan if context was restored successfully, None otherwise
+        """
+        if not self.context.resume:
+            return None
+
+        saved_context = await self._get_saved_parent_span_context(span_key)
+        if not saved_context:
+            return None
+
+        try:
+            trace_id = int(saved_context["trace_id"], 16)
+            span_id = int(saved_context["span_id"], 16)
+            span_context = SpanContext(
+                trace_id=trace_id,
+                span_id=span_id,
+                is_remote=True,
+                trace_flags=TraceFlags(0x01),  # Sampled
+            )
+            parent_span = NonRecordingSpan(span_context)
+            logger.debug(
+                f"EVAL RUNTIME: Restored {span_type} span context for resume - "
+                f"trace_id={saved_context['trace_id']}, span_id={saved_context['span_id']}"
+            )
+            return parent_span
+        except Exception as e:
+            logger.warning(
+                f"EVAL RUNTIME: Failed to restore {span_type} span context: {e}"
+            )
+            return None
+
+    async def _save_span_context_for_resume(
+        self, span: Any, span_key: str, span_type: str
+    ) -> None:
+        """Save span context for retrieval during resume.
+
+        Extracts trace_id and span_id from the span and persists them to storage
+        so they can be restored after suspend/resume across job boundaries.
+
+        Args:
+            span: The OpenTelemetry span to save context from
+            span_key: Storage key for the span. Examples:
+                - "eval_set_run" (string literal) for Evaluation Set Run span
+                - eval_item.id (e.g., "eval-001") for individual Evaluation span
+            span_type: Human-readable span type for logging (e.g., "Evaluation")
+        """
+        if span is None or not hasattr(span, "get_span_context"):
+            return
+
+        span_context = span.get_span_context()
+        span_id_hex = format(span_context.span_id, "016x")
+        trace_id_hex = format(span_context.trace_id, "032x")
+
+        await self._save_parent_span_context(
+            span_key,
+            {
+                "span_id": span_id_hex,
+                "trace_id": trace_id_hex,
+            },
+        )
+
+        logger.debug(
+            f"EVAL RUNTIME: Saved {span_type} span context for resume - "
+            f"trace_id={trace_id_hex}, span_id={span_id_hex}"
+        )
+
+    async def _save_parent_span_context(
+        self, span_key: str, span_context: dict[str, str]
+    ) -> None:
+        """Save parent span context for retrieval during resume.
+
+        Uses storage protocol from runtime factory to persist span context
+        across job boundaries (suspend/resume).
+
+        Storage structure:
+            - runtime_id: self.execution_id (eval set run ID)
+            - namespace: "eval_parent_span"
+            - key: span_key parameter (span-specific identifier)
+
+        Args:
+            span_key: Storage key for the span. Can be:
+                - "eval_set_run" for Evaluation Set Run span
+                - eval_item.id for individual Evaluation spans
+            span_context: Dictionary with 'span_id' and 'trace_id' keys (hex strings)
+        """
+        if self._storage is not None:
+            await self._storage.set_value(
+                runtime_id=self.execution_id,
+                namespace="eval_parent_span",
+                key=span_key,
+                value=span_context,
+            )
+            logger.debug(
+                f"Saved parent span context to storage for span_key={span_key}: {span_context}"
+            )
+        else:
+            logger.warning(
+                f"No storage available, cannot persist parent span context for span_key={span_key}"
+            )
+
+    async def _get_saved_parent_span_context(
+        self, span_key: str
+    ) -> dict[str, str] | None:
+        """Retrieve saved parent span context for resume.
+
+        Uses storage protocol from runtime factory to retrieve span context
+        persisted during suspend.
+
+        Storage lookup:
+            - runtime_id: self.execution_id (eval set run ID)
+            - namespace: "eval_parent_span"
+            - key: span_key parameter (span-specific identifier)
+
+        Args:
+            span_key: Storage key for the span. Can be:
+                - "eval_set_run" for Evaluation Set Run span
+                - eval_item.id for individual Evaluation spans
+
+        Returns:
+            Dictionary with 'span_id' and 'trace_id' keys (hex strings), or None if not found
+        """
+        if self._storage is not None:
+            context = await self._storage.get_value(
+                runtime_id=self.execution_id,
+                namespace="eval_parent_span",
+                key=span_key,
+            )
+            if context:
+                logger.debug(
+                    f"Retrieved parent span context from storage for span_key={span_key}: {context}"
+                )
+            else:
+                logger.debug(
+                    f"No saved parent span context found in storage for span_key={span_key}"
+                )
+            return context
+        else:
+            logger.warning(
+                f"No storage available, cannot retrieve parent span context for span_key={span_key}"
+            )
+            return None
+
+    async def dispose(self) -> None:
+        """Cleanup runtime resources."""
+        pass
diff --git a/packages/uipath/src/uipath/functions/__init__.py b/packages/uipath/src/uipath/functions/__init__.py
new file mode 100644
index 000000000..74ffac411
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/__init__.py
@@ -0,0 +1,27 @@
+"""UiPath Functions Runtime - factory and runtime for function-based execution."""
+
+from uipath.runtime import UiPathRuntimeFactoryRegistry
+
+from .debug import UiPathDebugFunctionsRuntime
+from .factory import UiPathFunctionsRuntimeFactory
+from .runtime import UiPathFunctionsRuntime
+
+
+def register_default_runtime_factory():
+    """Register the default functions factory."""
+    UiPathRuntimeFactoryRegistry.register(
+        "uipath",
+        factory_callable=lambda context: UiPathFunctionsRuntimeFactory(
+            config_path="uipath.json",
+        ),
+        config_file="uipath.json",
+    )
+    UiPathRuntimeFactoryRegistry.set_default("uipath")
+
+
+__all__ = [
+    "UiPathDebugFunctionsRuntime",
+    "UiPathFunctionsRuntimeFactory",
+    "UiPathFunctionsRuntime",
+    "register_default_runtime_factory",
+]
diff --git a/packages/uipath/src/uipath/functions/debug.py b/packages/uipath/src/uipath/functions/debug.py
new file mode 100644
index 000000000..a79835e3d
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/debug.py
@@ -0,0 +1,567 @@
+"""Debug wrapper for function runtimes with Python-level breakpoint support.
+
+Provides UiPathDebugFunctionsRuntime, a delegate wrapper that adds
+sys.settrace-based line-level breakpoints to any runtime.  When
+breakpoints are present in the execution options the delegate's
+execute() runs in a background thread with tracing enabled, yielding
+UiPathBreakpointResult events that carry captured local variables for
+inspection.
+
+Composition chain (debug command):
+
+    UiPathDebugRuntime                      → bridge I/O, resume loop
+      └─ UiPathDebugFunctionsRuntime        → trace-based line breakpoints
+           └─ UiPathFunctionsRuntime        → loads & executes user code
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import json
+import logging
+import os
+import queue
+import sys
+import threading
+from pathlib import Path
+from types import FrameType
+from typing import Any, AsyncGenerator, Literal
+
+from uipath.runtime import (
+    UiPathBreakpointResult,
+    UiPathExecuteOptions,
+    UiPathRuntimeEvent,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathStreamOptions,
+)
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+logger = logging.getLogger(__name__)
+
+
+def _capture_frame_locals(frame: FrameType) -> dict[str, Any]:
+    """Snapshot local variables from a live frame for variable inspection.
+
+    Primitives and JSON-serialisable collections are kept as-is so the
+    bridge can render them natively. Everything else is repr()-ed to
+    guarantee safe serialisation over the wire.
+    """
+    snapshot: dict[str, Any] = {}
+    for name, value in frame.f_locals.items():
+        try:
+            if isinstance(value, (bool, int, float, str, type(None))):
+                snapshot[name] = value
+            elif isinstance(value, (dict, list, tuple)):
+                # Strict probe — no default=str, so nested non-serialisable
+                # objects (code, frame, etc.) correctly fail here.
+                json.dumps(value)
+                snapshot[name] = value
+            else:
+                snapshot[name] = repr(value)
+        except Exception:
+            try:
+                snapshot[name] = repr(value)
+            except Exception:
+                snapshot[name] = "<unrepresentable>"
+    return snapshot
+
+
+def _format_location(filepath: str, line: int) -> str:
+    """Return a human-readable file:line breakpoint identifier."""
+    try:
+        relative = Path(filepath).relative_to(Path.cwd())
+    except ValueError:
+        relative = Path(Path(filepath).name)
+    return f"{relative}:{line}"
+
+
+class BreakpointController:
+    """Synchronises a sys.settrace-instrumented thread with an async stream.
+
+    Lifecycle
+    ---------
+    1. Created with breakpoint locations and a project directory.
+    2. start() launches delegate.execute() in a daemon thread with
+       tracing enabled.
+    3. When a matching line is reached the thread pauses and a
+       ("breakpoint", …) event is enqueued.
+    4. The async stream dequeues the event and yields a
+       UiPathBreakpointResult.
+    5. resume() unblocks the thread so it continues to the next
+       breakpoint or completion.
+    6. stop() terminates the thread gracefully.
+    """
+
+    def __init__(
+        self,
+        project_dir: str,
+        breakpoints: list[str] | Literal["*"],
+        entrypoint_path: str | None = None,
+        state_tracked_functions: dict[str, set[str]] | None = None,
+    ) -> None:
+        """Initialize the controller.
+
+        Parameters
+        ----------
+        state_tracked_functions:
+            If provided, state events are emitted *only* for function calls
+            whose ``(abs_file_path, func_name)`` appears in this mapping
+            (``{abs_path: {func_name, …}, …}``).  When ``None``, no state
+            events are emitted.
+        """
+        self._project_dir = project_dir
+        self._entrypoint_path = (
+            os.path.abspath(entrypoint_path) if entrypoint_path else None
+        )
+        self._step_mode: bool = breakpoints == "*"
+        self._file_breakpoints: dict[str, set[int]] = {}
+        if isinstance(breakpoints, list):
+            self._parse_breakpoints(breakpoints)
+
+        self._state_tracked: dict[str, set[str]] | None = state_tracked_functions
+        self._events: queue.Queue[tuple[str, Any]] = queue.Queue()
+        self._resume_event = threading.Event()
+        self._stopped = False
+        self._thread: threading.Thread | None = None
+        self._abspath_cache: dict[str, str] = {}
+        # Track which breakpoints already fired per frame so that
+        # multiline expressions (where the bytecodes bounce back to the
+        # call line after evaluating arguments on deeper lines) don't
+        # trigger the same breakpoint twice within one function call.
+        self._hit_lines: dict[int, set[int]] = {}  # frame-id → {lines}
+
+    # Breakpoint management
+
+    def _parse_breakpoints(self, breakpoints: list[str]) -> None:
+        """Parse breakpoint strings into *file → line-numbers* mappings.
+
+        Supported formats::
+
+            "42"          → line 42 in the entrypoint file
+            "main.py:42"  → line 42 in main.py (resolved relative to cwd)
+        """
+        for bp in breakpoints:
+            if ":" in bp:
+                file_part, line_str = bp.rsplit(":", 1)
+                try:
+                    line = int(line_str)
+                except ValueError:
+                    continue
+                resolved = os.path.abspath(file_part)
+                self._file_breakpoints.setdefault(resolved, set()).add(line)
+            else:
+                try:
+                    line = int(bp)
+                except ValueError:
+                    continue  # non-numeric tokens (agent node names) are ignored
+                if self._entrypoint_path is not None:
+                    self._file_breakpoints.setdefault(self._entrypoint_path, set()).add(
+                        line
+                    )
+
+    def update_breakpoints(self, breakpoints: list[str] | Literal["*"] | None) -> None:
+        """Replace the active breakpoint set (called between resume cycles)."""
+        self._step_mode = breakpoints == "*"
+        self._file_breakpoints.clear()
+        if isinstance(breakpoints, list):
+            self._parse_breakpoints(breakpoints)
+
+    # Tracing
+
+    def _abspath(self, path: str) -> str:
+        """Cached os.path.abspath to avoid repeated resolution in the hot path."""
+        result = self._abspath_cache.get(path)
+        if result is None:
+            result = os.path.abspath(path)
+            self._abspath_cache[path] = result
+        return result
+
+    def _is_project_file(self, abspath: str) -> bool:
+        """Return *True* for real .py files under the project directory."""
+        return (
+            abspath.endswith(".py")
+            and abspath.startswith(self._project_dir)
+            and "site-packages" not in abspath
+        )
+
+    def _is_tracked_function(self, abspath: str, func_name: str) -> bool:
+        """Return *True* if this function should produce a state event."""
+        if self._state_tracked is None:
+            return False
+        funcs = self._state_tracked.get(abspath)
+        return funcs is not None and func_name in funcs
+
+    def _trace_callback(self, frame: FrameType, event: str, arg: Any) -> Any:
+        """sys.settrace callback — dispatched for every frame event."""
+        if self._stopped:
+            return None
+
+        try:
+            co_filename = frame.f_code.co_filename
+            # Fast reject: frozen/built-in modules never have a dot-py path
+            if co_filename.startswith("<"):
+                return None
+
+            filepath = self._abspath(co_filename)
+
+            if event == "call":
+                is_project = self._is_project_file(filepath)
+
+                # Emit state event only for tracked graph-node functions
+                if is_project and self._is_tracked_function(
+                    filepath, frame.f_code.co_name
+                ):
+                    self._events.put(
+                        (
+                            "state",
+                            {
+                                "file": filepath,
+                                "line": frame.f_lineno,
+                                "function": frame.f_code.co_name,
+                                "locals": _capture_frame_locals(frame),
+                                "phase": "started",
+                            },
+                        )
+                    )
+
+                # Reset per-frame hit tracking so each call starts fresh.
+                self._hit_lines[id(frame)] = set()
+
+                # Decide whether to trace *into* this function's frame.
+                if self._step_mode:
+                    return self._trace_callback if is_project else None
+                if filepath in self._file_breakpoints:
+                    return self._trace_callback
+                # Also trace project files that contain tracked functions
+                if is_project and filepath in (self._state_tracked or {}):
+                    return self._trace_callback
+                return None
+
+            if event == "line":
+                # Skip module-level lines (imports, class/function defs).
+                # These fire during module loading, not user code execution.
+                if frame.f_code.co_name == "<module>":
+                    return self._trace_callback
+
+                lineno = frame.f_lineno
+                should_break = (
+                    self._step_mode and self._is_project_file(filepath)
+                ) or (lineno in self._file_breakpoints.get(filepath, ()))
+
+                if should_break:
+                    # Deduplicate: multiline expressions (e.g.
+                    # ``return Foo(arg=bar(...))``) cause the bytecode to
+                    # bounce back to the call-site line after evaluating
+                    # arguments on deeper lines. Without this guard the
+                    # same breakpoint would fire twice per call.
+                    frame_hits = self._hit_lines.get(id(frame))
+                    if frame_hits is not None and lineno in frame_hits:
+                        return self._trace_callback
+                    if frame_hits is not None:
+                        frame_hits.add(lineno)
+
+                    self._events.put(
+                        (
+                            "breakpoint",
+                            {
+                                "file": filepath,
+                                "line": lineno,
+                                "function": frame.f_code.co_name,
+                                "locals": _capture_frame_locals(frame),
+                            },
+                        )
+                    )
+                    # Pause the thread until the bridge signals resume.
+                    self._resume_event.wait()
+                    self._resume_event.clear()
+
+                    if self._stopped:
+                        return None
+
+            elif event == "return":
+                # Emit a "completed" state event for tracked functions
+                if self._is_project_file(filepath) and self._is_tracked_function(
+                    filepath, frame.f_code.co_name
+                ):
+                    locals_snapshot = _capture_frame_locals(frame)
+                    if arg is not None:
+                        try:
+                            import json as _json
+
+                            _json.dumps(arg)
+                            locals_snapshot["__return__"] = arg
+                        except Exception:
+                            locals_snapshot["__return__"] = repr(arg)
+                    self._events.put(
+                        (
+                            "state",
+                            {
+                                "file": filepath,
+                                "line": frame.f_lineno,
+                                "function": frame.f_code.co_name,
+                                "locals": locals_snapshot,
+                                "phase": "completed",
+                            },
+                        )
+                    )
+                # Clean up per-frame tracking when the frame exits.
+                self._hit_lines.pop(id(frame), None)
+
+            return self._trace_callback
+
+        except Exception:
+            # Never let our own errors propagate — that would disable tracing.
+            return self._trace_callback
+
+    # Thread lifecycle
+
+    def start(
+        self,
+        delegate: UiPathRuntimeProtocol,
+        input: dict[str, Any] | None,
+        options: UiPathExecuteOptions | None,
+    ) -> None:
+        """Launch delegate.execute() in a traced daemon thread.
+
+        Copies the caller's contextvars (including OTEL span context) so
+        that ``@traced`` decorators in user code produce spans that are
+        properly linked to the parent trace.
+        """
+        ctx = contextvars.copy_context()
+        self._thread = threading.Thread(
+            target=ctx.run,
+            args=(self._run, delegate, input, options),
+            daemon=True,
+        )
+        self._thread.start()
+
+    def _run(
+        self,
+        delegate: UiPathRuntimeProtocol,
+        input: dict[str, Any] | None,
+        options: UiPathExecuteOptions | None,
+    ) -> None:
+        """Thread entry-point: install the trace, execute, report result."""
+        try:
+            sys.settrace(self._trace_callback)
+            loop = asyncio.new_event_loop()
+            try:
+                result = loop.run_until_complete(delegate.execute(input, options))
+            finally:
+                loop.close()
+            sys.settrace(None)
+            self._events.put(("completed", result))
+        except Exception as exc:
+            sys.settrace(None)
+            self._events.put(("error", exc))
+
+    # Inter-thread communication
+
+    def wait_for_event(self) -> tuple[str, Any]:
+        """Block until the next breakpoint hit or execution completion."""
+        return self._events.get()
+
+    def resume(self) -> None:
+        """Unblock the trace thread so it continues past the current breakpoint."""
+        self._resume_event.set()
+
+    def stop(self) -> None:
+        """Terminate the controller and join the background thread."""
+        self._stopped = True
+        self._resume_event.set()  # unblock if paused at a breakpoint
+        if self._thread is not None and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+
+
+class UiPathDebugFunctionsRuntime:
+    """Delegate wrapper that adds Python-level breakpoint support via sys.settrace.
+
+    Follows the same composition pattern as UiPathDebugRuntime: wraps a UiPathRuntimeProtocol delegate and
+    intercepts stream() to inject breakpoint behaviour.
+
+    When breakpoints **are** present the delegate's execute() runs in
+    a background thread with sys.settrace enabled.  The trace callback
+    pauses the thread at matching lines and this runtime yields
+    UiPathBreakpointResult events with captured local variables.
+
+    Additionally emits ``UiPathRuntimeStateEvent`` for every function call
+    that appears in the entrypoint's call graph, so the debug bridge can
+    visualise execution flow through the graph nodes.
+
+    Works for both sync and async user functions — async functions run in
+    a dedicated asyncio event loop on the background thread.
+
+    Parameters
+    ----------
+    delegate:
+        The inner runtime to wrap (typically UiPathFunctionsRuntime).
+    entrypoint_path:
+        Absolute or relative path to the user's entrypoint file.  Used to
+        resolve bare line-number breakpoints (e.g. "42").
+    function_name:
+        Name of the entrypoint function.  Used together with
+        *entrypoint_path* to build the call graph for state events.
+    """
+
+    def __init__(
+        self,
+        delegate: UiPathRuntimeProtocol,
+        entrypoint_path: str | None = None,
+        function_name: str | None = None,
+    ) -> None:
+        """Initialize the debug wrapper."""
+        self.delegate = delegate
+        self._entrypoint_path = entrypoint_path
+        self._function_name = function_name
+        self._controller: BreakpointController | None = None
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        """Pass-through to delegate (no breakpoint support outside stream)."""
+        return await self.delegate.execute(input, options)
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathStreamOptions | None = None,
+    ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream execution events with line-level breakpoint support.
+
+        Emits ``UiPathRuntimeStateEvent`` for every call-graph function
+        entry so the debug bridge can visualise execution flow.
+
+        Breakpoint formats (via options.breakpoints):
+
+        * "42"          — line 42 in the entrypoint file
+        * "main.py:42"  — line 42 in *main.py* (resolved from cwd)
+        * "*"           — **step mode**: break on every line in project files
+        """
+        breakpoints = options.breakpoints if options else None
+
+        # Resume from a previous breakpoint
+        if options and options.resume and self._controller is not None:
+            self._controller.update_breakpoints(breakpoints)
+            self._controller.resume()
+
+            async for event in self._drain_events():
+                yield event
+            return
+
+        # Build the set of tracked functions from the call graph so we
+        # can emit state events even without breakpoints.
+        tracked = self._build_tracked_functions()
+
+        # Nothing to trace → transparent delegation.  The controller
+        # path runs delegate.execute() in a background thread with a
+        # new asyncio event loop, so we only use it when there is
+        # something to observe (breakpoints and/or state tracking).
+        if not breakpoints and not tracked:
+            async for event in self.delegate.stream(input, options):
+                yield event
+            return
+
+        controller = BreakpointController(
+            project_dir=str(Path.cwd()),
+            breakpoints=breakpoints if breakpoints else [],
+            entrypoint_path=self._entrypoint_path,
+            state_tracked_functions=tracked,
+        )
+        self._controller = controller
+
+        # Strip breakpoints from the options forwarded to the delegate —
+        # the delegate does not handle them; we do via the trace.
+        delegate_options = UiPathExecuteOptions(
+            resume=options.resume if options else False,
+        )
+        controller.start(self.delegate, input, delegate_options)
+
+        async for event in self._drain_events():
+            yield event
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        """Pass-through to delegate."""
+        return await self.delegate.get_schema()
+
+    async def dispose(self) -> None:
+        """Clean up the trace thread and delegate resources."""
+        if self._controller is not None:
+            self._controller.stop()
+            self._controller = None
+        await self.delegate.dispose()
+
+    def _build_tracked_functions(self) -> dict[str, set[str]] | None:
+        """Build a mapping of abs_file → {func_names} from the call graph.
+
+        Returns None when the graph cannot be built (missing path / name).
+        """
+        if not self._entrypoint_path or not self._function_name:
+            return None
+
+        try:
+            from .graph_builder import build_call_graph
+
+            graph = build_call_graph(
+                self._entrypoint_path,
+                self._function_name,
+                project_dir=str(Path.cwd()),
+            )
+
+            tracked: dict[str, set[str]] = {}
+            for node in graph.nodes:
+                file_rel = (node.metadata or {}).get("file")
+                if not file_rel:
+                    continue
+                abs_path = os.path.abspath(file_rel)
+                tracked.setdefault(abs_path, set()).add(node.name)
+
+            return tracked if tracked else None
+        except Exception:
+            logger.debug("Failed to build call graph for state tracking", exc_info=True)
+            return None
+
+    async def _drain_events(self) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Drain events from the controller, yielding state events and stopping at a terminal event."""
+        while self._controller is not None:
+            event_type, data = await asyncio.to_thread(self._controller.wait_for_event)
+            if event_type == "state":
+                yield self._to_state_event(data)
+            else:
+                yield self._to_runtime_event(event_type, data)
+                return
+
+    @staticmethod
+    def _to_state_event(data: dict[str, Any]) -> UiPathRuntimeStateEvent:
+        """Convert a trace state event into a UiPathRuntimeStateEvent."""
+        phase = UiPathRuntimeStatePhase(data.get("phase", "updated"))
+        return UiPathRuntimeStateEvent(
+            node_name=data["function"],
+            qualified_node_name=_format_location(data["file"], data["line"]),
+            payload=data["locals"],
+            phase=phase,
+        )
+
+    def _to_runtime_event(self, event_type: str, data: Any) -> UiPathRuntimeEvent:
+        """Convert a BreakpointController event into a UiPathRuntimeEvent."""
+        if event_type == "breakpoint":
+            return UiPathBreakpointResult(
+                breakpoint_node=_format_location(data["file"], data["line"]),
+                breakpoint_type="before",
+                current_state=data["locals"],
+                next_nodes=[],
+            )
+
+        # Terminal events, release the controller.
+        self._controller = None
+
+        if event_type == "completed":
+            # data is already a UiPathRuntimeResult from delegate.execute().
+            return data
+
+        # "error", re-raise so UiPathDebugRuntime can emit_execution_error().
+        raise data
diff --git a/packages/uipath/src/uipath/functions/factory.py b/packages/uipath/src/uipath/functions/factory.py
new file mode 100644
index 000000000..2f9888469
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/factory.py
@@ -0,0 +1,111 @@
+"""UiPath Functions Runtime Factory - discovery and creation of function-based runtimes."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from uipath.runtime import (
+    UiPathRuntimeFactorySettings,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeStorageProtocol,
+)
+
+from .debug import UiPathDebugFunctionsRuntime
+from .runtime import UiPathFunctionsRuntime
+
+logger = logging.getLogger(__name__)
+
+
+class UiPathFunctionsRuntimeFactory:
+    """Factory for discovering and creating function-based runtimes."""
+
+    def __init__(self, config_path: str = "uipath.json", base_dir: str | None = None):
+        """Initialize the factory with the path to uipath.json configuration."""
+        self.config_path = Path(config_path)
+        self.base_dir = Path(base_dir) if base_dir else self.config_path.parent
+        self._config: dict[str, Any] | None = None
+
+    def _load_config(self) -> dict[str, Any]:
+        """Load uipath.json configuration with caching."""
+        if self._config is not None:
+            return self._config
+
+        if not self.config_path.exists():
+            logger.warning(f"Config file not found: {self.config_path}")
+            return {}
+
+        try:
+            with open(self.config_path) as f:
+                self._config = json.load(f)
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in {self.config_path}: {e}")
+            return {}
+
+        return self._config
+
+    def discover_entrypoints(self) -> list[str]:
+        """Discover all entrypoints (functions and agents) from uipath.json."""
+        config = self._load_config()
+        functions = list(config.get("functions", {}).keys())
+        agents = list(config.get("agents", {}).keys())
+        return functions + agents
+
+    async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+        """Get storage protocol if any (placeholder for protocol compliance)."""
+        return None
+
+    async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+        """Get factory settings for coded functions."""
+        return None
+
+    async def new_runtime(
+        self, entrypoint: str, runtime_id: str, **kwargs
+    ) -> UiPathRuntimeProtocol:
+        """Create a new runtime instance for the given entrypoint."""
+        return self._create_runtime(entrypoint)
+
+    async def dispose(self) -> None:
+        """Dispose resources if any (placeholder for interface compliance)."""
+        pass
+
+    def _create_runtime(self, entrypoint: str) -> UiPathRuntimeProtocol:
+        """Create runtime instance from entrypoint specification."""
+        config = self._load_config()
+        functions = config.get("functions", {})
+        agents = config.get("agents", {})
+
+        # Check both functions and agents
+        if entrypoint in functions:
+            func_spec = functions[entrypoint]
+            entrypoint_type = "function"
+        elif entrypoint in agents:
+            func_spec = agents[entrypoint]
+            entrypoint_type = "agent"
+        else:
+            available = list(functions.keys()) + list(agents.keys())
+            raise ValueError(
+                f"Entrypoint '{entrypoint}' not found in uipath.json. "
+                f"Available: {', '.join(available)}"
+            )
+
+        if ":" not in func_spec:
+            raise ValueError(
+                f"Invalid function specification: '{func_spec}'. "
+                "Expected format: 'path/to/file.py:function_name'"
+            )
+
+        file_path, function_name = func_spec.rsplit(":", 1)
+        full_path = self.base_dir / file_path
+
+        if not full_path.exists():
+            raise ValueError(f"File not found: {full_path}")
+
+        inner = UiPathFunctionsRuntime(
+            str(full_path), function_name, entrypoint, entrypoint_type
+        )
+        return UiPathDebugFunctionsRuntime(
+            delegate=inner,
+            entrypoint_path=str(full_path),
+            function_name=function_name,
+        )
diff --git a/packages/uipath/src/uipath/functions/graph_builder.py b/packages/uipath/src/uipath/functions/graph_builder.py
new file mode 100644
index 000000000..8638d698b
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/graph_builder.py
@@ -0,0 +1,326 @@
+"""AST-based call graph builder for Python function runtimes.
+
+Parses user code starting from an entrypoint function and builds a
+UiPathRuntimeGraph of function call relationships. Only follows calls
+into local project files (skips external dependencies).
+
+Node IDs use the "file:line" format so they can double as breakpoint
+locations for the debug runtime.
+"""
+
+from __future__ import annotations
+
+import ast
+import logging
+import os
+from pathlib import Path
+
+from uipath.runtime.schema import (
+    UiPathRuntimeEdge,
+    UiPathRuntimeGraph,
+    UiPathRuntimeNode,
+)
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MAX_DEPTH = 3
+
+
+def build_call_graph(
+    file_path: str,
+    function_name: str,
+    *,
+    project_dir: str | None = None,
+    max_depth: int = DEFAULT_MAX_DEPTH,
+) -> UiPathRuntimeGraph:
+    """Build a call graph starting from *function_name* in *file_path*.
+
+    Parameters
+    ----------
+    file_path:
+        Absolute or relative path to the Python source file containing the
+        entrypoint function.
+    function_name:
+        Name of the entrypoint function inside *file_path*.
+    project_dir:
+        Root directory of the project. Only files under this directory are
+        followed. Defaults to the parent of *file_path*.
+    max_depth:
+        Maximum recursion depth for following function calls.
+
+    UiPathRuntimeGraph
+        A graph with nodes (id="relative/path.py:line") and edges
+        representing call relationships.
+    """
+    abs_file = os.path.abspath(file_path)
+    if project_dir is None:
+        project_dir = str(Path(abs_file).parent)
+    project_dir = os.path.abspath(project_dir)
+
+    ctx = _BuildContext(project_dir=project_dir, max_depth=max_depth)
+    ctx.visit_function(abs_file, function_name, depth=0)
+    return UiPathRuntimeGraph(nodes=ctx.nodes, edges=ctx.edges)
+
+
+class _BuildContext:
+    """Accumulates nodes and edges while walking the call graph."""
+
+    def __init__(self, project_dir: str, max_depth: int) -> None:
+        self.project_dir = project_dir
+        self.max_depth = max_depth
+        self.nodes: list[UiPathRuntimeNode] = []
+        self.edges: list[UiPathRuntimeEdge] = []
+        self._visited: set[str] = set()  # node IDs already processed
+        self._ast_cache: dict[str, ast.Module] = {}
+
+    def _parse_file(self, abs_path: str) -> ast.Module | None:
+        """Parse a Python file, returning the cached AST or None on failure."""
+        if abs_path in self._ast_cache:
+            return self._ast_cache[abs_path]
+        try:
+            with open(abs_path, encoding="utf-8") as f:
+                tree = ast.parse(f.read(), filename=abs_path)
+            self._ast_cache[abs_path] = tree
+            return tree
+        except Exception:
+            logger.debug("Failed to parse %s", abs_path, exc_info=True)
+            return None
+
+    def _relative_path(self, abs_path: str) -> str:
+        """Return a forward-slash relative path from the project dir."""
+        try:
+            return str(Path(abs_path).relative_to(self.project_dir)).replace("\\", "/")
+        except ValueError:
+            return Path(abs_path).name
+
+    def _node_id(self, abs_path: str, line: int) -> str:
+        return f"{self._relative_path(abs_path)}:{line}"
+
+    def _is_project_file(self, abs_path: str) -> bool:
+        return abs_path.startswith(self.project_dir) and "site-packages" not in abs_path
+
+    def _find_function_def(
+        self, tree: ast.Module, name: str
+    ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+        """Find a top-level function definition by name."""
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if node.name == name:
+                    return node
+        return None
+
+    def _resolve_imports(
+        self, tree: ast.Module, abs_file: str
+    ) -> dict[str, _ImportInfo]:
+        """Build a map of imported names → their source locations.
+
+        Only resolves imports that point to local project files.
+        """
+        result: dict[str, _ImportInfo] = {}
+        file_dir = os.path.dirname(abs_file)
+
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, ast.ImportFrom):
+                module_path = self._resolve_module_path(
+                    node.module, node.level, file_dir
+                )
+                if module_path is None or not self._is_project_file(module_path):
+                    continue
+                for alias in node.names:
+                    imported_name = alias.asname if alias.asname else alias.name
+                    result[imported_name] = _ImportInfo(
+                        abs_path=module_path,
+                        original_name=alias.name,
+                    )
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    module_path = self._resolve_module_path(alias.name, 0, file_dir)
+                    if module_path is None or not self._is_project_file(module_path):
+                        continue
+                    local_name = alias.asname if alias.asname else alias.name
+                    result[local_name] = _ImportInfo(
+                        abs_path=module_path,
+                        original_name=None,  # module-level import
+                    )
+        return result
+
+    def _resolve_module_path(
+        self, module: str | None, level: int, file_dir: str
+    ) -> str | None:
+        """Resolve a module name to an absolute file path, or None."""
+        if module is None and level == 0:
+            return None
+
+        if level > 0:
+            # Relative import: go up (level - 1) directories from file_dir
+            base = file_dir
+            for _ in range(level - 1):
+                base = os.path.dirname(base)
+            if module:
+                parts = module.split(".")
+                candidate = os.path.join(base, *parts)
+            else:
+                candidate = base
+        else:
+            # Absolute import: try from project dir
+            parts = module.split(".")  # type: ignore[union-attr]
+            candidate = os.path.join(self.project_dir, *parts)
+
+        # Check file.py then package/__init__.py
+        as_file = candidate + ".py"
+        if os.path.isfile(as_file):
+            return os.path.abspath(as_file)
+
+        as_pkg = os.path.join(candidate, "__init__.py")
+        if os.path.isfile(as_pkg):
+            return os.path.abspath(as_pkg)
+
+        return None
+
+    def _collect_calls(
+        self, func_node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> list[_CallSite]:
+        """Walk the function body and collect all function call sites."""
+        calls: list[_CallSite] = []
+        for node in ast.walk(func_node):
+            if not isinstance(node, ast.Call):
+                continue
+            info = self._extract_call_info(node)
+            if info is not None:
+                calls.append(info)
+        return calls
+
+    def _extract_call_info(self, call_node: ast.Call) -> _CallSite | None:
+        """Extract the callable name and line from a Call AST node."""
+        func = call_node.func
+        line = call_node.lineno
+
+        if isinstance(func, ast.Name):
+            # Simple call: foo()
+            return _CallSite(name=func.id, attr=None, line=line)
+        elif isinstance(func, ast.Attribute):
+            # Attribute call: module.foo() or obj.method()
+            if isinstance(func.value, ast.Name):
+                return _CallSite(name=func.value.id, attr=func.attr, line=line)
+        return None
+
+    @staticmethod
+    def _last_body_line(
+        func_def: ast.FunctionDef | ast.AsyncFunctionDef,
+    ) -> int:
+        """Return the line number of the last statement in the function body.
+
+        Using the last body line (rather than the first) means breakpoints
+        derived from graph-node IDs fire at the end of the function where
+        all local variables are visible for inspection.
+        """
+        if func_def.body:
+            return func_def.body[-1].lineno
+        return func_def.lineno
+
+    def visit_function(self, abs_file: str, func_name: str, depth: int) -> str | None:
+        """Process a function: create its node and recurse into its calls.
+
+        Returns the node ID if the function was found, otherwise None.
+        """
+        tree = self._parse_file(abs_file)
+        if tree is None:
+            return None
+
+        func_def = self._find_function_def(tree, func_name)
+        if func_def is None:
+            return None
+
+        node_id = self._node_id(abs_file, self._last_body_line(func_def))
+
+        # Add node even if already visited (we need the ID for edges)
+        if node_id in self._visited:
+            return node_id
+
+        self._visited.add(node_id)
+        self.nodes.append(
+            UiPathRuntimeNode(
+                id=node_id,
+                name=func_name,
+                type="function",
+                metadata={"file": self._relative_path(abs_file)},
+            )
+        )
+
+        if depth >= self.max_depth:
+            return node_id
+
+        # Resolve imports and local definitions
+        imports = self._resolve_imports(tree, abs_file)
+        local_funcs = self._collect_local_function_names(tree)
+        calls = self._collect_calls(func_def)
+
+        for call in calls:
+            target_id = self._resolve_and_visit_call(
+                call, abs_file, tree, imports, local_funcs, depth
+            )
+            if target_id is not None:
+                self.edges.append(UiPathRuntimeEdge(source=node_id, target=target_id))
+
+        return node_id
+
+    def _collect_local_function_names(self, tree: ast.Module) -> set[str]:
+        """Collect names of all top-level functions defined in a module."""
+        names: set[str] = set()
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                names.add(node.name)
+        return names
+
+    def _resolve_and_visit_call(
+        self,
+        call: _CallSite,
+        caller_file: str,
+        caller_tree: ast.Module,
+        imports: dict[str, _ImportInfo],
+        local_funcs: set[str],
+        depth: int,
+    ) -> str | None:
+        """Resolve a call site to a target function and visit it.
+
+        Returns the target node ID, or None if unresolvable / external.
+        """
+        if call.attr is None:
+            # Simple call: foo()
+            if call.name in imports:
+                imp = imports[call.name]
+                if imp.original_name is not None:
+                    return self.visit_function(
+                        imp.abs_path, imp.original_name, depth + 1
+                    )
+            if call.name in local_funcs:
+                return self.visit_function(caller_file, call.name, depth + 1)
+        else:
+            # Attribute call: module.foo()
+            if call.name in imports:
+                imp = imports[call.name]
+                if imp.original_name is None:
+                    # Module-level import: import module → module.func()
+                    return self.visit_function(imp.abs_path, call.attr, depth + 1)
+        return None
+
+
+class _ImportInfo:
+    """Tracks where an imported name comes from."""
+
+    __slots__ = ("abs_path", "original_name")
+
+    def __init__(self, abs_path: str, original_name: str | None) -> None:
+        self.abs_path = abs_path
+        self.original_name = original_name
+
+
+class _CallSite:
+    """A function call found in the AST."""
+
+    __slots__ = ("name", "attr", "line")
+
+    def __init__(self, name: str, attr: str | None, line: int) -> None:
+        self.name = name
+        self.attr = attr
+        self.line = line
diff --git a/packages/uipath/src/uipath/functions/runtime.py b/packages/uipath/src/uipath/functions/runtime.py
new file mode 100644
index 000000000..3467d72b5
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/runtime.py
@@ -0,0 +1,270 @@
+"""UiPath Function Runtime - wrapper for executing Python functions."""
+
+import importlib.util
+import inspect
+import logging
+import sys
+import uuid
+from dataclasses import is_dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any, AsyncGenerator, Callable, Type, cast, get_type_hints
+
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeEvent,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+from uipath.runtime.errors import (
+    UiPathErrorCategory,
+    UiPathErrorCode,
+    UiPathRuntimeError,
+)
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+from uipath.runtime.schema import UiPathRuntimeSchema, transform_attachments
+
+from .graph_builder import build_call_graph
+from .schema_gen import get_type_schema
+from .type_conversion import (
+    convert_from_class,
+    convert_to_class,
+    is_pydantic_model,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class UiPathFunctionsRuntime:
+    """Runtime wrapper for a single Python function with full script executor compatibility."""
+
+    def __init__(
+        self,
+        file_path: str,
+        function_name: str,
+        entrypoint_name: str,
+        entrypoint_type: str = "function",
+    ):
+        """Initialize the function runtime.
+
+        Args:
+            file_path: Path to the Python file containing the function
+            function_name: Name of the function to execute
+            entrypoint_name: Name of the entrypoint
+            entrypoint_type: Type of entrypoint - 'function' or 'agent'
+        """
+        self.file_path = Path(file_path)
+        self.function_name = function_name
+        self.entrypoint_name = entrypoint_name
+        self.entrypoint_type = entrypoint_type
+        self._function: Callable[..., Any] | None = None
+        self._module: ModuleType | None = None
+
+    def _load_module(self) -> None:
+        """Load the Python module containing the function."""
+        if self._module is not None:
+            return
+
+        spec = importlib.util.spec_from_file_location(
+            "dynamic_module", str(self.file_path)
+        )
+        if not spec or not spec.loader:
+            raise UiPathRuntimeError(
+                UiPathErrorCode.IMPORT_ERROR,
+                "Module import failed",
+                f"Could not load spec for {self.file_path}",
+                UiPathErrorCategory.USER,
+            )
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["dynamic_module"] = module
+        self._module = module
+
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise UiPathRuntimeError(
+                UiPathErrorCode.MODULE_EXECUTION_ERROR,
+                "Module execution failed",
+                f"Error executing module: {e}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+    def _load_function(self) -> Callable[..., Any]:
+        """Load the function from the module."""
+        if self._function is not None:
+            return self._function
+
+        self._load_module()
+
+        if not hasattr(self._module, self.function_name):
+            raise UiPathRuntimeError(
+                UiPathErrorCode.ENTRYPOINT_FUNCTION_MISSING,
+                "Function not found",
+                f"Function '{self.function_name}' not found in {self.file_path}",
+                UiPathErrorCategory.USER,
+            )
+
+        self._function = getattr(self._module, self.function_name)
+        return self._function
+
+    async def _execute_function(
+        self, func: Callable[..., Any], input_data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Execute function with proper input conversion and error handling."""
+        # Unwrap to inspect the original signature for type-based conversion,
+        # but still call the outer (decorated) func for proper tracing/hooks.
+        unwrapped = inspect.unwrap(func)
+        sig = inspect.signature(unwrapped)
+        params = list(sig.parameters.values())
+        is_async = inspect.iscoroutinefunction(unwrapped)
+
+        # No parameters - call without args
+        if not params:
+            result = await func() if is_async else func()
+            return convert_from_class(result) if result is not None else {}
+
+        # Get first parameter info.
+        # Use get_type_hints() to resolve PEP 563 stringified annotations
+        # (from `from __future__ import annotations`).  inspect.signature()
+        # returns raw strings in that case, which breaks type detection.
+        input_param = params[0]
+        try:
+            hints = get_type_hints(unwrapped)
+            input_type = hints.get(input_param.name, inspect.Parameter.empty)
+        except Exception:
+            input_type = input_param.annotation
+
+        # Typed parameter (class, dataclass, or Pydantic)
+        if input_type != inspect.Parameter.empty and (
+            is_dataclass(input_type)
+            or is_pydantic_model(input_type)
+            or (inspect.isclass(input_type) and hasattr(input_type, "__annotations__"))
+        ):
+            typed_input = convert_to_class(input_data, cast(Type[Any], input_type))
+            result = await func(typed_input) if is_async else func(typed_input)
+        else:
+            # Dict/untyped parameter
+            result = await func(input_data) if is_async else func(input_data)
+
+        return convert_from_class(result) if result is not None else {}
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        """Execute the function with the given input."""
+        try:
+            func = self._load_function()
+            output = await self._execute_function(func, input or {})
+
+            return UiPathRuntimeResult(
+                output=output,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        except UiPathRuntimeError:
+            raise
+        except Exception as e:
+            raise UiPathRuntimeError(
+                UiPathErrorCode.FUNCTION_EXECUTION_ERROR,
+                f"Function execution failed: {self.function_name}",
+                str(e),
+                UiPathErrorCategory.USER,
+            ) from e
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        """Stream execution results with lifecycle phase events.
+
+        Yields STARTED → COMPLETED/FAULTED → result so consumers can
+        observe the execution lifecycle.
+        """
+        yield UiPathRuntimeStateEvent(
+            node_name=self.function_name,
+            phase=UiPathRuntimeStatePhase.STARTED,
+            payload=input or {},
+        )
+
+        try:
+            result = await self.execute(input, options)
+        except UiPathRuntimeError as e:
+            yield UiPathRuntimeStateEvent(
+                node_name=self.function_name,
+                phase=UiPathRuntimeStatePhase.FAULTED,
+                payload={"error": str(e)},
+            )
+            raise
+
+        output = result.output
+        if output is None:
+            completed_payload: dict[str, Any] = {}
+        elif isinstance(output, dict):
+            completed_payload = output
+        else:
+            completed_payload = {"output": str(output)}
+        yield UiPathRuntimeStateEvent(
+            node_name=self.function_name,
+            phase=UiPathRuntimeStatePhase.COMPLETED,
+            payload=completed_payload,
+        )
+
+        yield result
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        """Get schema for the function."""
+        func = self._load_function()
+
+        # Unwrap decorated functions to get the original signature and type hints.
+        # This handles decorators (e.g. @traced) that use functools.wraps.
+        unwrapped = inspect.unwrap(func)
+        hints = get_type_hints(unwrapped)
+        sig = inspect.signature(unwrapped)
+
+        # Determine input schema
+        if not sig.parameters:
+            input_schema = {}
+        else:
+            input_param_name = next(iter(sig.parameters))
+            raw_input_schema = get_type_schema(hints.get(input_param_name))
+            input_schema = transform_attachments(raw_input_schema)
+
+        # Determine output schema
+        raw_output_schema = get_type_schema(hints.get("return"))
+        output_schema = transform_attachments(raw_output_schema)
+
+        # Build call graph from AST
+        graph = None
+        try:
+            graph = build_call_graph(
+                str(self.file_path),
+                self.function_name,
+                project_dir=str(self.file_path.parent),
+            )
+        except Exception:
+            logger.debug(
+                "Failed to build call graph for %s:%s",
+                self.file_path,
+                self.function_name,
+                exc_info=True,
+            )
+
+        return UiPathRuntimeSchema(
+            filePath=self.entrypoint_name,
+            uniqueId=str(uuid.uuid4()),
+            type=self.entrypoint_type,
+            input=input_schema,
+            output=output_schema,
+            graph=graph,
+        )
+
+    async def dispose(self) -> None:
+        """Cleanup resources."""
+        self._function = None
+        if "dynamic_module" in sys.modules:
+            del sys.modules["dynamic_module"]
+        self._module = None
diff --git a/packages/uipath/src/uipath/functions/schema_gen.py b/packages/uipath/src/uipath/functions/schema_gen.py
new file mode 100644
index 000000000..614626f1c
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/schema_gen.py
@@ -0,0 +1,157 @@
+"""Type hint to JSON schema conversion utilities."""
+
+import inspect
+from dataclasses import fields, is_dataclass
+from enum import Enum
+from types import UnionType
+from typing import Any, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+from uipath.runtime.schema import transform_nullable_types, transform_references
+
+SPECIAL_TYPES_MAP: dict[str, Any] = {
+    "UUID": {"type": "string", "format": "uuid"},
+}
+
+TYPE_MAP: dict[str, str] = {
+    "int": "integer",
+    "float": "number",
+    "str": "string",
+    "bool": "boolean",
+    "list": "array",
+    "dict": "object",
+    "List": "array",
+    "Dict": "object",
+}
+
+
+def get_type_schema(type_hint: Any) -> dict[str, Any]:
+    """Convert a type hint to a JSON schema."""
+    if type_hint is None or type_hint == inspect.Parameter.empty:
+        return {"type": "object"}
+
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    # Handle Optional[T] / Union[T, None]
+    if origin is Union or origin is UnionType:
+        # Filter out None/NoneType from the union
+        non_none_args = [arg for arg in args if arg is not type(None)]
+
+        if len(non_none_args) == 1:
+            return get_type_schema(non_none_args[0])
+        return {"type": "object"}
+
+    # Handle list/List
+    if origin in (list, tuple) or (
+        hasattr(origin, "__name__") and origin.__name__ == "List"
+    ):
+        item_type = args[0] if args else Any
+        return {"type": "array", "items": get_type_schema(item_type)}
+
+    # Handle dict/Dict
+    if origin is dict or (hasattr(origin, "__name__") and origin.__name__ == "Dict"):
+        return {"type": "object"}
+
+    if not inspect.isclass(type_hint):
+        type_name = getattr(type_hint, "__name__", str(type_hint))
+        return {"type": TYPE_MAP.get(type_name, "object")}
+
+    # Handle Enum
+    if issubclass(type_hint, Enum):
+        return _get_enum_schema(type_hint)
+
+    # Handle Pydantic models
+    if issubclass(type_hint, BaseModel):
+        return _get_pydantic_schema(type_hint)
+
+    # Handle dataclasses
+    if is_dataclass(type_hint):
+        return _get_dataclass_schema(type_hint)
+
+    # Handle regular classes with annotations
+    if hasattr(type_hint, "__annotations__") and type_hint.__annotations__:
+        return _get_annotated_class_schema(type_hint)
+
+    type_name = getattr(type_hint, "__name__", str(type_hint))
+    if type_name in SPECIAL_TYPES_MAP:
+        return SPECIAL_TYPES_MAP[type_name]
+
+    # Fallback
+    return {"type": TYPE_MAP.get(type_name, "object")}
+
+
+def _get_enum_schema(enum_class: type[Enum]) -> dict[str, Any]:
+    """Generate schema for Enum types."""
+    enum_values = [member.value for member in enum_class]
+    if not enum_values:
+        return {"type": "string", "enum": []}
+
+    first_value = enum_values[0]
+    enum_type = {
+        str: "string",
+        int: "integer",
+        float: "number",
+        bool: "boolean",
+    }.get(type(first_value), "string")
+
+    return {"type": enum_type, "enum": enum_values}
+
+
+def _get_pydantic_schema(model_class: type[BaseModel]) -> dict[str, Any]:
+    """Generate schema for Pydantic models using Pydantic's built-in schema generation."""
+    schema = model_class.model_json_schema()
+
+    resolved_schema, _ = transform_references(schema)
+    processed_properties = transform_nullable_types(resolved_schema)
+    assert isinstance(processed_properties, dict)
+    schema = {
+        "type": "object",
+        "properties": processed_properties.get("properties", {}),
+        "required": processed_properties.get("required", []),
+    }
+    if (title := processed_properties.get("title", None)) is not None:
+        schema["title"] = title
+    return schema
+
+
+def _get_dataclass_schema(dataclass_type: type) -> dict[str, Any]:
+    """Generate schema for dataclass types."""
+    properties = {}
+    required = []
+
+    for field in fields(dataclass_type):
+        properties[field.name] = get_type_schema(field.type)
+
+        # Field is required if it has no default value and no default_factory
+        if field.default == field.default_factory == field.default.__class__.__name__:
+            required.append(field.name)
+        # Better check: use MISSING sentinel
+        from dataclasses import MISSING
+
+        if field.default is MISSING and field.default_factory is MISSING:
+            required.append(field.name)
+
+    return {"type": "object", "properties": properties, "required": required}
+
+
+def _get_annotated_class_schema(class_type: type) -> dict[str, Any]:
+    """Generate schema for regular classes with type annotations."""
+    properties = {}
+    required = []
+
+    for name, field_type in class_type.__annotations__.items():
+        properties[name] = get_type_schema(field_type)
+
+        # Check if the class has an __init__ method and inspect its signature
+        try:
+            sig = inspect.signature(class_type)
+            param = sig.parameters.get(name)
+            if param and param.default == inspect.Parameter.empty:
+                required.append(name)
+        except (ValueError, TypeError):
+            # If we can't get signature, assume all fields are required
+            required.append(name)
+
+    return {"type": "object", "properties": properties, "required": required}
diff --git a/packages/uipath/src/uipath/functions/type_conversion.py b/packages/uipath/src/uipath/functions/type_conversion.py
new file mode 100644
index 000000000..7ad3627a1
--- /dev/null
+++ b/packages/uipath/src/uipath/functions/type_conversion.py
@@ -0,0 +1,135 @@
+"""Type conversion utilities for runtime input/output handling."""
+
+import inspect
+from dataclasses import asdict, is_dataclass
+from typing import Any, Type, TypeVar, cast, get_type_hints
+
+from pydantic import BaseModel
+
+T = TypeVar("T")
+
+
+def is_pydantic_model(cls: Type[Any]) -> bool:
+    """Check if a class is a Pydantic model."""
+    try:
+        return inspect.isclass(cls) and issubclass(cls, BaseModel)
+    except TypeError:
+        return False
+
+
+def convert_to_class(data: dict[str, Any], cls: Type[T]) -> T:
+    """Convert a dictionary to a class instance (Pydantic, dataclass, or regular)."""
+    # Pydantic models
+    if is_pydantic_model(cls):
+        pydantic_cls = cast(Type[BaseModel], cls)
+        return cast(T, pydantic_cls.model_validate(data))
+
+    # Dataclasses
+    if is_dataclass(cls):
+        return _convert_to_dataclass(data, cls)
+
+    # Regular classes
+    return _convert_to_regular_class(data, cls)
+
+
+def _convert_to_dataclass(data: dict[str, Any], cls: Type[T]) -> T:
+    """Convert dictionary to dataclass instance."""
+    field_types = get_type_hints(cls)
+    converted_data = {}
+
+    for field_name, field_type in field_types.items():
+        if field_name not in data:
+            continue
+
+        value = data[field_name]
+        # Recursively convert nested structures
+        if isinstance(value, dict) and _is_nested_type(field_type):
+            value = convert_to_class(value, cast(Type[Any], field_type))
+
+        converted_data[field_name] = value
+
+    return cls(**converted_data)
+
+
+def _convert_to_regular_class(data: dict[str, Any], cls: Type[T]) -> T:
+    """Convert dictionary to regular class instance."""
+    sig = inspect.signature(cls.__init__)
+    init_args = {}
+
+    for param_name, param in sig.parameters.items():
+        if param_name == "self":
+            continue
+
+        if param_name in data:
+            value = data[param_name]
+            param_type = (
+                param.annotation if param.annotation != inspect.Parameter.empty else Any
+            )
+
+            # Recursively convert nested structures
+            if isinstance(value, dict) and _is_nested_type(param_type):
+                value = convert_to_class(value, cast(Type[Any], param_type))
+
+            init_args[param_name] = value
+        elif param.default != inspect.Parameter.empty:
+            init_args[param_name] = param.default
+
+    return cls(**init_args)
+
+
+def convert_from_class(obj: Any) -> dict[str, Any]:
+    """Convert a class instance to a dictionary."""
+    if obj is None:
+        return {}
+
+    # Handle primitives and built-in types first
+    if isinstance(obj, (str, int, float, bool, list, tuple)):
+        return {"result": obj}
+
+    # Handle dict - return as-is
+    if isinstance(obj, dict):
+        return obj
+
+    # Pydantic models
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+
+    # Dataclasses
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return asdict(obj)
+
+    # Regular classes with __dict__
+    if hasattr(obj, "__dict__") and not isinstance(obj, type):
+        return _convert_from_regular_class(obj)
+
+    # Fallback
+    return {}
+
+
+def _convert_from_regular_class(obj: Any) -> dict[str, Any]:
+    """Convert regular class instance to dictionary."""
+    result = {}
+    for key, value in obj.__dict__.items():
+        if not key.startswith("_"):
+            # Recursively convert nested objects
+            if (
+                isinstance(value, BaseModel)
+                or is_dataclass(value)
+                or (
+                    hasattr(value, "__dict__")
+                    and not isinstance(value, (dict, list, str, int, float, bool))
+                )
+            ):
+                result[key] = convert_from_class(value)
+            else:
+                result[key] = value
+    return result
+
+
+def _is_nested_type(type_hint: Type[Any]) -> bool:
+    """Check if a type is a nested structure that needs conversion."""
+    return (
+        is_dataclass(type_hint)
+        or is_pydantic_model(type_hint)
+        or (inspect.isclass(type_hint) and hasattr(type_hint, "__annotations__"))
+    )
diff --git a/packages/uipath/src/uipath/py.typed b/packages/uipath/src/uipath/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/src/uipath/telemetry/__init__.py b/packages/uipath/src/uipath/telemetry/__init__.py
new file mode 100644
index 000000000..92b3a354c
--- /dev/null
+++ b/packages/uipath/src/uipath/telemetry/__init__.py
@@ -0,0 +1,17 @@
+from ._track import (  # noqa: D104
+    flush_events,
+    is_telemetry_enabled,
+    reset_event_client,
+    set_event_connection_string_provider,
+    track,
+    track_event,
+)
+
+__all__ = [
+    "track",
+    "track_event",
+    "is_telemetry_enabled",
+    "flush_events",
+    "set_event_connection_string_provider",
+    "reset_event_client",
+]
diff --git a/src/uipath/telemetry/_constants.py b/packages/uipath/src/uipath/telemetry/_constants.py
similarity index 62%
rename from src/uipath/telemetry/_constants.py
rename to packages/uipath/src/uipath/telemetry/_constants.py
index f47eae132..2583c6715 100644
--- a/src/uipath/telemetry/_constants.py
+++ b/packages/uipath/src/uipath/telemetry/_constants.py
@@ -3,14 +3,18 @@
 _APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE = "APPLICATION_INSIGHTS_EVENT_MARKER_ATTRIBUTE"
 _OTEL_RESOURCE_ATTRIBUTES = "OTEL_RESOURCE_ATTRIBUTES"
 _SDK_VERSION = "SdkVersion"
+_PROJECT_KEY = "ProjectKey"
 
-_CODE_FILEPATH = "code.filepath"
-_CODE_FUNCTION = "code.function"
-_CODE_LINENO = "code.lineno"
+_TELEMETRY_CONFIG_FILE = ".telemetry.json"
+
+_CODE_FILEPATH = "code.file.path"
+_CODE_FUNCTION = "code.function.name"
+_CODE_LINENO = "code.line.number"
 
 _CLOUD_ORG_ID = "CloudOrganizationId"
 _CLOUD_TENANT_ID = "CloudTenantId"
 _CLOUD_URL = "CloudUrl"
+_CLOUD_USER_ID = "CloudUserId"
 _APP_NAME = "ApplicationName"
 
 _UNKNOWN = ""
diff --git a/packages/uipath/src/uipath/telemetry/_track.py b/packages/uipath/src/uipath/telemetry/_track.py
new file mode 100644
index 000000000..3e585f8e5
--- /dev/null
+++ b/packages/uipath/src/uipath/telemetry/_track.py
@@ -0,0 +1,560 @@
+import atexit
+import json
+import os
+from functools import wraps
+from importlib.metadata import version
+from logging import INFO, WARNING, LogRecord, getLogger
+from typing import Any, Callable, ClassVar, Dict, Mapping, Optional, Union
+
+from opentelemetry.sdk._logs import LoggingHandler
+from opentelemetry.util.types import AnyValue
+
+from .._utils.constants import (
+    ENV_BASE_URL,
+    ENV_ORGANIZATION_ID,
+    ENV_TELEMETRY_ENABLED,
+    ENV_TENANT_ID,
+)
+from ._constants import (
+    _APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE,
+    _APP_NAME,
+    _CLOUD_ORG_ID,
+    _CLOUD_TENANT_ID,
+    _CLOUD_URL,
+    _CLOUD_USER_ID,
+    _CODE_FILEPATH,
+    _CODE_FUNCTION,
+    _CODE_LINENO,
+    _CONNECTION_STRING,
+    _OTEL_RESOURCE_ATTRIBUTES,
+    _PROJECT_KEY,
+    _SDK_VERSION,
+    _TELEMETRY_CONFIG_FILE,
+    _UNKNOWN,
+)
+
+# Try to import Application Insights client for custom events
+# Note: applicationinsights is not typed, as it was deprecated in favor of the
+# OpenTelemetry SDK. We still use it because it's the only way to send custom
+# events to the Application Insights customEvents table.
+try:
+    from applicationinsights import (  # type: ignore[import-untyped]
+        TelemetryClient as AppInsightsTelemetryClient,
+    )
+    from applicationinsights.channel import (  # type: ignore[import-untyped]
+        SynchronousQueue,
+        SynchronousSender,
+        TelemetryChannel,
+    )
+
+    _HAS_APPINSIGHTS = True
+except ImportError:
+    _HAS_APPINSIGHTS = False
+    AppInsightsTelemetryClient = None
+    SynchronousSender = None
+    SynchronousQueue = None
+    TelemetryChannel = None
+
+
+def _parse_connection_string(
+    connection_string: str,
+) -> Optional[Dict[str, str]]:
+    """Parse Azure Application Insights connection string.
+
+    Args:
+        connection_string: The full connection string from Azure.
+
+    Returns:
+        Dict with 'InstrumentationKey' and optionally 'IngestionEndpoint',
+        or None if InstrumentationKey is not found.
+    """
+    try:
+        parts: Dict[str, str] = {}
+        for part in connection_string.split(";"):
+            if "=" in part:
+                key, value = part.split("=", 1)
+                parts[key] = value
+        ikey = parts.get("InstrumentationKey")
+        if not ikey:
+            return None
+        result: Dict[str, str] = {"InstrumentationKey": ikey}
+        ingestion = parts.get("IngestionEndpoint")
+        if ingestion:
+            result["IngestionEndpoint"] = ingestion
+        return result
+    except Exception:
+        return None
+
+
+_logger = getLogger(__name__)
+_logger.propagate = False
+
+
+def _get_connection_string() -> str | None:
+    """Get the Application Insights connection string.
+
+    Checks the TELEMETRY_CONNECTION_STRING env var first, then falls back
+    to the _CONNECTION_STRING constant.
+    """
+    env_value = os.getenv("TELEMETRY_CONNECTION_STRING")
+    if env_value:
+        return env_value
+    if _CONNECTION_STRING and _CONNECTION_STRING != "$CONNECTION_STRING":
+        return _CONNECTION_STRING
+    return None
+
+
+def _get_project_key() -> str:
+    """Get the id used to attribute telemetry.
+
+    Resolves ``uipath.json#id`` (then the runtime env var) via the shared
+    ``resolve_project_id`` helper, falling back to a legacy ``.uipath/.telemetry.json``
+    ``ProjectKey`` if present.
+    Returns ``_UNKNOWN`` when no id is available.
+    """
+    from uipath.platform.common._span_utils import resolve_project_id
+
+    if project_id := resolve_project_id():
+        return project_id
+
+    try:
+        telemetry_file = os.path.join(".uipath", _TELEMETRY_CONFIG_FILE)
+        if os.path.exists(telemetry_file):
+            with open(telemetry_file, "r") as f:
+                if project_id := json.load(f).get(_PROJECT_KEY):
+                    return project_id
+    except (json.JSONDecodeError, IOError, KeyError):
+        pass
+
+    return _UNKNOWN
+
+
+class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
+    @staticmethod
+    def _get_attributes(record: LogRecord) -> Mapping[str, AnyValue]:
+        attributes = dict(LoggingHandler._get_attributes(record) or {})
+        attributes[_APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE] = True
+        attributes[_CLOUD_TENANT_ID] = os.getenv(ENV_TENANT_ID, _UNKNOWN)
+        attributes[_CLOUD_ORG_ID] = os.getenv(ENV_ORGANIZATION_ID, _UNKNOWN)
+        attributes[_CLOUD_URL] = os.getenv(ENV_BASE_URL, _UNKNOWN)
+        attributes[_APP_NAME] = "UiPath.Sdk"
+        attributes[_SDK_VERSION] = version("uipath")
+        try:
+            # Lazy import to avoid circular dependency
+            from .._cli._utils._common import get_claim_from_token
+
+            cloud_user_id = get_claim_from_token("sub")
+        except Exception:
+            cloud_user_id = _UNKNOWN
+        attributes[_CLOUD_USER_ID] = cloud_user_id
+        attributes[_PROJECT_KEY] = _get_project_key()
+
+        if _CODE_FILEPATH in attributes:
+            del attributes[_CODE_FILEPATH]
+        if _CODE_FUNCTION in attributes:
+            del attributes[_CODE_FUNCTION]
+        if _CODE_LINENO in attributes:
+            del attributes[_CODE_LINENO]
+
+        return attributes
+
+
+class _DiagnosticSender(SynchronousSender):
+    """SynchronousSender that logs HTTP failures the base SDK silently discards."""
+
+    def send(self, data_to_send: Any) -> None:
+        """Send telemetry data with diagnostic logging.
+
+        The base SDK silently discards HTTP 400 responses and swallows all
+        other network errors. This override adds WARNING-level logs so
+        silent data loss becomes visible in logs.
+        """
+        import json as _json
+
+        try:
+            import urllib.request as HTTPClient
+            from urllib.error import HTTPError
+        except ImportError:
+            super().send(data_to_send)
+            return
+
+        request_payload = _json.dumps([a.write() for a in data_to_send])
+        request = HTTPClient.Request(
+            self._service_endpoint_uri,
+            bytearray(request_payload, "utf-8"),
+            {
+                "Accept": "application/json",
+                "Content-Type": "application/json; charset=utf-8",
+            },
+        )
+        try:
+            response = HTTPClient.urlopen(request, timeout=self._timeout)
+            status_code = response.getcode()
+            if 200 <= status_code < 300:
+                return
+        except HTTPError as e:
+            if e.getcode() == 400:
+                _logger.warning(
+                    "AppInsights send: HTTP 400 — payload rejected (%d items discarded)",
+                    len(data_to_send),
+                )
+                return
+            _logger.warning(
+                "AppInsights send: HTTP %d (%d items re-queued)",
+                e.getcode(),
+                len(data_to_send),
+            )
+        except Exception as e:
+            _logger.warning("AppInsights send: %s (%s)", type(e).__name__, e)
+
+        # Re-queue unsent data up to 2 attempts, then discard
+        max_retries = 2
+        for data in data_to_send:
+            attempt = getattr(data, "_send_attempts", 0) + 1
+            if attempt < max_retries:
+                data._send_attempts = attempt
+                self._queue.put(data)
+            else:
+                _logger.warning(
+                    "AppInsights send: discarding item after %d failed attempts",
+                    attempt,
+                )
+
+
+class _AppInsightsEventClient:
+    """Application Insights SDK client for sending custom events.
+
+    This uses the applicationinsights SDK to send events directly to the
+    customEvents table in Application Insights.
+    """
+
+    _initialized = False
+    _client: Optional[Any] = None
+    _atexit_registered = False
+    _connection_string_provider: ClassVar[Optional[Callable[[], Optional[str]]]] = None
+
+    @staticmethod
+    def set_connection_string_provider(
+        provider: Callable[[], Optional[str]],
+    ) -> None:
+        """Override how the connection string is resolved.
+
+        Args:
+            provider: Zero-arg callable returning a connection string or None.
+        """
+        _AppInsightsEventClient._connection_string_provider = provider
+
+    @staticmethod
+    def _initialize() -> None:
+        """Initialize Application Insights client for custom events."""
+        if _AppInsightsEventClient._initialized:
+            return
+
+        _AppInsightsEventClient._initialized = True
+
+        # Suppress verbose logging from Application Insights SDK
+        # The SDK logs telemetry ingestion details which should not be user-facing
+        getLogger("applicationinsights").setLevel(WARNING)
+        getLogger("applicationinsights.channel").setLevel(WARNING)
+
+        if not _HAS_APPINSIGHTS:
+            return
+
+        if _AppInsightsEventClient._connection_string_provider:
+            connection_string = _AppInsightsEventClient._connection_string_provider()
+        else:
+            connection_string = _get_connection_string()
+        if not connection_string:
+            return
+
+        try:
+            parsed = _parse_connection_string(connection_string)
+            if not parsed:
+                return
+
+            instrumentation_key = parsed["InstrumentationKey"]
+            ingestion_endpoint = parsed.get("IngestionEndpoint")
+
+            # Build custom channel: DiagnosticSender → SynchronousQueue → TelemetryChannel
+            if ingestion_endpoint:
+                endpoint_url = ingestion_endpoint.rstrip("/") + "/v2/track"
+            else:
+                endpoint_url = None  # SDK default
+
+            sender = _DiagnosticSender(service_endpoint_uri=endpoint_url)
+            queue = SynchronousQueue(sender)
+            channel = TelemetryChannel(queue=queue)
+
+            _AppInsightsEventClient._client = AppInsightsTelemetryClient(
+                instrumentation_key, telemetry_channel=channel
+            )
+
+            # Set application version
+            _AppInsightsEventClient._client.context.application.ver = version("uipath")
+        except Exception as e:
+            # Log but don't raise - telemetry should never break the main application
+            _logger.warning(f"Failed to initialize Application Insights client: {e}")
+            _logger.debug("Application Insights initialization error", exc_info=True)
+
+    @staticmethod
+    def track_event(
+        name: str,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Track a custom event to Application Insights customEvents table.
+
+        Args:
+            name: Name of the event.
+            properties: Properties for the event (converted to strings).
+        """
+        _AppInsightsEventClient._initialize()
+
+        if not _AppInsightsEventClient._client:
+            return
+
+        try:
+            safe_properties: Dict[str, str] = {}
+            if properties:
+                for key, value in properties.items():
+                    if value is not None:
+                        safe_properties[key] = str(value)
+
+            _AppInsightsEventClient._client.track_event(
+                name=name, properties=safe_properties, measurements={}
+            )
+            # Note: We don't flush after every event to avoid blocking.
+            # Events will be sent in batches by the SDK.
+        except Exception as e:
+            # Log but don't raise - telemetry should never break the main application
+            _logger.warning(f"Failed to track event '{name}': {e}")
+            _logger.debug(f"Event tracking error for '{name}'", exc_info=True)
+
+    @staticmethod
+    def flush() -> None:
+        """Flush any pending telemetry events."""
+        if _AppInsightsEventClient._client:
+            try:
+                _AppInsightsEventClient._client.flush()
+                # Check if items remain after flush (indicates send failure)
+                try:
+                    remaining = (
+                        _AppInsightsEventClient._client.channel.queue._queue.qsize()
+                    )
+                    if remaining > 0:
+                        _logger.warning(
+                            "AppInsights flush: %d items still in queue after flush",
+                            remaining,
+                        )
+                except Exception:
+                    pass
+            except Exception as e:
+                # Log but don't raise - telemetry should never break the main application
+                _logger.warning(f"Failed to flush telemetry events: {e}")
+                _logger.debug("Telemetry flush error", exc_info=True)
+
+    @staticmethod
+    def register_atexit_flush() -> None:
+        """Register an atexit handler to flush events on process exit."""
+        if not _AppInsightsEventClient._atexit_registered:
+            atexit.register(_AppInsightsEventClient.flush)
+            _AppInsightsEventClient._atexit_registered = True
+
+    @staticmethod
+    def reset() -> None:
+        """Flush pending events and reset so the next call re-initializes."""
+        _AppInsightsEventClient.flush()
+        _AppInsightsEventClient._client = None
+        _AppInsightsEventClient._initialized = False
+
+
+class _TelemetryClient:
+    """A class to handle telemetry using OpenTelemetry for method tracking."""
+
+    _initialized = False
+
+    @staticmethod
+    def _is_enabled() -> bool:
+        """Check if telemetry is enabled at runtime."""
+        return os.getenv(ENV_TELEMETRY_ENABLED, "true").lower() == "true"
+
+    @staticmethod
+    def _initialize():
+        """Initialize the OpenTelemetry-based telemetry client."""
+        if _TelemetryClient._initialized or not _TelemetryClient._is_enabled():
+            return
+
+        try:
+            os.environ[_OTEL_RESOURCE_ATTRIBUTES] = (
+                "service.name=uipath-sdk,service.instance.id=" + version("uipath")
+            )
+            os.environ["OTEL_TRACES_EXPORTER"] = "none"
+            os.environ["APPLICATIONINSIGHTS_STATSBEAT_DISABLED_ALL"] = "true"
+
+            # Suppress verbose logging from telemetry libraries
+            getLogger("azure").setLevel(WARNING)
+            getLogger("applicationinsights").setLevel(WARNING)
+            getLogger("opentelemetry").setLevel(WARNING)
+            _logger.addHandler(_AzureMonitorOpenTelemetryEventHandler())
+            _logger.setLevel(INFO)
+
+            _TelemetryClient._initialized = True
+        except Exception as e:
+            # Log but don't raise - telemetry should never break the main application
+            _logger.warning(f"Failed to initialize telemetry client: {e}")
+            _logger.debug("Telemetry initialization error", exc_info=True)
+
+    @staticmethod
+    def _track_method(name: str, attrs: Optional[Dict[str, Any]] = None):
+        """Track function invocations using OpenTelemetry."""
+        if not _TelemetryClient._is_enabled():
+            return
+
+        _TelemetryClient._initialize()
+
+        _logger.info(f"Sdk.{name.capitalize()}", extra=attrs)
+
+    @staticmethod
+    def track_event(
+        name: str,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Track a custom event to Application Insights customEvents table.
+
+        This method sends a custom event using the Application Insights SDK,
+        which ensures events appear in the customEvents table for monitoring
+        and analytics. Telemetry failures are silently ignored to ensure the
+        main application is never blocked.
+
+        Args:
+            name: Name of the event (e.g., "EvalSetRun.Start", "AgentRun.Complete").
+            properties: Optional dictionary of properties to attach to the event.
+                       Values will be converted to strings.
+
+        Example:
+            from uipath.telemetry import track_event
+
+            track_event("MyFeature.Start", {"user_id": "123", "feature": "export"})
+        """
+        if not _TelemetryClient._is_enabled():
+            return
+
+        try:
+            _AppInsightsEventClient.track_event(name, properties)
+            # Safety net: register atexit flush so events are sent even if
+            # the caller never explicitly flushes (e.g. serverless containers).
+            # Idempotent — only registers once.
+            _AppInsightsEventClient.register_atexit_flush()
+        except Exception as e:
+            # Log but don't raise - telemetry should never break the main application
+            _logger.warning(f"Failed to track event '{name}': {e}")
+            _logger.debug(f"Event tracking error for '{name}'", exc_info=True)
+
+
+def track_event(
+    name: str,
+    properties: Optional[Dict[str, Any]] = None,
+) -> None:
+    """Track a custom event.
+
+    This function sends a custom event to Application Insights for monitoring
+    and analytics. Telemetry failures are silently ignored to ensure the
+    main application is never blocked.
+
+    Args:
+        name: Name of the event (e.g., "EvalSetRun.Start", "AgentRun.Complete").
+        properties: Optional dictionary of properties to attach to the event.
+                   Values will be converted to strings.
+
+    Example:
+        from uipath.telemetry import track_event
+
+        track_event("MyFeature.Start", {"user_id": "123", "feature": "export"})
+    """
+    _TelemetryClient.track_event(name, properties)
+
+
+def is_telemetry_enabled() -> bool:
+    """Check if telemetry is enabled.
+
+    Returns:
+        True if telemetry is enabled, False otherwise.
+    """
+    return _TelemetryClient._is_enabled()
+
+
+def flush_events() -> None:
+    """Flush any pending telemetry events.
+
+    Call this to ensure all tracked events are sent to Application Insights.
+    This is useful at the end of a process or when you need to ensure
+    events are sent immediately.
+    """
+    _AppInsightsEventClient.flush()
+
+
+def set_event_connection_string_provider(
+    provider: Callable[[], Optional[str]],
+) -> None:
+    """Override how the Application Insights connection string is resolved.
+
+    Args:
+        provider: Zero-arg callable returning a connection string or None.
+    """
+    _AppInsightsEventClient.set_connection_string_provider(provider)
+
+
+def reset_event_client() -> None:
+    """Flush pending events and reset so the next ``track_event`` re-initializes."""
+    _AppInsightsEventClient.reset()
+
+
+def track_cli_event(
+    name: str,
+    properties: Optional[Dict[str, Any]] = None,
+) -> None:
+    """Track a CLI event.
+
+    Buffers the event and registers an atexit handler to flush pending events on process exit.
+    """
+    if not _TelemetryClient._is_enabled():
+        return
+    try:
+        _AppInsightsEventClient.track_event(name, properties)
+        _AppInsightsEventClient.register_atexit_flush()
+    except Exception:
+        pass
+
+
+def track(
+    name_or_func: Optional[Union[str, Callable[..., Any]]] = None,
+    *,
+    when: Optional[Union[bool, Callable[..., bool]]] = True,
+    extra: Optional[Dict[str, Any]] = None,
+):
+    """Decorator that will trace function invocations.
+
+    Args:
+        name_or_func: The name of the event to track or the function itself.
+        extra: Extra attributes to add to the telemetry event.
+    """
+
+    def decorator(func: Callable[..., Any]):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            event_name = (
+                name_or_func if isinstance(name_or_func, str) else func.__name__
+            )
+
+            should_track = when(*args, **kwargs) if callable(when) else when
+
+            if should_track:
+                _TelemetryClient._track_method(event_name, extra)
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    if callable(name_or_func):
+        return decorator(name_or_func)
+
+    return decorator
diff --git a/packages/uipath/src/uipath/tracing/__init__.py b/packages/uipath/src/uipath/tracing/__init__.py
new file mode 100644
index 000000000..e6c37bc99
--- /dev/null
+++ b/packages/uipath/src/uipath/tracing/__init__.py
@@ -0,0 +1,28 @@
+"""Tracing utilities and OpenTelemetry exporters."""
+
+from uipath.core import traced
+from uipath.platform.common._span_utils import (
+    AttachmentDirection,
+    AttachmentProvider,
+    SpanAttachment,
+    VerbosityLevel,
+)
+
+from ._live_tracking_processor import LiveTrackingSpanProcessor
+from ._otel_exporters import (  # noqa: D104
+    JsonLinesFileExporter,
+    LlmOpsHttpExporter,
+    SpanStatus,
+)
+
+__all__ = [
+    "traced",
+    "LlmOpsHttpExporter",
+    "JsonLinesFileExporter",
+    "LiveTrackingSpanProcessor",
+    "SpanStatus",
+    "AttachmentDirection",
+    "AttachmentProvider",
+    "SpanAttachment",
+    "VerbosityLevel",
+]
diff --git a/packages/uipath/src/uipath/tracing/_live_tracking_processor.py b/packages/uipath/src/uipath/tracing/_live_tracking_processor.py
new file mode 100644
index 000000000..85bcca1ba
--- /dev/null
+++ b/packages/uipath/src/uipath/tracing/_live_tracking_processor.py
@@ -0,0 +1,94 @@
+import logging
+from concurrent.futures import ThreadPoolExecutor
+
+from opentelemetry import context as context_api
+from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
+
+from uipath.core.tracing import UiPathTraceSettings
+from uipath.tracing._otel_exporters import LlmOpsHttpExporter, SpanStatus
+
+logger = logging.getLogger(__name__)
+
+
+class LiveTrackingSpanProcessor(SpanProcessor):
+    """Span processor for live span tracking using upsert_span API.
+
+    Sends real-time span updates:
+    - On span start: Upsert with RUNNING status
+    - On span end: Upsert with final status (OK/ERROR)
+
+    All upsert calls run in background threads without blocking execution.
+    Uses a thread pool to cap the maximum number of concurrent threads
+    and avoid resource exhaustion.
+
+    Filtering:
+        Applies the span_filter from factory settings (if provided).
+        - Low-code agents: Filter to uipath.custom_instrumentation=True
+        - Coded functions: No filtering (settings=None)
+
+    Architecture note:
+        One LiveTrackingSpanProcessor per LlmOpsHttpExporter.
+        Do not share processors between exporters.
+    """
+
+    def __init__(
+        self,
+        exporter: LlmOpsHttpExporter,
+        max_workers: int = 10,
+        settings: UiPathTraceSettings | None = None,
+    ):
+        self.exporter = exporter
+        self.span_filter = (
+            settings.span_filter if settings and settings.span_filter else None
+        )
+        self.executor = ThreadPoolExecutor(
+            max_workers=max_workers, thread_name_prefix="span-upsert"
+        )
+
+    def _upsert_span_async(
+        self, span: Span | ReadableSpan, status_override: int | None = None
+    ) -> None:
+        """Run upsert_span in a background thread without blocking.
+
+        Submits the upsert task to the thread pool and returns immediately.
+        The thread pool handles execution with max_workers cap to prevent
+        resource exhaustion.
+        """
+
+        def _upsert():
+            try:
+                if status_override:
+                    self.exporter.upsert_span(span, status_override=status_override)
+                else:
+                    self.exporter.upsert_span(span)
+            except Exception as e:
+                logger.debug(f"Failed to upsert span: {e}")
+
+        # Submit to thread pool and return immediately (non-blocking)
+        # The timeout parameter is reserved for shutdown operations
+        self.executor.submit(_upsert)
+
+    def on_start(
+        self, span: Span, parent_context: context_api.Context | None = None
+    ) -> None:
+        """Called when span starts - upsert with RUNNING status (non-blocking)."""
+        # Apply factory span filter if configured
+        if self.span_filter is None or self.span_filter(span):
+            self._upsert_span_async(span, status_override=SpanStatus.RUNNING)
+
+    def on_end(self, span: ReadableSpan) -> None:
+        """Called when span ends - upsert with final status (non-blocking)."""
+        # Apply factory span filter if configured
+        if self.span_filter is None or self.span_filter(span):
+            self._upsert_span_async(span)
+
+    def shutdown(self) -> None:
+        """Shutdown the processor and wait for pending tasks to complete."""
+        try:
+            self.executor.shutdown(wait=True)
+        except Exception as e:
+            logger.debug(f"Executor shutdown failed: {e}")
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush - no-op for live tracking."""
+        return True
diff --git a/packages/uipath/src/uipath/tracing/_otel_exporters.py b/packages/uipath/src/uipath/tracing/_otel_exporters.py
new file mode 100644
index 000000000..d2bf3a7c1
--- /dev/null
+++ b/packages/uipath/src/uipath/tracing/_otel_exporters.py
@@ -0,0 +1,455 @@
+import json
+import logging
+import os
+import time
+from typing import Any, Dict, List, Optional, Sequence
+
+import httpx
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+from uipath.platform.common import _SpanUtils
+from uipath.platform.common.retry import NON_RETRYABLE_STATUS_CODES
+
+logger = logging.getLogger(__name__)
+
+_NIL_UUID = "00000000-0000-0000-0000-000000000000"
+
+
+def _normalize_process_key(value: Optional[str]) -> Optional[str]:
+    return None if not value or value == _NIL_UUID else value
+
+
+class SpanStatus:
+    """Span status values matching LLMOps StatusEnum."""
+
+    UNSET = 0
+    OK = 1
+    ERROR = 2
+    RUNNING = 3
+    RESTRICTED = 4
+    CANCELLED = 5
+
+
+def _safe_parse_json(s: Any) -> Any:
+    """Safely parse a JSON string, returning the original if not a string or on error."""
+    if not isinstance(s, str):
+        return s
+    try:
+        return json.loads(s)
+    except (json.JSONDecodeError, TypeError):
+        return s
+
+
+def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str, Any]]:
+    """Extracts and reconstructs LLM messages from flattened attributes."""
+    messages: dict[int, dict[str, Any]] = {}
+    message_prefix = f"{prefix}."
+    prefix_len = len(message_prefix)
+
+    for key, value in attributes.items():
+        if key.startswith(message_prefix):
+            # Avoid repeated string slicing and splits
+            parts = key[prefix_len:].split(".")
+            if len(parts) >= 2 and parts[0].isdigit():
+                index = int(parts[0])
+                if index not in messages:
+                    messages[index] = {}
+                current: Any = messages[index]
+
+                # Traverse parts except the last one
+                parts_len = len(parts)
+                for i in range(1, parts_len - 1):
+                    part = parts[i]
+                    key_part: str | int = part
+                    if part.isdigit() and (
+                        i + 2 < parts_len and parts[i + 2].isdigit()
+                    ):
+                        key_part = int(part)
+
+                    if isinstance(current, dict):
+                        if key_part not in current:
+                            current[key_part] = {}
+                        current = current[key_part]
+                    elif isinstance(current, list) and isinstance(key_part, int):
+                        if key_part >= len(current):
+                            current.append({})
+                        current = current[key_part]
+
+                current[parts[-1]] = value
+
+    # Convert dict to list, ordered by index, avoid sorted() if we can use range
+    if not messages:
+        return []
+
+    # Convert dict to list, ordered by index
+    return [messages[i] for i in sorted(messages.keys())]
+
+
+class LlmOpsHttpExporter(SpanExporter):
+    """An OpenTelemetry span exporter that sends spans to UiPath LLM Ops."""
+
+    ATTRIBUTE_MAPPING: dict[str, str | tuple[str, Any]] = {
+        "input.value": ("input", _safe_parse_json),
+        "output.value": ("output", _safe_parse_json),
+        "llm.model_name": "model",
+    }
+
+    # Mapping of span types
+    SPAN_TYPE_MAPPING: dict[str, str] = {
+        "LLM": "completion",
+        "TOOL": "toolCall",
+        # Add more mappings as needed
+    }
+
+    class Status:
+        SUCCESS = 1
+        ERROR = 2
+        INTERRUPTED = 3
+
+    def __init__(
+        self,
+        trace_id: Optional[str] = None,
+    ):
+        """Initialize the exporter with the base URL and authentication token.
+
+        Args:
+            trace_id: Optional trace ID to use for all spans
+        """
+        super().__init__()
+        self.base_url = self._get_base_url()
+        self.auth_token = os.environ.get("UIPATH_ACCESS_TOKEN")
+        self.headers: dict[str, str] = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth_token}",
+        }
+
+        if os.environ.get("UIPATH_TRACE_BASE_URL"):
+            self.headers["X-UiPath-Internal-TenantId"] = os.environ.get(
+                "UIPATH_TENANT_ID", ""
+            )
+            self.headers["X-UiPath-Internal-AccountId"] = os.environ.get(
+                "UIPATH_ORGANIZATION_ID", ""
+            )
+
+        client_kwargs = get_httpx_client_kwargs(headers=self.headers)
+
+        self.http_client = httpx.Client(**client_kwargs)
+        self.trace_id = trace_id
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans to UiPath LLM Ops."""
+        if len(spans) == 0:
+            logger.warning("No spans to export")
+            return SpanExportResult.SUCCESS
+
+        logger.debug(
+            f"Exporting {len(spans)} spans to {self.base_url}/api/Traces/spans"
+        )
+
+        # Use optimized path: keep attributes as dict for processing
+        # Only serialize at the very end
+        span_list = [
+            _SpanUtils.otel_span_to_uipath_span(
+                span, custom_trace_id=self.trace_id, serialize_attributes=False
+            ).to_dict(serialize_attributes=False)
+            for span in spans
+        ]
+
+        url = self._build_url(span_list)
+
+        # Process spans in-place - work directly with dict
+        for span_data in span_list:
+            if "ProcessKey" in span_data:
+                span_data["ProcessKey"] = _normalize_process_key(
+                    span_data["ProcessKey"]
+                )
+            self._process_span_attributes(span_data)
+
+        # Serialize attributes once at the very end
+        for span_data in span_list:
+            if isinstance(span_data.get("Attributes"), dict):
+                span_data["Attributes"] = json.dumps(span_data["Attributes"])
+
+        # Only serialize for logging if debug is enabled to avoid allocation
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Payload: %s", json.dumps(span_list))
+
+        return self._send_with_retries(url, span_list)
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush the exporter."""
+        return True
+
+    def upsert_span(
+        self,
+        span: ReadableSpan,
+        status_override: Optional[int] = None,
+    ) -> SpanExportResult:
+        """Upsert a single span to LLMOps for real-time state updates.
+
+        Unlike export(), can be called multiple times with the same span ID.
+        Used for resumable spans that need state updates (RUNNING → OK).
+
+        Args:
+            span: OTel Span (live or ReadableSpan)
+            status_override: Override status (e.g., SpanStatus.RUNNING)
+
+        Returns:
+            SpanExportResult indicating success or failure
+        """
+        span_data = _SpanUtils.otel_span_to_uipath_span(
+            span, custom_trace_id=self.trace_id, serialize_attributes=False
+        ).to_dict(serialize_attributes=False)
+
+        url = self._build_url([span_data])
+
+        if "ProcessKey" in span_data:
+            span_data["ProcessKey"] = _normalize_process_key(span_data["ProcessKey"])
+        self._process_span_attributes(span_data)
+
+        # Apply status override after processing (which may set status from error)
+        if status_override is not None:
+            span_data["Status"] = status_override
+
+        if isinstance(span_data.get("Attributes"), dict):
+            span_data["Attributes"] = json.dumps(span_data["Attributes"])
+
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Upsert payload: %s", json.dumps([span_data]))
+
+        return self._send_with_retries(url, [span_data])
+
+    def _map_llm_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
+        """Maps attributes for LLM calls, handling flattened keys."""
+        # Modify attributes in place to avoid copy
+        result = attributes
+
+        # Token Usage
+        token_keys = {
+            "llm.token_count.prompt": "promptTokens",
+            "llm.token_count.completion": "completionTokens",
+            "llm.token_count.total": "totalTokens",
+        }
+        usage = {
+            new_key: attributes.get(old_key)
+            for old_key, new_key in token_keys.items()
+            if old_key in attributes
+        }
+        if usage:
+            result["usage"] = usage
+
+        # Input/Output Messages
+        result["input"] = _get_llm_messages(attributes, "llm.input_messages")
+        output_messages = _get_llm_messages(attributes, "llm.output_messages")
+        result["output"] = output_messages
+
+        # Invocation Parameters
+        invocation_params = _safe_parse_json(
+            attributes.get("llm.invocation_parameters", "{}")
+        )
+        if isinstance(invocation_params, dict):
+            result["model"] = invocation_params.get("model", result.get("model"))
+            settings: dict[str, Any] = {}
+            if "max_tokens" in invocation_params:
+                settings["maxTokens"] = invocation_params["max_tokens"]
+            if "temperature" in invocation_params:
+                settings["temperature"] = invocation_params["temperature"]
+            if settings:
+                result["settings"] = settings
+
+        # Tool Calls
+        tool_calls: list[dict[str, Any]] = []
+        for msg in output_messages:
+            # Ensure msg is a dictionary before proceeding
+            if not isinstance(msg, dict):
+                continue
+            msg_tool_calls = msg.get("message", {}).get("tool_calls", [])
+
+            # Ensure msg_tool_calls is a list
+            if not isinstance(msg_tool_calls, list):
+                continue
+
+            for tc in msg_tool_calls:
+                if not isinstance(tc, dict):
+                    continue
+                tool_call_data = tc.get("tool_call", {})
+                if not isinstance(tool_call_data, dict):
+                    continue
+                tool_calls.append(
+                    {
+                        "id": tool_call_data.get("id"),
+                        "name": tool_call_data.get("function", {}).get("name"),
+                        "arguments": _safe_parse_json(
+                            tool_call_data.get("function", {}).get("arguments", "{}")
+                        ),
+                    }
+                )
+        if tool_calls:
+            result["toolCalls"] = tool_calls
+
+        return result
+
+    def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
+        """Maps attributes for tool calls."""
+        # Modify attributes in place to avoid copy
+        result = attributes
+
+        result["type"] = "toolCall"
+        result["callId"] = attributes.get("call_id") or attributes.get("id")
+        result["toolName"] = attributes.get("tool.name")
+        result["arguments"] = _safe_parse_json(
+            attributes.get("input", attributes.get("input.value", "{}"))
+        )
+        result["toolType"] = result.get("toolType") or "Integration"
+        result["result"] = _safe_parse_json(
+            attributes.get("output", attributes.get("output.value"))
+        )
+
+        return result
+
+    def _determine_status(self, error: Optional[Any]) -> int:
+        if error:
+            if isinstance(error, str) and error.startswith("GraphInterrupt("):
+                return self.Status.INTERRUPTED
+            return self.Status.ERROR
+        return self.Status.SUCCESS
+
+    def _process_span_attributes(self, span_data: Dict[str, Any]) -> None:
+        """Extracts, transforms, and maps attributes for a span in-place.
+
+        Args:
+            span_data: Span dict with Attributes as dict or JSON string
+
+        Note:
+            Modifies span_data in-place. When optimized path is used (dict),
+            modifies dict directly. When legacy path is used (str), parse → modify → serialize.
+        """
+        if "Attributes" not in span_data:
+            return
+
+        attributes_val = span_data["Attributes"]
+        if isinstance(attributes_val, str):
+            # Legacy path: parse JSON string
+            try:
+                attributes: Dict[str, Any] = json.loads(attributes_val)
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse attributes JSON: {e}")
+                return
+        elif isinstance(attributes_val, dict):
+            # Optimized path: work directly with dict
+            attributes = attributes_val
+        else:
+            return
+
+        # Determine SpanType
+        if "openinference.span.kind" in attributes:
+            span_type = attributes["openinference.span.kind"]
+            span_data["SpanType"] = self.SPAN_TYPE_MAPPING.get(span_type, span_type)
+
+        # Apply basic attribute mapping
+        for old_key, mapping in self.ATTRIBUTE_MAPPING.items():
+            if old_key in attributes:
+                if isinstance(mapping, tuple):
+                    new_key, func = mapping
+                    attributes[new_key] = func(attributes[old_key])
+                else:
+                    new_key = mapping
+                    attributes[new_key] = attributes[old_key]
+
+        # Apply detailed mapping based on SpanType
+        # Modify attributes dict in place to avoid allocations
+        span_type = span_data.get("SpanType")
+        if span_type == "completion":
+            self._map_llm_call_attributes(attributes)
+        elif span_type == "toolCall":
+            self._map_tool_call_attributes(attributes)
+
+        # Parse JSON-encoded strings that should be objects (avoids double-encoding)
+        # OTEL only accepts primitives, so agents serialize dicts to JSON strings.
+        # Detect and parse any string that looks like JSON object/array.
+        for key, value in attributes.items():
+            if isinstance(value, str) and value and value[0] in "{[":
+                attributes[key] = _safe_parse_json(value)
+
+        # If attributes were a string (legacy path), serialize back
+        # If dict (optimized path), leave as dict - caller will serialize once at the end
+        if isinstance(attributes_val, str):
+            span_data["Attributes"] = json.dumps(attributes)
+
+        # Determine status based on error information
+        error = attributes.get("error") or attributes.get("exception.message")
+        status = self._determine_status(error)
+        span_data["Status"] = status
+
+    def _build_url(self, span_list: list[Dict[str, Any]]) -> str:
+        """Construct the URL for the API request."""
+        trace_id = str(span_list[0]["TraceId"])
+        return f"{self.base_url}/api/Traces/spans?traceId={trace_id}&source=CodedAgents"
+
+    def _send_with_retries(
+        self, url: str, payload: list[Dict[str, Any]], max_retries: int = 4
+    ) -> SpanExportResult:
+        """Send the HTTP request with retry logic."""
+        for attempt in range(max_retries):
+            try:
+                response = self.http_client.post(url, json=payload)
+                if response.status_code == 200:
+                    return SpanExportResult.SUCCESS
+
+                logger.warning(
+                    f"Attempt {attempt + 1} failed with status code {response.status_code}: {response.text}"
+                )
+
+                if response.status_code in NON_RETRYABLE_STATUS_CODES:
+                    return SpanExportResult.FAILURE
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1} failed with exception: {e}")
+
+            if attempt < max_retries - 1:
+                time.sleep(1.5**attempt)  # Exponential backoff
+
+        return SpanExportResult.FAILURE
+
+    def _get_base_url(self) -> str:
+        trace_base_url = os.environ.get("UIPATH_TRACE_BASE_URL")
+        if trace_base_url:
+            return trace_base_url.rstrip("/")
+
+        uipath_url = (
+            os.environ.get("UIPATH_URL")
+            or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
+        )
+
+        uipath_url = uipath_url.rstrip("/")
+
+        return f"{uipath_url}/llmopstenant_"
+
+
+class JsonLinesFileExporter(SpanExporter):
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        # Ensure the directory exists
+        dir_path = os.path.dirname(self.file_path)
+        if dir_path:  # Only create if there's an actual directory path
+            os.makedirs(dir_path, exist_ok=True)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        try:
+            dict_spans = [span.to_json(indent=None) for span in spans]
+
+            with open(self.file_path, "a") as f:
+                for span in dict_spans:
+                    f.write(span + "\n")
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Failed to export spans to {self.file_path}: {e}")
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        """Shuts down the exporter."""
+        pass
diff --git a/packages/uipath/src/uipath/tracing/_utils.py b/packages/uipath/src/uipath/tracing/_utils.py
new file mode 100644
index 000000000..679f92530
--- /dev/null
+++ b/packages/uipath/src/uipath/tracing/_utils.py
@@ -0,0 +1,17 @@
+"""Re-export from uipath.platform.common for backward compatibility."""
+
+from uipath.platform.common._span_utils import (
+    AttachmentDirection,
+    AttachmentProvider,
+    SpanAttachment,
+    UiPathSpan,
+    _SpanUtils,
+)
+
+__all__ = [
+    "AttachmentDirection",
+    "AttachmentProvider",
+    "SpanAttachment",
+    "UiPathSpan",
+    "_SpanUtils",
+]
diff --git a/packages/uipath/src/uipath/utils/__init__.py b/packages/uipath/src/uipath/utils/__init__.py
new file mode 100644
index 000000000..fd041ad1e
--- /dev/null
+++ b/packages/uipath/src/uipath/utils/__init__.py
@@ -0,0 +1,7 @@
+"""Re-export from uipath.platform for backward compatibility."""
+
+from uipath.platform.common._endpoints_manager import EndpointManager  # noqa: D104
+
+__all__ = [
+    "EndpointManager",
+]
diff --git a/packages/uipath/testcases/apicalls-testcase/main.py b/packages/uipath/testcases/apicalls-testcase/main.py
new file mode 100644
index 000000000..fe8812f9c
--- /dev/null
+++ b/packages/uipath/testcases/apicalls-testcase/main.py
@@ -0,0 +1,73 @@
+import logging
+from dataclasses import dataclass
+
+from uipath.platform import UiPath
+from uipath.platform.orchestrator import AssetsService, AttachmentsService, BucketsService, FolderService, JobsService, McpService, ProcessesService, QueuesService
+from uipath.platform.action_center import TasksService
+from uipath.platform.connections import ConnectionsService
+from uipath.platform.context_grounding import ContextGroundingService
+from uipath.platform.chat import ConversationsService
+from uipath.platform.documents import DocumentsService
+from uipath.platform.entities import EntitiesService
+from uipath.platform.resource_catalog import ResourceCatalogService
+
+logger = logging.getLogger(__name__)
+
+sdk = None
+
+
+def test_assets(sdk: UiPath):
+    sdk.assets.retrieve(name="MyAsset")
+
+
+async def test_llm(sdk: UiPath):
+    messages = [
+        {"role": "system", "content": "You are a helpful programming assistant."},
+        {"role": "user", "content": "How do I read a file in Python?"},
+        {"role": "assistant", "content": "You can use the built-in open() function."},
+        {"role": "user", "content": "Can you show an example?"},
+    ]
+
+    result_openai = await sdk.llm_openai.chat_completions(messages)
+    logger.info("LLM OpenAI Response: %s", result_openai.choices[0].message.content)
+
+    result_normalized = await sdk.llm.chat_completions(messages)
+    logger.info(
+        "LLM Normalized Response: %s", result_normalized.choices[0].message.content
+    )
+
+async def test_imports(sdk: UiPath):
+    logger.info("BucketsService imported: %s", BucketsService)
+    logger.info("QueuesService imported: %s", QueuesService)
+    logger.info("AssetsService imported: %s", AssetsService)
+    logger.info("AttachmentsService imported: %s", AttachmentsService)
+    logger.info("ConnectionsService imported: %s", ConnectionsService)
+    logger.info("ContextGroundingService imported: %s", ContextGroundingService)
+    logger.info("ConversationsService imported: %s", ConversationsService)
+    logger.info("DocumentsService imported: %s", DocumentsService)
+    logger.info("EntitiesService imported: %s", EntitiesService)
+    logger.info("FolderService imported: %s", FolderService)
+    logger.info("JobsService imported: %s", JobsService)
+    logger.info("McpService imported: %s", McpService)
+    logger.info("ProcessesService imported: %s", ProcessesService)
+    logger.info("ResourceCatalogService imported: %s", ResourceCatalogService)
+    logger.info("TasksService imported: %s", TasksService)
+    logger.info("Imports test passed.")
+
+@dataclass
+class EchoIn:
+    message: str
+
+
+@dataclass
+class EchoOut:
+    message: str
+
+
+async def main(input: EchoIn) -> EchoOut:
+    sdk = UiPath()
+
+    await test_llm(sdk)
+    await test_imports(sdk)
+
+    return EchoOut(message=input.message)
diff --git a/packages/uipath/testcases/apicalls-testcase/pyproject.toml b/packages/uipath/testcases/apicalls-testcase/pyproject.toml
new file mode 100644
index 000000000..cc8781624
--- /dev/null
+++ b/packages/uipath/testcases/apicalls-testcase/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "agent"
+version = "0.0.1"
+description = "agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
\ No newline at end of file
diff --git a/packages/uipath/testcases/apicalls-testcase/run.sh b/packages/uipath/testcases/apicalls-testcase/run.sh
new file mode 100644
index 000000000..6d512f38c
--- /dev/null
+++ b/packages/uipath/testcases/apicalls-testcase/run.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Run init..."
+uv run uipath init
+
+echo "Packing agent..."
+uv run uipath pack
+
+echo "Input from input.json file"
+uv run uipath run main '{"message": "abc" }'
diff --git a/packages/uipath/testcases/apicalls-testcase/src/assert.py b/packages/uipath/testcases/apicalls-testcase/src/assert.py
new file mode 100644
index 000000000..025ddf212
--- /dev/null
+++ b/packages/uipath/testcases/apicalls-testcase/src/assert.py
@@ -0,0 +1,32 @@
+import json
+import os
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields for ticket classification agent
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+print("Required fields validation passed")
diff --git a/packages/uipath/testcases/apicalls-testcase/uipath.json b/packages/uipath/testcases/apicalls-testcase/uipath.json
new file mode 100644
index 000000000..ee698d9df
--- /dev/null
+++ b/packages/uipath/testcases/apicalls-testcase/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/testcases/basic-testcase/main.py b/packages/uipath/testcases/basic-testcase/main.py
new file mode 100644
index 000000000..49fa0e055
--- /dev/null
+++ b/packages/uipath/testcases/basic-testcase/main.py
@@ -0,0 +1,29 @@
+import logging
+from dataclasses import dataclass
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EchoIn:
+    message: str
+    repeat: int | None = 1
+    prefix: str | None = None
+
+
+@dataclass
+class EchoOut:
+    message: str
+
+
+def main(input: EchoIn) -> EchoOut:
+    result = []
+
+    for _ in range(input.repeat):
+        line = input.message
+        if input.prefix:
+            line = f"{input.prefix}: {line}"
+        result.append(line)
+
+    return EchoOut(message="\n".join(result))
diff --git a/packages/uipath/testcases/basic-testcase/pyproject.toml b/packages/uipath/testcases/basic-testcase/pyproject.toml
new file mode 100644
index 000000000..cc8781624
--- /dev/null
+++ b/packages/uipath/testcases/basic-testcase/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "agent"
+version = "0.0.1"
+description = "agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
\ No newline at end of file
diff --git a/packages/uipath/testcases/basic-testcase/run.sh b/packages/uipath/testcases/basic-testcase/run.sh
new file mode 100644
index 000000000..506ba8ab6
--- /dev/null
+++ b/packages/uipath/testcases/basic-testcase/run.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Run init..."
+uv run uipath init
+
+echo "Packing agent..."
+uv run uipath pack
+
+echo "Run agent with input from cli"
+uv run uipath run main '{"message": "abc", "repeat": 2, "prefix": "xyz"}'
diff --git a/packages/uipath/testcases/basic-testcase/src/assert.py b/packages/uipath/testcases/basic-testcase/src/assert.py
new file mode 100644
index 000000000..025ddf212
--- /dev/null
+++ b/packages/uipath/testcases/basic-testcase/src/assert.py
@@ -0,0 +1,32 @@
+import json
+import os
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields for ticket classification agent
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+print("Required fields validation passed")
diff --git a/packages/uipath/testcases/basic-testcase/uipath.json b/packages/uipath/testcases/basic-testcase/uipath.json
new file mode 100644
index 000000000..ee698d9df
--- /dev/null
+++ b/packages/uipath/testcases/basic-testcase/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/testcases/calculator-crash-evals/pyproject.toml b/packages/uipath/testcases/calculator-crash-evals/pyproject.toml
new file mode 100644
index 000000000..f96b0ecc0
--- /dev/null
+++ b/packages/uipath/testcases/calculator-crash-evals/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "calculator-agent"
+version = "0.0.1"
+description = "Calculator agent testcase with custom evaluators"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/calculator-crash-evals/run.sh b/packages/uipath/testcases/calculator-crash-evals/run.sh
new file mode 100755
index 000000000..f5a050f11
--- /dev/null
+++ b/packages/uipath/testcases/calculator-crash-evals/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running evaluations with custom evaluator..."
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/crash-scenarios.json --no-report
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/calculator-crash-evals/src/assert.py b/packages/uipath/testcases/calculator-crash-evals/src/assert.py
new file mode 100644
index 000000000..89622953d
--- /dev/null
+++ b/packages/uipath/testcases/calculator-crash-evals/src/assert.py
@@ -0,0 +1,106 @@
+"""Assertions for calculator-crash-evals testcase.
+
+This script validates that the calculator crash evaluations work correctly by:
+1. Reading the evaluation output from __uipath/output.json
+2. Validating that all evaluations have scores equal to 0 (since the calculator crashes)
+"""
+
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # Check if output file exists
+    output_file = "__uipath/output.json"
+
+    assert os.path.isfile(output_file), (
+        f"Evaluation output file '{output_file}' not found"
+    )
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    # Load evaluation results
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print("✓ Loaded evaluation output")
+
+    # Check status
+    status = output_data.get("status")
+    assert status == "successful", f"Evaluation run failed with status: {status}"
+    print("✓ Evaluation run status: successful")
+
+    # Extract output data
+    output = output_data.get("output", {})
+
+    # Validate structure
+    assert "evaluationSetResults" in output, "Missing 'evaluationSetResults' in output"
+
+    evaluation_results = output["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+
+    print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+    # Validate each evaluation result
+    passed_count = 0
+    failed_count = 0
+    skipped_count = 0
+    all_scores_zero = True
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        print(f"\n→ Validating: {eval_name}")
+
+        try:
+            # Validate evaluation results are present
+            eval_run_results = eval_result.get("evaluationRunResults", [])
+            if len(eval_run_results) == 0:
+                print(f"  ⊘ Skipping '{eval_name}' (no evaluation run results)")
+                skipped_count += 1
+                continue
+
+            # Check that all evaluations have scores equal to 0
+            all_passed = True
+            for eval_run in eval_run_results:
+                evaluator_name = eval_run.get("evaluatorName", "Unknown")
+                result = eval_run.get("result", {})
+                score = result.get("score", 0)
+
+                # Check if score is equal to 0
+                if score == 0:
+                    print(f"  ✓ {evaluator_name}: score={score:.1f} (expected 0)")
+                else:
+                    print(f"  ✗ {evaluator_name}: score={score:.1f} (expected 0)")
+                    all_passed = False
+                    all_scores_zero = False
+
+            if all_passed:
+                print(f"  ✓ All evaluators passed for '{eval_name}' (all scores are 0)")
+                passed_count += 1
+            else:
+                print(f"  ✗ Some evaluators failed for '{eval_name}'")
+                failed_count += 1
+
+        except Exception as e:
+            print(f"  ✗ Error validating '{eval_name}': {e}")
+            failed_count += 1
+
+    # Final summary
+    print(f"\n{'=' * 60}")
+    print("Summary:")
+    print(f"  Total evaluations: {passed_count + failed_count + skipped_count}")
+    print(f"  ✓ Passed: {passed_count}")
+    print(f"  ✗ Failed: {failed_count}")
+    print(f"  ⊘ Skipped: {skipped_count}")
+    print(f"{'=' * 60}")
+
+    assert failed_count == 0, "Some assertions failed"
+    assert all_scores_zero, "Not all evaluation scores are 0 as expected"
+
+    print(
+        "\n✅ All assertions passed! All scores are 0 as expected for crash scenarios."
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/calculator-crash-evals/uipath.json b/packages/uipath/testcases/calculator-crash-evals/uipath.json
new file mode 100644
index 000000000..04945ab0a
--- /dev/null
+++ b/packages/uipath/testcases/calculator-crash-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/testcases/calculator-evals/pyproject.toml b/packages/uipath/testcases/calculator-evals/pyproject.toml
new file mode 100644
index 000000000..f96b0ecc0
--- /dev/null
+++ b/packages/uipath/testcases/calculator-evals/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "calculator-agent"
+version = "0.0.1"
+description = "Calculator agent testcase with custom evaluators"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/calculator-evals/run.sh b/packages/uipath/testcases/calculator-evals/run.sh
new file mode 100755
index 000000000..361529628
--- /dev/null
+++ b/packages/uipath/testcases/calculator-evals/run.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running evaluations with custom evaluator..."
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/legacy.json --no-report --output-file legacy.json
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/default.json --no-report --output-file default.json
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/multi-model.json --no-report --output-file multi-model.json
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/trajectory-multi-model.json --no-report --output-file trajectory-multi-model.json
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/faithfulness-multi-model.json --no-report --output-file faithfulness-multi-model.json
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/context-precision-multi-model.json --no-report --output-file context-precision-multi-model.json
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/calculator-evals/src/assert.py b/packages/uipath/testcases/calculator-evals/src/assert.py
new file mode 100644
index 000000000..a3ae42088
--- /dev/null
+++ b/packages/uipath/testcases/calculator-evals/src/assert.py
@@ -0,0 +1,151 @@
+"""Assertions for calculator-evals testcase.
+
+This script validates that the calculator evaluations work correctly by:
+1. Reading the evaluation output from __uipath/output.json
+2. Validating that evaluations have scores greater than 0
+"""
+
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # Check if output file exists
+    for output_file in [
+        "default.json",
+        "legacy.json",
+        "multi-model.json",
+        "trajectory-multi-model.json",
+        "faithfulness-multi-model.json",
+        "context-precision-multi-model.json",
+    ]:
+        assert os.path.isfile(output_file), (
+            f"Evaluation output file '{output_file}' not found"
+        )
+        print(f"✓ Found evaluation output file: {output_file}")
+
+        # Load evaluation results
+        with open(output_file, "r", encoding="utf-8") as f:
+            output_data = json.load(f)
+
+        print("✓ Loaded evaluation output")
+
+        # Extract output data
+        output = output_data
+
+        # Validate structure
+        assert "evaluationSetResults" in output, (
+            "Missing 'evaluationSetResults' in output"
+        )
+
+        evaluation_results = output["evaluationSetResults"]
+        assert len(evaluation_results) > 0, "No evaluation results found"
+
+        print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+        # Validate each evaluation result
+        passed_count = 0
+        failed_count = 0
+        skipped_count = 0
+        has_positive_scores = False
+        has_non_rag_evaluators = False
+
+        for eval_result in evaluation_results:
+            eval_name = eval_result.get("evaluationName", "Unknown")
+            print(f"\n→ Validating: {eval_name}")
+
+            try:
+                # Validate evaluation results are present
+                eval_run_results = eval_result.get("evaluationRunResults", [])
+                if len(eval_run_results) == 0:
+                    print(f"  ⊘ Skipping '{eval_name}' (no evaluation run results)")
+                    skipped_count += 1
+                    continue
+
+                # Check that evaluations have scores > 0
+                all_passed = True
+                min_score = 100
+                for eval_run in eval_run_results:
+                    evaluator_name = eval_run.get("evaluatorName", "Unknown")
+                    result = eval_run.get("result", {})
+                    score = result.get("score", 0)
+                    min_score = min(min_score, score)
+
+                    # Allow 0 scores for Faithfulness and ContextPrecision evaluators
+                    # since calculator doesn't use RAG/context grounding
+                    is_rag_evaluator = any(
+                        x in evaluator_name
+                        for x in ["Faithfulness", "ContextPrecision"]
+                    )
+
+                    if not is_rag_evaluator:
+                        has_non_rag_evaluators = True
+
+                    # Check if score is greater than 0
+                    if score > 0:
+                        has_positive_scores = True
+                        print(f"  ✓ {evaluator_name}: score={score:.1f}")
+                    elif is_rag_evaluator:
+                        print(
+                            f"  ⊘ {evaluator_name}: score={score:.1f} (RAG evaluator, 0 allowed)"
+                        )
+                    else:
+                        print(f"  ✗ {evaluator_name}: score={score:.1f} (must be > 0)")
+                        all_passed = False
+
+                if all_passed and min_score > 0:
+                    print(
+                        f"  ✓ All evaluators passed for '{eval_name}' (min score: {min_score:.1f})"
+                    )
+                    passed_count += 1
+                elif all_passed:
+                    print(
+                        f"  ⊘ All evaluators passed for '{eval_name}' (some RAG evaluators scored 0)"
+                    )
+                    passed_count += 1
+                else:
+                    print(f"  ✗ Some evaluators failed for '{eval_name}'")
+                    failed_count += 1
+
+            except Exception as e:
+                print(f"  ✗ Error validating '{eval_name}': {e}")
+                failed_count += 1
+
+        # Final summary
+        print(f"\n{'=' * 60}")
+        print("Summary:")
+        print(f"  Total evaluations: {passed_count + failed_count + skipped_count}")
+        print(f"  ✓ Passed: {passed_count}")
+        print(f"  ✗ Failed: {failed_count}")
+        print(f"  ⊘ Skipped: {skipped_count}")
+        print(f"{'=' * 60}")
+
+        assert failed_count == 0, "Some assertions failed"
+        # Only require positive scores if there are non-RAG evaluators
+        # RAG evaluators can legitimately score 0 on non-RAG agents like calculator
+        if has_non_rag_evaluators:
+            assert has_positive_scores, "No evaluation scores greater than 0 were found"
+
+        print("\n✅ All assertions passed!")
+
+    output_file = "__uipath/output.json"
+    assert os.path.isfile(output_file), (
+        f"Evaluation output file '{output_file}' not found"
+    )
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    # Load evaluation results
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print("✓ Loaded evaluation output")
+
+    # Check status
+    status = output_data.get("status")
+    assert status == "successful", f"Evaluation run failed with status: {status}"
+    print("✓ Evaluation run status: successful")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/calculator-evals/uipath.json b/packages/uipath/testcases/calculator-evals/uipath.json
new file mode 100644
index 000000000..04945ab0a
--- /dev/null
+++ b/packages/uipath/testcases/calculator-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/testcases/common/trace_assert.py b/packages/uipath/testcases/common/trace_assert.py
new file mode 100644
index 000000000..e1ae76a74
--- /dev/null
+++ b/packages/uipath/testcases/common/trace_assert.py
@@ -0,0 +1,160 @@
+"""
+Simple trace assertion - just check that expected spans exist with required attributes.
+Much simpler than the tree-based approach.
+"""
+
+import json
+from typing import List, Dict, Any
+
+
+def load_traces(traces_file: str) -> List[Dict[str, Any]]:
+    """Load traces from a JSONL file."""
+    traces = []
+    with open(traces_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                traces.append(json.loads(line))
+    return traces
+
+
+def load_expected_traces(expected_file: str) -> List[Dict[str, Any]]:
+    """Load expected trace definitions from a JSON file."""
+    with open(expected_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    return data.get('required_spans', [])
+
+
+def get_attributes(span: Dict[str, Any]) -> Dict[str, Any]:
+    """Parse attributes from a span."""
+    return span.get('attributes', {})
+
+
+def matches_value(expected_value: Any, actual_value: Any) -> bool:
+    """
+    Check if an actual value matches the expected value.
+
+    Supports:
+    - List of possible values: ["value1", "value2"]
+    - Wildcard: "*" (any value accepted)
+    - Exact match: "value"
+    """
+    # Wildcard - accept any value
+    if expected_value == "*":
+        return True
+
+    # List of possible values
+    if isinstance(expected_value, list):
+        return actual_value in expected_value
+
+    # Exact match
+    return expected_value == actual_value
+
+
+def matches_expected(span: Dict[str, Any], expected: Dict[str, Any], all_spans: List[Dict[str, Any]] = None) -> bool:
+    """Check if a span matches the expected definition."""
+    # Check name - can be a string or list of possible names
+    expected_name = expected.get('name')
+    actual_name = span.get('name')
+
+    if isinstance(expected_name, list):
+        if actual_name not in expected_name:
+            return False
+    elif expected_name != actual_name:
+        return False
+
+    # Check span type if specified
+    if 'span_type' in expected:
+        actual_attrs = get_attributes(span)
+        actual_span_type = actual_attrs.get('span_type')
+
+        if actual_span_type != expected['span_type']:
+            return False
+
+    # Check parent if specified
+    if 'parent' in expected:
+        expected_parent = expected['parent']
+        actual_parent_id = span.get('parent_id')
+
+        # Handle null parent (root span)
+        if expected_parent is None:
+            if actual_parent_id is not None:
+                return False
+        else:
+            # Find parent span by name
+            if all_spans is None:
+                return False
+
+            parent_span = None
+            for s in all_spans:
+                if s.get('context', {}).get('span_id') == actual_parent_id:
+                    parent_span = s
+                    break
+
+            if parent_span is None:
+                return False
+
+            # Check if parent name matches expected
+            parent_name = parent_span.get('name')
+            if isinstance(expected_parent, list):
+                if parent_name not in expected_parent:
+                    return False
+            elif parent_name != expected_parent:
+                return False
+
+    # Check attributes if specified
+    if 'attributes' in expected:
+        actual_attrs = get_attributes(span)
+        for key, expected_value in expected['attributes'].items():
+            if key not in actual_attrs:
+                return False
+            # Use flexible value matching
+            if not matches_value(expected_value, actual_attrs[key]):
+                return False
+
+    return True
+
+
+def assert_traces(traces_file: str, expected_file: str) -> None:
+    """
+    Assert that all expected traces exist in the traces file.
+
+    Args:
+        traces_file: Path to the traces.jsonl file
+        expected_file: Path to the expected_traces.json file
+
+    Raises:
+        AssertionError: If any expected trace is not found
+    """
+    traces = load_traces(traces_file)
+    expected_spans = load_expected_traces(expected_file)
+
+    print(f"Loaded {len(traces)} traces from {traces_file}")
+    print(f"Checking {len(expected_spans)} expected spans...")
+
+    missing_spans = []
+
+    for expected in expected_spans:
+        # Find a matching span
+        found = False
+        for span in traces:
+            if matches_expected(span, expected, traces):
+                found = True
+                print(f"✓ Found span: {expected['name']}")
+                break
+
+        if not found:
+            missing_spans.append(expected['name'])
+            print(f"✗ Missing span: {expected['name']}")
+
+    if missing_spans:
+        raise AssertionError(
+            f"Missing expected spans: {', '.join(missing_spans)}\n"
+            f"Expected {len(expected_spans)} spans, found {len(expected_spans) - len(missing_spans)}"
+        )
+
+    print(f"\n✓ All {len(expected_spans)} expected spans found!")
+
+
+if __name__ == "__main__":
+    # Example usage
+    assert_traces(".uipath/traces.jsonl", "expected_traces.json")
\ No newline at end of file
diff --git a/packages/uipath/testcases/common/validate_output.sh b/packages/uipath/testcases/common/validate_output.sh
new file mode 100644
index 000000000..1e4cd1a59
--- /dev/null
+++ b/packages/uipath/testcases/common/validate_output.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+# Common utility to print UiPath output file
+# Usage: source /app/testcases/common/validate_output.sh
+
+debug_print_uipath_output() {
+    echo "Printing output file..."
+    if [ -f "__uipath/output.json" ]; then
+        echo "=== OUTPUT FILE CONTENT ==="
+        cat __uipath/output.json
+        echo "=== END OUTPUT FILE CONTENT ==="
+    else
+        echo "ERROR: __uipath/output.json not found!"
+        echo "Checking directory contents:"
+        ls -la
+        if [ -d "__uipath" ]; then
+            echo "Contents of __uipath directory:"
+            ls -la __uipath/
+        else
+            echo "__uipath directory does not exist!"
+        fi
+    fi
+}
+
+# Run assertions from the testcase's src directory
+run_assertions() {
+    echo "Running assertions..."
+    if [ -f "src/assert.py" ]; then
+        # Use uv run to ensure testcase dependencies are available
+        # Prepend the common directory to the python path so it can be resolved
+        PYTHONPATH="../common:$PYTHONPATH" uv run python src/assert.py
+    else
+        echo "assert.py not found in src directory!"
+        exit 1
+    fi
+}
+
+debug_print_uipath_output
+run_assertions
\ No newline at end of file
diff --git a/packages/uipath/testcases/csv-processor-evals/pyproject.toml b/packages/uipath/testcases/csv-processor-evals/pyproject.toml
new file mode 100644
index 000000000..144e93cf2
--- /dev/null
+++ b/packages/uipath/testcases/csv-processor-evals/pyproject.toml
@@ -0,0 +1,13 @@
+[project]
+name = "csv-processor-agent"
+version = "0.0.1"
+description = "CSV processor agent testcase with file input evaluations"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+    "pandas>=2.3.3",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/csv-processor-evals/run.sh b/packages/uipath/testcases/csv-processor-evals/run.sh
new file mode 100755
index 000000000..8a3eec5f3
--- /dev/null
+++ b/packages/uipath/testcases/csv-processor-evals/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Running evaluations with custom evaluators..."
+uv run uipath eval main ../../samples/csv-processor/evaluations/eval-sets/file-input-tests-local.json --no-report --output-file file-input-tests-local.json
+
+echo "Running assertions..."
+uv run python src/assert.py
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/csv-processor-evals/src/assert.py b/packages/uipath/testcases/csv-processor-evals/src/assert.py
new file mode 100644
index 000000000..999f89412
--- /dev/null
+++ b/packages/uipath/testcases/csv-processor-evals/src/assert.py
@@ -0,0 +1,116 @@
+"""Assertions for csv-processor-evals testcase.
+
+This script validates that the CSV processor evaluations work correctly by:
+1. Reading the evaluation output from file-input-tests-local.json
+2. Validating that evaluations have scores equal to 1.0
+"""
+
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # Check if output file exists
+    output_file = "file-input-tests-local.json"
+    assert os.path.isfile(output_file), (
+        f"Evaluation output file '{output_file}' not found"
+    )
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    # Load evaluation results
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print("✓ Loaded evaluation output")
+
+    # Extract output data
+    output = output_data
+
+    # Validate structure
+    assert "evaluationSetResults" in output, "Missing 'evaluationSetResults' in output"
+
+    evaluation_results = output["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+
+    print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+    # Validate each evaluation result
+    passed_count = 0
+    failed_count = 0
+    skipped_count = 0
+    has_perfect_scores = False
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        print(f"\n→ Validating: {eval_name}")
+
+        try:
+            # Validate evaluation results are present
+            eval_run_results = eval_result.get("evaluationRunResults", [])
+            if len(eval_run_results) == 0:
+                print(f"  ⊘ Skipping '{eval_name}' (no evaluation run results)")
+                skipped_count += 1
+                continue
+
+            # Check that evaluations have scores = 1.0
+            all_passed = True
+            min_score = 100
+            for eval_run in eval_run_results:
+                evaluator_name = eval_run.get("evaluatorName", "Unknown")
+                result = eval_run.get("result", {})
+                score = result.get("score", 0)
+                min_score = min(min_score, score)
+
+                # Check if score is 1.0
+                if score == 1.0:
+                    has_perfect_scores = True
+                    print(f"  ✓ {evaluator_name}: score={score:.1f}")
+                else:
+                    print(f"  ✗ {evaluator_name}: score={score:.1f} (expected 1.0)")
+                    all_passed = False
+
+            if all_passed and min_score == 1.0:
+                print(f"  ✓ All evaluators passed for '{eval_name}' (all scores: 1.0)")
+                passed_count += 1
+            else:
+                print(f"  ✗ Some evaluators failed for '{eval_name}'")
+                failed_count += 1
+
+        except Exception as e:
+            print(f"  ✗ Error validating '{eval_name}': {e}")
+            failed_count += 1
+
+    # Final summary
+    print(f"\n{'=' * 60}")
+    print("Summary:")
+    print(f"  Total evaluations: {passed_count + failed_count + skipped_count}")
+    print(f"  ✓ Passed: {passed_count}")
+    print(f"  ✗ Failed: {failed_count}")
+    print(f"  ⊘ Skipped: {skipped_count}")
+    print(f"{'=' * 60}")
+
+    assert failed_count == 0, "Some assertions failed"
+    assert has_perfect_scores, "No evaluation scores equal to 1.0 were found"
+
+    print("\n✅ All assertions passed!")
+
+    # Check __uipath/output.json if it exists
+    output_file = "__uipath/output.json"
+    if os.path.isfile(output_file):
+        print(f"\n✓ Found evaluation output file: {output_file}")
+
+        # Load evaluation results
+        with open(output_file, "r", encoding="utf-8") as f:
+            output_data = json.load(f)
+
+        print("✓ Loaded evaluation output")
+
+        # Check status
+        status = output_data.get("status")
+        assert status == "successful", f"Evaluation run failed with status: {status}"
+        print("✓ Evaluation run status: successful")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/csv-processor-evals/uipath.json b/packages/uipath/testcases/csv-processor-evals/uipath.json
new file mode 100644
index 000000000..f9241ecb0
--- /dev/null
+++ b/packages/uipath/testcases/csv-processor-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/csv-processor/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/eval-input-overrides/entry-points.json b/packages/uipath/testcases/eval-input-overrides/entry-points.json
new file mode 100644
index 000000000..a6648b47a
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/entry-points.json
@@ -0,0 +1,48 @@
+{
+    "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+    "$id": "entry-points.json",
+    "entryPoints": [
+        {
+            "filePath": "../../samples/calculator/main",
+            "uniqueId": "2137b503-2c5c-49f0-a45b-a1fa4bb45771",
+            "type": "agent",
+            "input": {
+                "type": "object",
+                "properties": {
+                    "a": {
+                        "type": "number"
+                    },
+                    "b": {
+                        "type": "number"
+                    },
+                    "operator": {
+                        "type": "string",
+                        "enum": [
+                            "+",
+                            "-",
+                            "*",
+                            "/",
+                            "random"
+                        ]
+                    }
+                },
+                "required": [
+                    "a",
+                    "b",
+                    "operator"
+                ]
+            },
+            "output": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "number"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/packages/uipath/testcases/eval-input-overrides/pyproject.toml b/packages/uipath/testcases/eval-input-overrides/pyproject.toml
new file mode 100644
index 000000000..13e449c77
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "eval-input-overrides"
+version = "0.0.1"
+description = "Integration testcase for input overrides functionality with calculator evals"
+authors = [{ name = "UiPath", email = "dev@uipath.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/eval-input-overrides/run.sh b/packages/uipath/testcases/eval-input-overrides/run.sh
new file mode 100755
index 000000000..741a6cb49
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/run.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo ""
+echo "Running evaluations with input overrides..."
+echo "Using eval set: src/input-overrides-eval-set.json"
+echo "Using input overrides: src/input-overrides.json"
+echo ""
+
+# Create output directory
+mkdir -p __uipath
+
+# Read input overrides from JSON file
+INPUT_OVERRIDES=$(cat src/input-overrides.json)
+
+# Run evaluations with input overrides
+uv run uipath eval main src/input-overrides-eval-set.json \
+  --no-report \
+  --output-file __uipath/output.json \
+  --input-overrides "$INPUT_OVERRIDES"
+
+echo ""
+echo "Evaluations completed! Verifying results..."
+echo ""
+
+# Run assertion script to verify results
+uv run python src/assert.py
+
+echo ""
+echo "✅ Input overrides integration test completed successfully!"
diff --git a/packages/uipath/testcases/eval-input-overrides/src/assert.py b/packages/uipath/testcases/eval-input-overrides/src/assert.py
new file mode 100644
index 000000000..8212b3a2b
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/src/assert.py
@@ -0,0 +1,76 @@
+"""Assertions for eval-input-overrides testcase.
+
+This script validates that input overrides work correctly by:
+1. Reading the evaluation output from __uipath/output.json
+2. Validating that overridden inputs produced expected results
+3. Verifying that non-overridden evaluations used original values
+4. Checking that all evaluations passed with scores > 0
+"""
+
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # Check if output file exists
+    output_file = "__uipath/output.json"
+
+    assert os.path.isfile(output_file), (
+        f"Evaluation output file '{output_file}' not found"
+    )
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    # Load evaluation results
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print("✓ Loaded evaluation output")
+
+    # Validate structure - output format doesn't have status/output wrapper
+    assert "evaluationSetResults" in output_data, (
+        "Missing 'evaluationSetResults' in output"
+    )
+
+    evaluation_results = output_data["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+
+    print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+    # Expected evaluation names
+    expected_evals = [
+        "Simple Field Override",
+        "Operator Override Only",
+        "Multiple Field Overrides",
+        "No Override - Use Original Values",
+    ]
+
+    # Validate each evaluation is present
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        print(f"\n→ Found evaluation: {eval_name}")
+
+        if eval_name in expected_evals:
+            print(f"  ✓ Evaluation '{eval_name}' completed")
+        else:
+            print(f"  ⚠ Unexpected evaluation name: '{eval_name}'")
+
+    # Final summary
+    print(f"\n{'=' * 70}")
+    print("Summary:")
+    print(f"  Total evaluations found: {len(evaluation_results)}")
+    print(f"  Expected evaluations: {len(expected_evals)}")
+    print(f"{'=' * 70}")
+
+    # Assertions
+    assert len(evaluation_results) == 4, (
+        f"Expected 4 evaluations, but found {len(evaluation_results)}"
+    )
+
+    print("\n✅ All input override evaluations completed successfully!")
+    print("✅ Input overrides were configured and applied during evaluation execution!")
+    print("✅ All expected evaluations are present in the output!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/eval-input-overrides/src/input-overrides-eval-set.json b/packages/uipath/testcases/eval-input-overrides/src/input-overrides-eval-set.json
new file mode 100644
index 000000000..3a42211da
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/src/input-overrides-eval-set.json
@@ -0,0 +1,48 @@
+{
+  "version": "1.0",
+  "id": "InputOverridesEvalSet",
+  "name": "Input Overrides Integration Test",
+  "evaluatorRefs": [],
+  "evaluations": [
+    {
+      "id": "test-simple-override",
+      "name": "Simple Field Override",
+      "inputs": {
+        "a": 5,
+        "b": 3,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "test-operator-override",
+      "name": "Operator Override Only",
+      "inputs": {
+        "a": 8,
+        "b": 2,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "test-multiple-overrides",
+      "name": "Multiple Field Overrides",
+      "inputs": {
+        "a": 1,
+        "b": 1,
+        "operator": "+"
+      },
+      "evaluationCriterias": {}
+    },
+    {
+      "id": "test-no-override",
+      "name": "No Override - Use Original Values",
+      "inputs": {
+        "a": 6,
+        "b": 7,
+        "operator": "*"
+      },
+      "evaluationCriterias": {}
+    }
+  ]
+}
diff --git a/packages/uipath/testcases/eval-input-overrides/src/input-overrides.json b/packages/uipath/testcases/eval-input-overrides/src/input-overrides.json
new file mode 100644
index 000000000..c3122d5a8
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/src/input-overrides.json
@@ -0,0 +1,14 @@
+{
+  "test-simple-override": {
+    "a": 10,
+    "operator": "*"
+  },
+  "test-operator-override": {
+    "operator": "/"
+  },
+  "test-multiple-overrides": {
+    "a": 7,
+    "b": 3,
+    "operator": "*"
+  }
+}
diff --git a/packages/uipath/testcases/eval-input-overrides/uipath.json b/packages/uipath/testcases/eval-input-overrides/uipath.json
new file mode 100644
index 000000000..2b8e5b396
--- /dev/null
+++ b/packages/uipath/testcases/eval-input-overrides/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/eval-level-expected-output/pyproject.toml b/packages/uipath/testcases/eval-level-expected-output/pyproject.toml
new file mode 100644
index 000000000..73286e014
--- /dev/null
+++ b/packages/uipath/testcases/eval-level-expected-output/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "eval-level-expected-output"
+version = "0.0.1"
+description = "Tests for evaluation-level expectedOutput on EvaluationItem"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/eval-level-expected-output/run.sh b/packages/uipath/testcases/eval-level-expected-output/run.sh
new file mode 100644
index 000000000..e62959d23
--- /dev/null
+++ b/packages/uipath/testcases/eval-level-expected-output/run.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running eval-level expectedOutput evaluations (deterministic evaluators)..."
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/eval-level-expected-output.json --no-report --output-file eval-level-expected-output.json
+
+echo "Running eval-level expectedOutput evaluations (LLM judge)..."
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/eval-level-expected-output-llm-judge.json --no-report --output-file eval-level-expected-output-llm-judge.json
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/eval-level-expected-output/src/assert.py b/packages/uipath/testcases/eval-level-expected-output/src/assert.py
new file mode 100644
index 000000000..0ce7af9f1
--- /dev/null
+++ b/packages/uipath/testcases/eval-level-expected-output/src/assert.py
@@ -0,0 +1,148 @@
+"""Assertions for eval-level-expected-output testcase.
+
+Validates that evaluation-level expectedOutput is correctly injected
+into output-based evaluators (ExactMatch, JsonSimilarity, LLMJudge)
+while non-output evaluators (Contains) remain unaffected.
+"""
+
+import json
+import os
+
+# Evaluators expected in the deterministic eval set
+DETERMINISTIC_EVALUATORS = {
+    "ExactMatchEvaluator",
+    "JsonSimilarityEvaluator",
+    "ContainsEvaluator",
+}
+
+# Evaluators expected in the LLM judge eval set
+LLM_JUDGE_EVALUATORS = {
+    "ExactMatchEvaluator",
+    "LLMJudgeOutputEvaluator",
+}
+
+# Evaluations in the deterministic eval set
+DETERMINISTIC_EVALUATIONS = {
+    "Eval-level expectedOutput with null criteria (addition)",
+    "Eval-level expectedOutput with null criteria (multiplication)",
+    "Per-evaluator expectedOutput overrides eval-level",
+    "Mixed: some evaluators null, some explicit",
+}
+
+# Evaluations in the LLM judge eval set
+LLM_JUDGE_EVALUATIONS = {
+    "LLM Judge uses eval-level expectedOutput (addition)",
+    "LLM Judge uses eval-level expectedOutput (multiplication)",
+}
+
+
+def validate_output_file(
+    output_file: str,
+    expected_evaluations: set[str],
+    expected_evaluators: set[str],
+    min_score: float = 0.99,
+) -> None:
+    """Validate an evaluation output file.
+
+    Args:
+        output_file: Path to the evaluation output JSON file.
+        expected_evaluations: Set of evaluation names to expect.
+        expected_evaluators: Set of evaluator IDs/names to expect.
+        min_score: Minimum acceptable score for all evaluators.
+    """
+    assert os.path.isfile(output_file), f"Output file '{output_file}' not found"
+    print(f"  Found output file: {output_file}")
+
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    assert "evaluationSetResults" in output_data, "Missing 'evaluationSetResults'"
+
+    evaluation_results = output_data["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+    print(f"  Found {len(evaluation_results)} evaluation result(s)")
+
+    failed_count = 0
+    seen_evaluations: set[str] = set()
+    seen_evaluators: set[str] = set()
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        seen_evaluations.add(eval_name)
+        print(f"\n  Validating: {eval_name}")
+
+        eval_run_results = eval_result.get("evaluationRunResults", [])
+        assert len(eval_run_results) > 0, f"No run results for '{eval_name}'"
+
+        for eval_run in eval_run_results:
+            evaluator_id = eval_run.get("evaluatorId", "Unknown")
+            evaluator_name = eval_run.get("evaluatorName", evaluator_id)
+            result = eval_run.get("result", {})
+            score = result.get("score")
+
+            seen_evaluators.add(evaluator_id)
+
+            is_passing = False
+            if score is True:
+                is_passing = True
+            elif isinstance(score, (int, float)) and score >= min_score:
+                is_passing = True
+
+            if is_passing:
+                display = f"{score:.2f}" if isinstance(score, float) else str(score)
+                print(f"    {evaluator_name}: score={display} (pass)")
+            else:
+                print(
+                    f"    {evaluator_name}: score={score} "
+                    f"(FAILED - expected >= {min_score})"
+                )
+                failed_count += 1
+
+    # Verify all expected evaluations were seen
+    missing_evals = expected_evaluations - seen_evaluations
+    if missing_evals:
+        print(f"\n  Missing evaluations: {missing_evals}")
+        failed_count += len(missing_evals)
+
+    # Verify all expected evaluators were seen
+    missing_evaluators = expected_evaluators - seen_evaluators
+    if missing_evaluators:
+        print(f"\n  Missing evaluators: {missing_evaluators}")
+        failed_count += len(missing_evaluators)
+
+    print(f"\n{'=' * 60}")
+    print(f"  Failed: {failed_count}")
+    print(f"{'=' * 60}")
+
+    assert failed_count == 0, f"{failed_count} assertion(s) failed for {output_file}"
+    print(f"\n  All assertions passed for {output_file}!")
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # 1. Validate deterministic evaluators (ExactMatch, JsonSimilarity, Contains)
+    #    All scores should be >= 0.99 since these are deterministic calculations
+    print("\n--- Deterministic Evaluators ---")
+    validate_output_file(
+        "eval-level-expected-output.json",
+        expected_evaluations=DETERMINISTIC_EVALUATIONS,
+        expected_evaluators=DETERMINISTIC_EVALUATORS,
+        min_score=0.99,
+    )
+
+    # 2. Validate LLM judge evaluators
+    #    ExactMatch should score >= 0.99, LLM judge scores can vary
+    #    but should be > 0 (semantically correct answers)
+    print("\n--- LLM Judge Evaluators ---")
+    validate_output_file(
+        "eval-level-expected-output-llm-judge.json",
+        expected_evaluations=LLM_JUDGE_EVALUATIONS,
+        expected_evaluators=LLM_JUDGE_EVALUATORS,
+        min_score=0.5,  # LLM judge scores can vary, but should be well above 0
+    )
+
+    print("\n  All eval-level expectedOutput assertions passed!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/eval-level-expected-output/uipath.json b/packages/uipath/testcases/eval-level-expected-output/uipath.json
new file mode 100644
index 000000000..2b8e5b396
--- /dev/null
+++ b/packages/uipath/testcases/eval-level-expected-output/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/eval-spans-testcase/pyproject.toml b/packages/uipath/testcases/eval-spans-testcase/pyproject.toml
new file mode 100644
index 000000000..41b4430c7
--- /dev/null
+++ b/packages/uipath/testcases/eval-spans-testcase/pyproject.toml
@@ -0,0 +1,11 @@
+[project]
+name = "eval-spans-testcase"
+version = "0.1.0"
+description = "E2E test for verifying eval spans (Evaluation Set Run, Evaluation, Evaluator)"
+requires-python = ">=3.11"
+dependencies = [
+    "uipath",
+]
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/eval-spans-testcase/run.sh b/packages/uipath/testcases/eval-spans-testcase/run.sh
new file mode 100755
index 000000000..80be32da9
--- /dev/null
+++ b/packages/uipath/testcases/eval-spans-testcase/run.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+echo "=== E2E Test: Eval Spans Verification ==="
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running evaluations with trace capture..."
+# Run eval with trace file to capture spans
+uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/default.json \
+    --no-report \
+    --trace-file __uipath/traces.jsonl
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/eval-spans-testcase/src/assert.py b/packages/uipath/testcases/eval-spans-testcase/src/assert.py
new file mode 100644
index 000000000..0749a557a
--- /dev/null
+++ b/packages/uipath/testcases/eval-spans-testcase/src/assert.py
@@ -0,0 +1,322 @@
+"""E2E assertions for eval spans testcase.
+
+This script validates that the new eval spans are created correctly:
+1. "Evaluation Set Run" span with span_type: "eval_set_run"
+2. "Evaluation" spans with span_type: "evaluation"
+3. "Evaluator: {name}" spans with span_type: "evaluator"
+4. "Evaluation output" spans with span.type: "evalOutput"
+"""
+
+import json
+import os
+import sys
+from typing import Any
+
+
+def load_traces(traces_file: str) -> list[dict[str, Any]]:
+    """Load traces from a JSONL file."""
+    traces = []
+    with open(traces_file, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                traces.append(json.loads(line))
+    return traces
+
+
+def get_attributes(span: dict[str, Any]) -> dict[str, Any]:
+    """Get attributes from a span."""
+    return span.get("attributes", {})
+
+
+def find_spans_by_type(
+    traces: list[dict[str, Any]], span_type: str
+) -> list[dict[str, Any]]:
+    """Find all spans with the given span_type attribute."""
+    return [
+        trace for trace in traces if get_attributes(trace).get("span_type") == span_type
+    ]
+
+
+def find_spans_by_span_dot_type(
+    traces: list[dict[str, Any]], span_type: str
+) -> list[dict[str, Any]]:
+    """Find all spans with the given span.type attribute."""
+    return [
+        trace for trace in traces if get_attributes(trace).get("span.type") == span_type
+    ]
+
+
+def find_spans_by_name(traces: list[dict[str, Any]], name: str) -> list[dict[str, Any]]:
+    """Find all spans with the given name."""
+    return [trace for trace in traces if trace.get("name") == name]
+
+
+def find_spans_by_name_prefix(
+    traces: list[dict[str, Any]], prefix: str
+) -> list[dict[str, Any]]:
+    """Find all spans whose name starts with the given prefix."""
+    return [trace for trace in traces if trace.get("name", "").startswith(prefix)]
+
+
+def assert_eval_set_run_span(traces: list[dict[str, Any]]) -> None:
+    """Assert that the Evaluation Set Run span exists with correct attributes."""
+    print("\n--- Checking 'Evaluation Set Run' span ---")
+
+    # Find by span_type
+    eval_set_run_spans = find_spans_by_type(traces, "eval_set_run")
+
+    assert len(eval_set_run_spans) >= 1, (
+        "Expected at least 1 'eval_set_run' span, found 0. "
+        "Spans with span_type attribute: "
+        f"{[get_attributes(t).get('span_type') for t in traces if get_attributes(t).get('span_type')]}"
+    )
+
+    print(f"  Found {len(eval_set_run_spans)} eval_set_run span(s)")
+
+    for span in eval_set_run_spans:
+        name = span.get("name")
+        attrs = get_attributes(span)
+
+        # Check span name
+        assert name == "Evaluation Set Run", (
+            f"Expected span name 'Evaluation Set Run', got '{name}'"
+        )
+        print(f"  Name: {name}")
+
+        # Check span_type attribute
+        assert attrs.get("span_type") == "eval_set_run", (
+            f"Expected span_type 'eval_set_run', got '{attrs.get('span_type')}'"
+        )
+        print(f"  span_type: {attrs.get('span_type')}")
+
+        # Check eval_set_run_id is present (may be execution_id fallback)
+        if "eval_set_run_id" in attrs:
+            print(f"  eval_set_run_id: {attrs.get('eval_set_run_id')}")
+
+    print("Evaluation Set Run span assertion passed")
+
+
+def assert_evaluation_spans(traces: list[dict[str, Any]]) -> None:
+    """Assert that Evaluation spans exist with correct attributes."""
+    print("\n--- Checking 'Evaluation' spans ---")
+
+    # Find by span_type
+    evaluation_spans = find_spans_by_type(traces, "evaluation")
+
+    assert len(evaluation_spans) >= 1, "Expected at least 1 'evaluation' span, found 0"
+
+    print(f"  Found {len(evaluation_spans)} evaluation span(s)")
+
+    for i, span in enumerate(evaluation_spans):
+        name = span.get("name")
+        attrs = get_attributes(span)
+
+        print(f"\n  Evaluation span {i + 1}:")
+
+        # Check span name
+        assert name == "Evaluation", f"Expected span name 'Evaluation', got '{name}'"
+        print(f"    Name: {name}")
+
+        # Check span_type attribute
+        assert attrs.get("span_type") == "evaluation", (
+            f"Expected span_type 'evaluation', got '{attrs.get('span_type')}'"
+        )
+        print(f"    span_type: {attrs.get('span_type')}")
+
+        # Check required attributes
+        assert "execution.id" in attrs, (
+            "Expected 'execution.id' attribute in Evaluation span"
+        )
+        print(f"    execution.id: {attrs.get('execution.id')}")
+
+        assert "eval_item_id" in attrs, (
+            "Expected 'eval_item_id' attribute in Evaluation span"
+        )
+        print(f"    eval_item_id: {attrs.get('eval_item_id')}")
+
+        assert "eval_item_name" in attrs, (
+            "Expected 'eval_item_name' attribute in Evaluation span"
+        )
+        print(f"    eval_item_name: {attrs.get('eval_item_name')}")
+
+    print("\nEvaluation spans assertion passed")
+
+
+def assert_evaluator_spans(traces: list[dict[str, Any]]) -> None:
+    """Assert that Evaluator spans exist with correct attributes."""
+    print("\n--- Checking 'Evaluator' spans ---")
+
+    # Find by span_type
+    evaluator_spans = find_spans_by_type(traces, "evaluator")
+
+    assert len(evaluator_spans) >= 1, "Expected at least 1 'evaluator' span, found 0"
+
+    print(f"  Found {len(evaluator_spans)} evaluator span(s)")
+
+    for i, span in enumerate(evaluator_spans):
+        name = span.get("name")
+        attrs = get_attributes(span)
+
+        print(f"\n  Evaluator span {i + 1}:")
+
+        # Check span name starts with "Evaluator: "
+        assert name and name.startswith("Evaluator: "), (
+            f"Expected span name to start with 'Evaluator: ', got '{name}'"
+        )
+        print(f"    Name: {name}")
+
+        # Check span_type attribute
+        assert attrs.get("span_type") == "evaluator", (
+            f"Expected span_type 'evaluator', got '{attrs.get('span_type')}'"
+        )
+        print(f"    span_type: {attrs.get('span_type')}")
+
+        # Check required attributes
+        assert "evaluator_id" in attrs, (
+            "Expected 'evaluator_id' attribute in Evaluator span"
+        )
+        print(f"    evaluator_id: {attrs.get('evaluator_id')}")
+
+        assert "evaluator_name" in attrs, (
+            "Expected 'evaluator_name' attribute in Evaluator span"
+        )
+        print(f"    evaluator_name: {attrs.get('evaluator_name')}")
+
+        assert "eval_item_id" in attrs, (
+            "Expected 'eval_item_id' attribute in Evaluator span"
+        )
+        print(f"    eval_item_id: {attrs.get('eval_item_id')}")
+
+    print("\nEvaluator spans assertion passed")
+
+
+def assert_evaluation_output_spans(traces: list[dict[str, Any]]) -> None:
+    """Assert that Evaluation output spans exist with correct attributes."""
+    print("\n--- Checking 'Evaluation output' spans ---")
+
+    # Find by span.type (note: different attribute name than span_type)
+    eval_output_spans = find_spans_by_span_dot_type(traces, "evalOutput")
+
+    assert len(eval_output_spans) >= 1, (
+        "Expected at least 1 'evalOutput' span, found 0. "
+        "Spans with span.type attribute: "
+        f"{[get_attributes(t).get('span.type') for t in traces if get_attributes(t).get('span.type')]}"
+    )
+
+    print(f"  Found {len(eval_output_spans)} evalOutput span(s)")
+
+    for i, span in enumerate(eval_output_spans):
+        name = span.get("name")
+        attrs = get_attributes(span)
+
+        print(f"\n  Evaluation output span {i + 1}:")
+
+        # Check span name
+        assert name == "Evaluation output", (
+            f"Expected span name 'Evaluation output', got '{name}'"
+        )
+        print(f"    Name: {name}")
+
+        # Check span.type attribute
+        assert attrs.get("span.type") == "evalOutput", (
+            f"Expected span.type 'evalOutput', got '{attrs.get('span.type')}'"
+        )
+        print(f"    span.type: {attrs.get('span.type')}")
+
+        # Check openinference.span.kind attribute
+        assert attrs.get("openinference.span.kind") == "CHAIN", (
+            f"Expected openinference.span.kind 'CHAIN', got '{attrs.get('openinference.span.kind')}'"
+        )
+        print(f"    openinference.span.kind: {attrs.get('openinference.span.kind')}")
+
+        # Check required attributes
+        assert "value" in attrs, "Expected 'value' attribute in Evaluation output span"
+        print(f"    value: {attrs.get('value')}")
+
+        assert "evaluatorId" in attrs, (
+            "Expected 'evaluatorId' attribute in Evaluation output span"
+        )
+        print(f"    evaluatorId: {attrs.get('evaluatorId')}")
+
+        # justification is optional but log it if present
+        if "justification" in attrs:
+            justification = attrs.get("justification")
+            # Truncate long justifications for display
+            if isinstance(justification, str) and len(justification) > 100:
+                justification = justification[:100] + "..."
+            print(f"    justification: {justification}")
+
+    print("\nEvaluation output spans assertion passed")
+
+
+def assert_span_hierarchy(traces: list[dict[str, Any]]) -> None:
+    """Assert the span hierarchy is correct."""
+    print("\n--- Checking span hierarchy ---")
+
+    # Build span lookup by span_id
+    span_by_id: dict[str, dict[str, Any]] = {}
+    for trace in traces:
+        context = trace.get("context", {})
+        span_id = context.get("span_id")
+        if span_id:
+            span_by_id[span_id] = trace
+
+    # Get spans by type
+    eval_set_run_spans = find_spans_by_type(traces, "eval_set_run")
+    evaluation_spans = find_spans_by_type(traces, "evaluation")
+    evaluator_spans = find_spans_by_type(traces, "evaluator")
+
+    # Get eval_set_run span_id
+    if eval_set_run_spans:
+        eval_set_run_span_id = eval_set_run_spans[0].get("context", {}).get("span_id")
+        print(f"  EvalSetRun span_id: {eval_set_run_span_id}")
+
+        # Check Evaluation spans are children of EvalSetRun (through parent chain)
+        # Note: In practice, there may be intermediate spans, so we just verify
+        # the relationship exists through the trace
+        print(f"  Found {len(evaluation_spans)} Evaluation spans")
+        print(f"  Found {len(evaluator_spans)} Evaluator spans")
+
+    print("\nSpan hierarchy check passed")
+
+
+def main() -> None:
+    """Main assertion logic."""
+    traces_file = "__uipath/traces.jsonl"
+
+    # Check if traces file exists
+    if not os.path.isfile(traces_file):
+        print(f"Traces file '{traces_file}' not found")
+        sys.exit(1)
+
+    print(f"Loading traces from {traces_file}...")
+    traces = load_traces(traces_file)
+    print(f"Loaded {len(traces)} trace spans")
+
+    # Print all span names and types for debugging
+    print("\n--- All spans ---")
+    for i, trace in enumerate(traces):
+        name = trace.get("name", "Unknown")
+        attrs = get_attributes(trace)
+        span_type = attrs.get("span_type", "N/A")
+        print(f"  {i + 1}. {name} (span_type: {span_type})")
+
+    # Run assertions
+    try:
+        assert_eval_set_run_span(traces)
+        assert_evaluation_spans(traces)
+        assert_evaluator_spans(traces)
+        assert_evaluation_output_spans(traces)
+        assert_span_hierarchy(traces)
+
+        print("\n" + "=" * 60)
+        print("All eval span assertions passed!")
+        print("=" * 60)
+
+    except AssertionError as e:
+        print(f"\nAssertion failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/eval-spans-testcase/uipath.json b/packages/uipath/testcases/eval-spans-testcase/uipath.json
new file mode 100644
index 000000000..2b8e5b396
--- /dev/null
+++ b/packages/uipath/testcases/eval-spans-testcase/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/eval-telemetry-testcase/pyproject.toml b/packages/uipath/testcases/eval-telemetry-testcase/pyproject.toml
new file mode 100644
index 000000000..e9c2e52d9
--- /dev/null
+++ b/packages/uipath/testcases/eval-telemetry-testcase/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "eval-telemetry-testcase"
+version = "0.1.0"
+description = "E2E test for verifying eval telemetry events in Application Insights"
+requires-python = ">=3.11"
+dependencies = [
+    "uipath",
+    "httpx",
+]
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/eval-telemetry-testcase/run.sh b/packages/uipath/testcases/eval-telemetry-testcase/run.sh
new file mode 100755
index 000000000..1b18072f4
--- /dev/null
+++ b/packages/uipath/testcases/eval-telemetry-testcase/run.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+set -e
+
+echo "=== E2E Test: Eval Telemetry Integration ==="
+
+# Validate required environment variables
+if [ -z "$TELEMETRY_CONNECTION_STRING" ]; then
+    echo "Warning: TELEMETRY_CONNECTION_STRING not set, telemetry won't be sent"
+fi
+if [ -z "$APP_INSIGHTS_APP_ID" ]; then
+    echo "Warning: APP_INSIGHTS_APP_ID not set, skipping telemetry verification"
+fi
+if [ -z "$APP_INSIGHTS_API_KEY" ]; then
+    echo "Warning: APP_INSIGHTS_API_KEY not set, skipping telemetry verification"
+fi
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+# Generate a unique run ID to identify this test run's telemetry events
+export EVAL_TEST_RUN_ID="e2e-test-$(date +%s)-$$"
+echo "Test Run ID: $EVAL_TEST_RUN_ID"
+
+echo "Running evaluations with telemetry enabled..."
+# Run eval with telemetry explicitly enabled and App Insights connection string
+UIPATH_TELEMETRY_ENABLED=true uv run uipath eval main ../../samples/calculator/evaluations/eval-sets/default.json \
+    --no-report \
+    --output-file __uipath/output.json \
+    --eval-set-run-id "$EVAL_TEST_RUN_ID"
+
+# Wait for telemetry to be ingested into App Insights
+if [ -n "$APP_INSIGHTS_APP_ID" ] && [ -n "$APP_INSIGHTS_API_KEY" ]; then
+    echo "Waiting for telemetry to be ingested (30 seconds)..."
+    sleep 30
+fi
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/eval-telemetry-testcase/src/assert.py b/packages/uipath/testcases/eval-telemetry-testcase/src/assert.py
new file mode 100644
index 000000000..083019426
--- /dev/null
+++ b/packages/uipath/testcases/eval-telemetry-testcase/src/assert.py
@@ -0,0 +1,209 @@
+"""E2E assertions for eval telemetry testcase.
+
+This script validates that telemetry events are sent to Application Insights by:
+1. Verifying eval completed successfully
+2. Querying App Insights API to check for expected telemetry events
+3. Validating event properties match expected values
+"""
+
+import json
+import os
+import sys
+import time
+from typing import Any
+
+import httpx
+
+# Expected telemetry event names
+EXPECTED_EVENTS = [
+    "EvalSetRun.Start",
+    "EvalSetRun.End",
+    "EvalRun.Start",
+    "EvalRun.End",
+]
+
+
+def load_output(output_file: str) -> dict[str, Any]:
+    """Load output from a JSON file."""
+    with open(output_file, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def query_app_insights(
+    app_id: str, api_key: str, query: str, max_retries: int = 3
+) -> dict[str, Any]:
+    """Query Application Insights using the REST API.
+
+    Args:
+        app_id: Application Insights App ID
+        api_key: Application Insights API Key
+        query: Kusto query to execute
+        max_retries: Number of retries on failure
+
+    Returns:
+        Query results as dictionary
+    """
+    url = f"https://api.applicationinsights.io/v1/apps/{app_id}/query"
+    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
+    payload = {"query": query}
+
+    for attempt in range(max_retries):
+        try:
+            response = httpx.post(url, headers=headers, json=payload, timeout=30)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            if attempt < max_retries - 1:
+                print(f"  Retry {attempt + 1}/{max_retries} after error: {e}")
+                time.sleep(5)
+            else:
+                raise
+
+
+def verify_telemetry_events(app_id: str, api_key: str, eval_set_run_id: str) -> bool:
+    """Verify telemetry events were sent to Application Insights.
+
+    Args:
+        app_id: Application Insights App ID
+        api_key: Application Insights API Key
+        eval_set_run_id: The eval set run ID to search for
+
+    Returns:
+        True if all expected events were found
+    """
+    print("\n--- Querying App Insights for events ---")
+    print(f"  EvalSetRunId: {eval_set_run_id}")
+
+    # Query for events with the specific EvalSetRunId
+    query = f"""
+    customEvents
+    | where timestamp > ago(10m)
+    | where customDimensions.EvalSetRunId == "{eval_set_run_id}"
+       or customDimensions["EvalSetRunId"] == "{eval_set_run_id}"
+    | project name, timestamp, customDimensions
+    | order by timestamp asc
+    """
+
+    try:
+        result = query_app_insights(app_id, api_key, query)
+    except Exception as e:
+        print(f"  Error querying App Insights: {e}")
+        return False
+
+    # Parse results
+    tables = result.get("tables", [])
+    if not tables:
+        print("  No tables returned from query")
+        return False
+
+    rows = tables[0].get("rows", [])
+    columns = [col["name"] for col in tables[0].get("columns", [])]
+
+    print(f"  Found {len(rows)} events")
+
+    # Extract event names
+    found_events: list[str] = []
+    name_idx = columns.index("name") if "name" in columns else 0
+
+    for row in rows:
+        event_name = row[name_idx]
+        found_events.append(event_name)
+        print(f"    - {event_name}")
+
+    # Check for expected events
+    print("\n--- Verifying expected events ---")
+    all_found = True
+    for expected in EXPECTED_EVENTS:
+        if expected in found_events:
+            print(f"  [OK] {expected}")
+        else:
+            print(f"  [MISSING] {expected}")
+            all_found = False
+
+    return all_found
+
+
+def verify_output(output_file: str) -> bool:
+    """Verify the eval output file."""
+    print("\n--- Verifying eval output ---")
+
+    if not os.path.isfile(output_file):
+        print(f"  Output file '{output_file}' not found")
+        return False
+
+    output_data = load_output(output_file)
+
+    # The eval output can have two formats:
+    # 1. Direct results: {"evaluationSetName": "...", "evaluationSetResults": [...]}
+    # 2. Wrapped results: {"status": "successful", "output": {...}}
+    if "status" in output_data:
+        status = output_data.get("status")
+        if status != "successful":
+            print(f"  Eval failed with status: {status}")
+            return False
+        print(f"  Status: {status}")
+        output = output_data.get("output", {})
+        evaluation_results = output.get("evaluationSetResults", [])
+    else:
+        # Direct format - check for evaluationSetResults
+        evaluation_results = output_data.get("evaluationSetResults", [])
+        if not evaluation_results:
+            print("  No evaluationSetResults found in output")
+            return False
+        print("  Status: completed (direct output format)")
+
+    print(f"  Evaluation results: {len(evaluation_results)}")
+
+    # Verify we have results with scores
+    if len(evaluation_results) == 0:
+        print("  No evaluation results found")
+        return False
+
+    return True
+
+
+def main() -> None:
+    """Main assertion logic."""
+    output_file = "__uipath/output.json"
+
+    # Get environment variables
+    app_id = os.environ.get("APP_INSIGHTS_APP_ID")
+    api_key = os.environ.get("APP_INSIGHTS_API_KEY")
+    eval_set_run_id = os.environ.get("EVAL_TEST_RUN_ID")
+
+    # Verify eval output first
+    if not verify_output(output_file):
+        print("\nEval output verification failed")
+        sys.exit(1)
+
+    # Check if App Insights verification is possible
+    if not app_id or not api_key:
+        print("\n--- Skipping App Insights verification ---")
+        print("  APP_INSIGHTS_APP_ID or APP_INSIGHTS_API_KEY not set")
+        print("  Telemetry verification skipped (eval completed successfully)")
+        print("\nAll assertions passed! (telemetry verification skipped)")
+        return
+
+    if not eval_set_run_id:
+        print("\n--- Skipping App Insights verification ---")
+        print("  EVAL_TEST_RUN_ID not set")
+        print("\nAll assertions passed! (telemetry verification skipped)")
+        return
+
+    # Verify telemetry events in App Insights
+    if not verify_telemetry_events(app_id, api_key, eval_set_run_id):
+        print("\n" + "=" * 60)
+        print("Telemetry verification FAILED")
+        print("Expected events not found in App Insights")
+        print("=" * 60)
+        sys.exit(1)
+
+    print("\n" + "=" * 60)
+    print("All assertions passed!")
+    print("  - Eval completed successfully")
+    print("  - Telemetry events verified in App Insights")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/eval-telemetry-testcase/uipath.json b/packages/uipath/testcases/eval-telemetry-testcase/uipath.json
new file mode 100644
index 000000000..2b8e5b396
--- /dev/null
+++ b/packages/uipath/testcases/eval-telemetry-testcase/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/calculator/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/langchain-cross/agent.mermaid b/packages/uipath/testcases/langchain-cross/agent.mermaid
new file mode 100644
index 000000000..6fa387dce
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/agent.mermaid
@@ -0,0 +1,14 @@
+---
+config:
+  flowchart:
+    curve: linear
+---
+graph TD;
+	__start__([<p>__start__</p>]):::first
+	generate_report(generate_report)
+	__end__([<p>__end__</p>]):::last
+	__start__ --> generate_report;
+	generate_report --> __end__;
+	classDef default fill:#f2f0ff,line-height:1.2
+	classDef first fill-opacity:0
+	classDef last fill:#bfb6fc
diff --git a/packages/uipath/testcases/langchain-cross/expected_traces.json b/packages/uipath/testcases/langchain-cross/expected_traces.json
new file mode 100644
index 000000000..82701a144
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/expected_traces.json
@@ -0,0 +1,101 @@
+{
+    "description": "Langchain cross and traced - checks key spans exist with parent relationships",
+    "required_spans": [
+        {
+            "name": "LangGraph",
+            "parent": null,
+            "attributes": {
+                "openinference.span.kind": "CHAIN"
+            }
+        },
+        {
+            "name": "generate_report",
+            "parent": "LangGraph",
+            "attributes": {
+                "openinference.span.kind": "CHAIN"
+            }
+        },
+        {
+            "name": "my_custom_traceable_function",
+            "parent": "generate_report",
+            "span_type": "function_call_sync",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json"
+            }
+        },
+        {
+            "name": "my_custom_traced_function",
+            "parent": "generate_report",
+            "span_type": "function_call_sync",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json"
+            }
+        },
+        {
+            "name": "my_custom_nested_traced_function",
+            "parent": "my_custom_traced_function",
+            "span_type": "function_call_sync",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json"
+            }
+        },
+        {
+            "name": "factorial",
+            "parent": "generate_report",
+            "span_type": "function_call_async",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json",
+                "input.value": "{\"i\": 5}",
+                "output.value": "120"
+            }
+        },
+        {
+            "name": "factorial",
+            "parent": "factorial",
+            "span_type": "function_call_async",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json",
+                "input.value": "{\"i\": 4}",
+                "output.value": "24"
+            }
+        },
+        {
+            "name": "factorial",
+            "parent": "factorial",
+            "span_type": "function_call_async",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json",
+                "input.value": "{\"i\": 3}",
+                "output.value": "6"
+            }
+        },
+        {
+            "name": "factorial",
+            "parent": "factorial",
+            "span_type": "function_call_async",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json",
+                "input.value": "{\"i\": 2}",
+                "output.value": "2"
+            }
+        },
+        {
+            "name": "factorial",
+            "parent": "factorial",
+            "span_type": "function_call_async",
+            "attributes": {
+                "input.mime_type": "application/json",
+                "output.mime_type": "application/json",
+                "input.value": "{\"i\": 1}",
+                "output.value": "1"
+            }
+        }
+    ]
+}
diff --git a/packages/uipath/testcases/langchain-cross/langgraph.json b/packages/uipath/testcases/langchain-cross/langgraph.json
new file mode 100644
index 000000000..5632a46b7
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/langgraph.json
@@ -0,0 +1,7 @@
+{
+    "dependencies": ["."],
+    "graphs": {
+      "agent": "./src/main.py:graph"
+    },
+    "env": ".env"
+  }
diff --git a/packages/uipath/testcases/langchain-cross/pyproject.toml b/packages/uipath/testcases/langchain-cross/pyproject.toml
new file mode 100644
index 000000000..0420b6c48
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/pyproject.toml
@@ -0,0 +1,20 @@
+[project]
+name = "agent"
+version = "0.0.1"
+description = "agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath-langchain>=0.0.149",
+    "uipath"
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
+
+# Force the local uipath (the version under test) regardless of the upper bound
+# the published uipath-langchain declares, so a backward-compatible minor bump
+# does not break resolution purely on that cap. Mirrors the uv override used in
+# the cross-repo test workflows.
+[tool.uv]
+override-dependencies = ["uipath"]
\ No newline at end of file
diff --git a/packages/uipath/testcases/langchain-cross/run.sh b/packages/uipath/testcases/langchain-cross/run.sh
new file mode 100644
index 000000000..b363f8fd0
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/run.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Run init..."
+uv run uipath init
+
+echo "Packing agent..."
+uv run uipath pack
+
+echo "Run agent with input from cli"
+uv run uipath run agent '{"topic": "Weather and Technology"}'
+
+echo "Running agent again with empty UIPATH_JOB_KEY..."
+export UIPATH_JOB_KEY=""
+uv run uipath run agent --trace-file .uipath/traces.jsonl '{"topic": "Weather and Technology"}' >> local_run_output.log
\ No newline at end of file
diff --git a/packages/uipath/testcases/langchain-cross/src/assert.py b/packages/uipath/testcases/langchain-cross/src/assert.py
new file mode 100644
index 000000000..491a64c69
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/src/assert.py
@@ -0,0 +1,49 @@
+import json
+import os
+from trace_assert import assert_traces
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields and structure
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+# Check the specific structure of the output
+output_section = output_data.get("output")
+assert isinstance(output_section, dict), "Output field should be a dictionary"
+assert "report" in output_section, "Missing 'report' field in output section"
+
+# Check the specific report content
+expected_report = "Just a sanity report"
+actual_report = output_section.get("report")
+assert actual_report == expected_report, (
+    f"Expected report: '{expected_report}', but got: '{actual_report}'"
+)
+
+# Simple trace assertions - just check that expected spans exist
+assert_traces(".uipath/traces.jsonl", "expected_traces.json")
+
+print("Required fields validation passed")
+print(f"Output structure validation passed - report: '{actual_report}'")
diff --git a/packages/uipath/testcases/langchain-cross/src/assert.py.orig b/packages/uipath/testcases/langchain-cross/src/assert.py.orig
new file mode 100644
index 000000000..db1830133
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/src/assert.py.orig
@@ -0,0 +1,101 @@
+<<<<<<< HEAD
+import json
+import os
+from trace_assert import assert_traces
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields and structure
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+# Check the specific structure of the output
+output_section = output_data.get("output")
+assert isinstance(output_section, dict), "Output field should be a dictionary"
+assert "report" in output_section, "Missing 'report' field in output section"
+
+# Check the specific report content
+expected_report = "Just a sanity report"
+actual_report = output_section.get("report")
+assert actual_report == expected_report, (
+    f"Expected report: '{expected_report}', but got: '{actual_report}'"
+)
+
+# Simple trace assertions - just check that expected spans exist
+assert_traces(".uipath/traces.jsonl", "expected_traces.json")
+
+print("Required fields validation passed")
+print(f"Output structure validation passed - report: '{actual_report}'")
+=======
+import json
+import os
+from trace_assert import assert_traces
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields and structure
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+# Check the specific structure of the output
+output_section = output_data.get("output")
+assert isinstance(output_section, dict), "Output field should be a dictionary"
+assert "report" in output_section, "Missing 'report' field in output section"
+
+# Check the specific report content
+expected_report = "Just a sanity report"
+actual_report = output_section.get("report")
+assert actual_report == expected_report, (
+    f"Expected report: '{expected_report}', but got: '{actual_report}'"
+)
+
+# Simple trace assertions - just check that expected spans exist
+assert_traces(".uipath/traces.jsonl", "expected_traces.json")
+
+print("Required fields validation passed")
+print(f"Output structure validation passed - report: '{actual_report}'")
+>>>>>>> 13298dfa (feat(tests): add traces testcase)
diff --git a/packages/uipath/testcases/langchain-cross/src/main.py b/packages/uipath/testcases/langchain-cross/src/main.py
new file mode 100644
index 000000000..717888b3c
--- /dev/null
+++ b/packages/uipath/testcases/langchain-cross/src/main.py
@@ -0,0 +1,72 @@
+from langgraph.graph import START, StateGraph, END
+from langsmith import traceable
+from uipath.tracing import traced
+from pydantic import BaseModel
+import logging
+from opentelemetry import trace, baggage
+
+tracer = trace.get_tracer("my.tracer")
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@traceable
+def my_custom_traceable_function(input: str) -> str:
+    logger.warning(f"Testing traceable: {input}")
+    # Custom function to process the input
+    return { "a": "HARD-CODED-OUTPUT-1" }
+
+@traced()
+def my_custom_nested_traced_function(input: str) -> str:
+    logger.warning(f"Testing nested traced from uipath: {input}")
+    # Custom function to process the input
+    return { "a-nested": "HARD-CODED-OUTPUT-2" }
+
+
+@traced()
+def my_custom_traced_function(input: str) -> str:
+    logger.warning(f"Testing traced from uipath: {input}")
+
+    my_custom_nested_traced_function(input)
+    # Custom function to process the input
+    return { "a": "HARD-CODED-OUTPUT-2" }
+
+@traced(name="factorial")
+async def factorial(i: int=0) -> int:
+    logger.info(f"Calculating factorial of {i}")
+    if i <= 1:
+        return 1
+    return i * await factorial(i=i - 1)
+
+
+class GraphState(BaseModel):
+    topic: str
+
+class GraphOutput(BaseModel):
+    report: str
+
+async def generate_report(state: GraphState) -> GraphOutput:
+
+    # with tracer.start_as_current_span(name="manual_root") as root_span:
+    #     with tracer.start_as_current_span(name="manual_child_span") as child_span:
+    #         my_custom_traceable_function("test-1")
+    #         my_custom_traced_function("test-2")
+    #         await factorial(5)
+
+    my_custom_traceable_function("test-1")
+    my_custom_traced_function("test-2")
+    await factorial(5)
+
+    report = "Just a sanity report"
+    return GraphOutput(report=report)
+
+builder = StateGraph(GraphState, output=GraphOutput)
+
+builder.add_node("generate_report", generate_report)
+
+builder.add_edge(START, "generate_report")
+builder.add_edge("generate_report", END)
+
+graph = builder.compile()
diff --git a/packages/uipath/testcases/list-target-output-key-evals/pyproject.toml b/packages/uipath/testcases/list-target-output-key-evals/pyproject.toml
new file mode 100644
index 000000000..b3a04339d
--- /dev/null
+++ b/packages/uipath/testcases/list-target-output-key-evals/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "list-target-output-key-evals"
+version = "0.0.1"
+description = "Tests for evaluating multiple output keys at once using a list targetOutputKey"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/list-target-output-key-evals/run.sh b/packages/uipath/testcases/list-target-output-key-evals/run.sh
new file mode 100755
index 000000000..508bd9777
--- /dev/null
+++ b/packages/uipath/testcases/list-target-output-key-evals/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running list targetOutputKey evaluations..."
+uv run uipath eval main ../../samples/list_target_output_key_test/evaluations/eval-sets/default.json --no-report --output-file default.json
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/list-target-output-key-evals/src/assert.py b/packages/uipath/testcases/list-target-output-key-evals/src/assert.py
new file mode 100644
index 000000000..80f22c195
--- /dev/null
+++ b/packages/uipath/testcases/list-target-output-key-evals/src/assert.py
@@ -0,0 +1,90 @@
+"""Assertions for list-target-output-key-evals testcase.
+
+Validates that evaluating multiple output fields at once (targetOutputKey as a
+list) works correctly for both ExactMatch and JsonSimilarity evaluators.
+
+Expected outcomes
+-----------------
+- headphones-all-match  : ListKeysExactMatch=1.0, ListKeysJsonSimilarity=1.0
+- shoes-all-match       : ListKeysExactMatch=1.0, ListKeysJsonSimilarity=1.0
+- headphones-wrong-price: ListKeysExactMatch=0.0, ListKeysJsonSimilarity=1.0
+"""
+
+import json
+import os
+
+# Maps evaluationName → evaluator ID → expected score (1.0 = pass, 0.0 = fail)
+EXPECTED: dict[str, dict[str, float]] = {
+    "Headphones - all keys match": {
+        "ListKeysExactMatch": 1.0,
+        "ListKeysJsonSimilarity": 1.0,
+    },
+    "Running Shoes - all keys match": {
+        "ListKeysExactMatch": 1.0,
+        "ListKeysJsonSimilarity": 1.0,
+    },
+    "Headphones - wrong price (should fail)": {
+        "ListKeysExactMatch": 0.0,
+        "ListKeysJsonSimilarity": 1.0,
+    },
+}
+
+
+def main() -> None:
+    output_file = "default.json"
+    assert os.path.isfile(output_file), f"Output file '{output_file}' not found"
+    print(f"Found output file: {output_file}")
+
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    assert "evaluationSetResults" in output_data, "Missing 'evaluationSetResults'"
+    evaluation_results = output_data["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+    print(f"Found {len(evaluation_results)} evaluation result(s)")
+
+    failures: list[str] = []
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "")
+        expected_scores = EXPECTED.get(eval_name)
+
+        if expected_scores is None:
+            print(f"  [skip] '{eval_name}' not in EXPECTED map")
+            continue
+
+        print(f"\n  Validating: {eval_name}")
+
+        run_results = eval_result.get("evaluationRunResults", [])
+        assert len(run_results) > 0, f"No run results for '{eval_name}'"
+
+        for run in run_results:
+            evaluator_id = run.get("evaluatorId", run.get("evaluatorName", ""))
+            score = run.get("result", {}).get("score", None)
+
+            if evaluator_id not in expected_scores:
+                print(f"    [skip] unexpected evaluator '{evaluator_id}'")
+                continue
+
+            expected = expected_scores[evaluator_id]
+            ok = score == expected
+            status = "pass" if ok else "FAIL"
+            print(f"    {evaluator_id}: score={score} expected={expected} ({status})")
+            if not ok:
+                failures.append(
+                    f"{eval_name} / {evaluator_id}: got {score}, expected {expected}"
+                )
+
+    print(f"\n{'=' * 60}")
+    if failures:
+        for f in failures:
+            print(f"  FAIL: {f}")
+        print(f"{'=' * 60}")
+        assert False, f"{len(failures)} assertion(s) failed"
+
+    print("  All assertions passed!")
+    print(f"{'=' * 60}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/list-target-output-key-evals/uipath.json b/packages/uipath/testcases/list-target-output-key-evals/uipath.json
new file mode 100644
index 000000000..a50f100df
--- /dev/null
+++ b/packages/uipath/testcases/list-target-output-key-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/list_target_output_key_test/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/llamaindexcross/agent.mermaid b/packages/uipath/testcases/llamaindexcross/agent.mermaid
new file mode 100644
index 000000000..723243021
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/agent.mermaid
@@ -0,0 +1,17 @@
+flowchart TD
+    step__done["_done"]:::stepStyle
+    step_critique_joke["critique_joke"]:::stepStyle
+    step_generate_joke["generate_joke"]:::stepStyle
+    event_JokeEvent([<p>JokeEvent</p>]):::defaultEventStyle
+    event_CritiqueEvent([<p>CritiqueEvent</p>]):::stopEventStyle
+    event_TopicEvent([<p>TopicEvent</p>]):::defaultEventStyle
+    event_CritiqueEvent --> step__done
+    step_critique_joke --> event_CritiqueEvent
+    event_JokeEvent --> step_critique_joke
+    step_generate_joke --> event_JokeEvent
+    event_TopicEvent --> step_generate_joke
+    classDef stepStyle fill:#f2f0ff,line-height:1.2
+    classDef externalStyle fill:#f2f0ff,line-height:1.2
+    classDef defaultEventStyle fill-opacity:0
+    classDef stopEventStyle fill:#bfb6fc
+    classDef inputRequiredStyle fill:#f2f0ff,line-height:1.2
\ No newline at end of file
diff --git a/packages/uipath/testcases/llamaindexcross/llama_index.json b/packages/uipath/testcases/llamaindexcross/llama_index.json
new file mode 100644
index 000000000..f397f788d
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/llama_index.json
@@ -0,0 +1,7 @@
+{
+  "dependencies": ["."],
+  "workflows": {
+    "agent": "./src/main.py:workflow"
+  },
+  "env": ".env"
+}
diff --git a/packages/uipath/testcases/llamaindexcross/pyproject.toml b/packages/uipath/testcases/llamaindexcross/pyproject.toml
new file mode 100644
index 000000000..3cb977f82
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/pyproject.toml
@@ -0,0 +1,13 @@
+[project]
+name = "agent"
+version = "0.0.1"
+description = "agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath-llamaindex>=0.0.27",
+    "uipath"
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
\ No newline at end of file
diff --git a/packages/uipath/testcases/llamaindexcross/run.sh b/packages/uipath/testcases/llamaindexcross/run.sh
new file mode 100644
index 000000000..281cb002f
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/run.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Run init..."
+uv run uipath init
+
+echo "Packing agent..."
+uv run uipath pack
+
+echo "Run agent with input from cli"
+uv run uipath run agent '{"topic": "Weather and Technology"}'
\ No newline at end of file
diff --git a/packages/uipath/testcases/llamaindexcross/src/assert.py b/packages/uipath/testcases/llamaindexcross/src/assert.py
new file mode 100644
index 000000000..bdded3f13
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/src/assert.py
@@ -0,0 +1,47 @@
+import json
+import os
+
+# Check NuGet package
+uipath_dir = ".uipath"
+assert os.path.exists(uipath_dir), "NuGet package directory (.uipath) not found"
+
+nupkg_files = [f for f in os.listdir(uipath_dir) if f.endswith(".nupkg")]
+assert nupkg_files, "NuGet package file (.nupkg) not found in .uipath directory"
+
+print(f"NuGet package found: {nupkg_files[0]}")
+
+# Check agent output file
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+print("Agent output file found")
+
+# Check status and required fields
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+# Check status
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+print("Agent execution status: successful")
+
+# Check required fields and structure
+assert "output" in output_data, "Missing 'output' field in agent response"
+
+# Check the specific structure of the output
+output_section = output_data.get("output")
+assert isinstance(output_section, dict), "Output field should be a dictionary"
+assert "joke" in output_section, "Missing 'joke' field in output section"
+assert "critique" in output_section, "Missing 'critique' field in output section"
+
+# Check that the fields are not empty
+joke = output_section.get("joke")
+critique = output_section.get("critique")
+assert joke and isinstance(joke, str), "Joke field should be a non-empty string"
+assert critique and isinstance(critique, str), (
+    "Critique field should be a non-empty string"
+)
+
+print("Required fields validation passed")
+print(f"Output structure validation passed - joke: '{joke}', critique: '{critique}'")
diff --git a/packages/uipath/testcases/llamaindexcross/src/main.py b/packages/uipath/testcases/llamaindexcross/src/main.py
new file mode 100644
index 000000000..d371ff750
--- /dev/null
+++ b/packages/uipath/testcases/llamaindexcross/src/main.py
@@ -0,0 +1,71 @@
+from llama_index.core.workflow import (
+    Event,
+    StartEvent,
+    StopEvent,
+    Workflow,
+    step,
+)
+from uipath.tracing import traced
+from llama_index.llms.openai import OpenAI
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@traced()
+def my_custom_nested_traced_function(input: str) -> str:
+    logger.warning(f"Testing nested traced from uipath: {input}")
+    # Custom function to process the input
+    return { "a-nested": "HARD-CODED-OUTPUT-2" }
+
+
+@traced()
+def my_custom_traced_function(input: str) -> str:
+    logger.warning(f"Testing traced from uipath: {input}")
+
+    my_custom_nested_traced_function(input)
+    # Custom function to process the input
+    return { "a": "HARD-CODED-OUTPUT-2" }
+
+@traced(name="factorial")
+async def factorial(i: int=0) -> int:
+    logger.info(f"Calculating factorial of {i}")
+    if i <= 1:
+        return 1
+    return i * await factorial(i=i - 1)
+
+
+class TopicEvent(StartEvent):
+    topic: str
+
+
+class JokeEvent(Event):
+    joke: str
+
+
+class CritiqueEvent(StopEvent):
+    joke: str
+    critique: str
+
+
+class JokeFlow(Workflow):
+    llm = OpenAI()
+
+    @step
+    async def generate_joke(self, ev: TopicEvent) -> JokeEvent:
+
+        my_custom_traced_function("test-1")
+        my_custom_traced_function("test-2")
+        await factorial(5)
+
+        response = "Random joke"
+        return JokeEvent(joke=str(response))
+
+    @step
+    async def critique_joke(self, ev: JokeEvent) -> CritiqueEvent:
+        joke = ev.joke
+        return CritiqueEvent(joke=joke, critique="Just a critique")
+
+
+workflow = JokeFlow(timeout=60, verbose=False)
diff --git a/packages/uipath/testcases/simulation-testcase/pyproject.toml b/packages/uipath/testcases/simulation-testcase/pyproject.toml
new file mode 100644
index 000000000..d37877dbf
--- /dev/null
+++ b/packages/uipath/testcases/simulation-testcase/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "simulation-testcase"
+version = "0.0.1"
+description = "simulation-testcase"
+authors = [{ name = "UiPath", email = "python-sdk@uipath.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/simulation-testcase/run.sh b/packages/uipath/testcases/simulation-testcase/run.sh
new file mode 100644
index 000000000..0095cc904
--- /dev/null
+++ b/packages/uipath/testcases/simulation-testcase/run.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+set -e
+
+TESTCASE_DIR="$(cd "$(dirname "$0")" && pwd)"
+SAMPLE_DIR="$(cd "$TESTCASE_DIR/../../samples/runtime-simulations-agent" && pwd)"
+
+echo "Syncing testcase dependencies (local editable uipath)..."
+uv sync --project "$TESTCASE_DIR"
+
+UIPATH_BIN="$TESTCASE_DIR/.venv/bin/uipath"
+
+# Run auth and agent from the sample dir so credentials are stored and read
+# from the same location.
+cd "$SAMPLE_DIR"
+
+echo "Authenticating with UiPath..."
+"$UIPATH_BIN" auth \
+    --client-id="$CLIENT_ID" \
+    --client-secret="$CLIENT_SECRET" \
+    --base-url="$BASE_URL"
+
+echo "Running agent with simulation..."
+"$UIPATH_BIN" run main \
+    -f input.json \
+    --simulation "$(cat simulation.json)" 2>&1 | tee "$TESTCASE_DIR/run.log"
+
+# Copy the runtime output file back to the testcase dir for assert.py
+mkdir -p "$TESTCASE_DIR/__uipath"
+cp "$SAMPLE_DIR/__uipath/output.json" "$TESTCASE_DIR/__uipath/output.json"
diff --git a/packages/uipath/testcases/simulation-testcase/src/assert.py b/packages/uipath/testcases/simulation-testcase/src/assert.py
new file mode 100644
index 000000000..fd7e89697
--- /dev/null
+++ b/packages/uipath/testcases/simulation-testcase/src/assert.py
@@ -0,0 +1,57 @@
+import json
+import os
+
+# ── 1. Verify agent output exists and succeeded ──────────────────────────────
+output_file = "__uipath/output.json"
+assert os.path.isfile(output_file), "Agent output file not found"
+
+with open(output_file, "r", encoding="utf-8") as f:
+    output_data = json.load(f)
+
+status = output_data.get("status")
+assert status == "successful", f"Agent execution failed with status: {status}"
+
+output = output_data.get("output", {})
+
+assert "syntax" in output, "Missing 'syntax' in output"
+assert "style" in output, "Missing 'style' in output"
+assert "improvements" in output, "Missing 'improvements' in output"
+assert "summary" in output, "Missing 'summary' in output"
+
+assert isinstance(output["syntax"]["valid"], bool), "'syntax.valid' must be a bool"
+assert isinstance(output["syntax"]["errors"], list), "'syntax.errors' must be a list"
+
+score = output["style"]["score"]
+assert isinstance(score, int), "'style.score' must be an int"
+assert 0 <= score <= 100, f"'style.score' out of range: {score}"
+assert isinstance(output["style"]["violations"], list), (
+    "'style.violations' must be a list"
+)
+
+assert isinstance(output["improvements"]["suggestions"], list), (
+    "'improvements.suggestions' must be a list"
+)
+assert isinstance(output["improvements"]["refactored_snippet"], str), (
+    "'improvements.refactored_snippet' must be a str"
+)
+
+# ── 2. Verify simulation produced non-default values ─────────────────────────
+# Real tool impls always return: score=100, violations=[], suggestions=[].
+# The LLM simulation should detect issues in the input code and return richer output.
+simulated_something = (
+    score < 100
+    or len(output["style"]["violations"]) > 0
+    or len(output["improvements"]["suggestions"]) > 0
+)
+assert simulated_something, (
+    "Output matches hardcoded real-tool defaults — simulation may not have run. "
+    f"style.score={score}, violations={output['style']['violations']}, "
+    f"suggestions={output['improvements']['suggestions']}"
+)
+
+print(
+    f"Simulation confirmed: score={score}, "
+    f"violations={len(output['style']['violations'])}, "
+    f"suggestions={len(output['improvements']['suggestions'])}"
+)
+print("All assertions passed.")
diff --git a/packages/uipath/testcases/target-output-key-evals/pyproject.toml b/packages/uipath/testcases/target-output-key-evals/pyproject.toml
new file mode 100644
index 000000000..0b6842b25
--- /dev/null
+++ b/packages/uipath/testcases/target-output-key-evals/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "target-output-key-evals"
+version = "0.0.1"
+description = "Tests for targetOutputKey path resolution in legacy evaluators"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/target-output-key-evals/run.sh b/packages/uipath/testcases/target-output-key-evals/run.sh
new file mode 100755
index 000000000..6797c3270
--- /dev/null
+++ b/packages/uipath/testcases/target-output-key-evals/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running target-output-key evaluations..."
+uv run uipath eval main ../../samples/multi-output-agent/evaluations/eval-sets/target-output-key.json --no-report --output-file target-output-key.json
+
+echo "Test completed successfully!"
diff --git a/packages/uipath/testcases/target-output-key-evals/src/assert.py b/packages/uipath/testcases/target-output-key-evals/src/assert.py
new file mode 100644
index 000000000..6d2dc53c9
--- /dev/null
+++ b/packages/uipath/testcases/target-output-key-evals/src/assert.py
@@ -0,0 +1,84 @@
+"""Assertions for target-output-key-evals testcase.
+
+Validates that targetOutputKey path resolution works correctly across
+legacy evaluators with nested dot-notation and array-index paths.
+"""
+
+import json
+import os
+
+EXPECTED_EVALUATORS = {
+    "legacy-equality-full-output",
+    "legacy-equality-flat-key",
+    "legacy-equality-nested-path",
+    "legacy-equality-deep-nested",
+    "legacy-equality-array-index",
+    "legacy-equality-array-tag",
+    "legacy-json-similarity-nested",
+    "legacy-json-similarity-customer",
+}
+
+
+def main() -> None:
+    output_file = "target-output-key.json"
+    assert os.path.isfile(output_file), f"Output file '{output_file}' not found"
+    print(f"  Found output file: {output_file}")
+
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    assert "evaluationSetResults" in output_data, "Missing 'evaluationSetResults'"
+
+    evaluation_results = output_data["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+    print(f"  Found {len(evaluation_results)} evaluation result(s)")
+
+    failed_count = 0
+    seen_evaluators: set[str] = set()
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        print(f"\n  Validating: {eval_name}")
+
+        eval_run_results = eval_result.get("evaluationRunResults", [])
+        assert len(eval_run_results) > 0, f"No run results for '{eval_name}'"
+
+        for eval_run in eval_run_results:
+            evaluator_id = eval_run.get("evaluatorId", "Unknown")
+            evaluator_name = eval_run.get("evaluatorName", evaluator_id)
+            result = eval_run.get("result", {})
+            score = result.get("score")
+
+            seen_evaluators.add(evaluator_id)
+
+            # Both ExactMatch (serialized as 100.0) and JsonSimilarity
+            # should score 100.0 when outputs match perfectly
+            is_passing = False
+            if score is True:
+                is_passing = True
+            elif isinstance(score, (int, float)) and score >= 99.0:
+                is_passing = True
+
+            if is_passing:
+                display = f"{score:.1f}" if isinstance(score, float) else str(score)
+                print(f"    {evaluator_name}: score={display} (pass)")
+            else:
+                print(f"    {evaluator_name}: score={score} (FAILED - expected >= 99)")
+                failed_count += 1
+
+    # Verify all expected evaluators were seen
+    missing = EXPECTED_EVALUATORS - seen_evaluators
+    if missing:
+        print(f"\n  Missing evaluators: {missing}")
+        failed_count += len(missing)
+
+    print(f"\n{'=' * 60}")
+    print(f"  Failed: {failed_count}")
+    print(f"{'=' * 60}")
+
+    assert failed_count == 0, f"{failed_count} assertion(s) failed"
+    print("\n  All assertions passed!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/target-output-key-evals/uipath.json b/packages/uipath/testcases/target-output-key-evals/uipath.json
new file mode 100644
index 000000000..2a3782ddd
--- /dev/null
+++ b/packages/uipath/testcases/target-output-key-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/multi-output-agent/main.py:main"
+  }
+}
diff --git a/packages/uipath/testcases/tools-evals/pyproject.toml b/packages/uipath/testcases/tools-evals/pyproject.toml
new file mode 100644
index 000000000..6c3519ee6
--- /dev/null
+++ b/packages/uipath/testcases/tools-evals/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "weather-tools-agent"
+version = "0.0.1"
+description = "Weather tools agent testcase"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath",
+]
+requires-python = ">=3.11"
+
+[tool.uv.sources]
+uipath = { path = "../../", editable = true }
diff --git a/packages/uipath/testcases/tools-evals/run.sh b/packages/uipath/testcases/tools-evals/run.sh
new file mode 100755
index 000000000..def99e587
--- /dev/null
+++ b/packages/uipath/testcases/tools-evals/run.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+echo "Syncing dependencies..."
+uv sync
+
+echo "Authenticating with UiPath..."
+uv run uipath auth --client-id="$CLIENT_ID" --client-secret="$CLIENT_SECRET" --base-url="$BASE_URL"
+
+echo "Running evaluations..."
+uv run uipath eval main ../../samples/weather_tools/evaluations/eval-sets/default.json --no-report
+
+#echo "Running assertions..."
+#uv run python assert.py
diff --git a/packages/uipath/testcases/tools-evals/src/assert.py b/packages/uipath/testcases/tools-evals/src/assert.py
new file mode 100644
index 000000000..1597cf7a9
--- /dev/null
+++ b/packages/uipath/testcases/tools-evals/src/assert.py
@@ -0,0 +1,102 @@
+"""Assertions for tools-evals testcase.
+
+This script validates that the tool call evaluators work correctly by:
+1. Reading the evaluation output from __uipath/output.json
+2. Validating that evaluations have scores greater than 0
+"""
+
+import json
+import os
+
+
+def main() -> None:
+    """Main assertion logic."""
+    # Check if output file exists
+    output_file = "__uipath/output.json"
+
+    assert os.path.isfile(output_file), f"Evaluation output file '{output_file}' not found"
+    print(f"✓ Found evaluation output file: {output_file}")
+
+    # Load evaluation results
+    with open(output_file, "r", encoding="utf-8") as f:
+        output_data = json.load(f)
+
+    print(f"✓ Loaded evaluation output")
+
+    # Check status
+    status = output_data.get("status")
+    assert status == "successful", f"Evaluation run failed with status: {status}"
+    print(f"✓ Evaluation run status: successful")
+
+    # Extract output data
+    output = output_data.get("output", {})
+
+    # Validate structure
+    assert "evaluationSetResults" in output, "Missing 'evaluationSetResults' in output"
+
+    evaluation_results = output["evaluationSetResults"]
+    assert len(evaluation_results) > 0, "No evaluation results found"
+
+    print(f"✓ Found {len(evaluation_results)} evaluation result(s)")
+
+    # Validate each evaluation result
+    passed_count = 0
+    failed_count = 0
+    has_positive_scores = False
+
+    for eval_result in evaluation_results:
+        eval_name = eval_result.get("evaluationName", "Unknown")
+        print(f"\n→ Validating: {eval_name}")
+
+        try:
+            # Validate evaluation results are present
+            eval_run_results = eval_result.get("evaluationRunResults", [])
+            if len(eval_run_results) == 0:
+                print(f"  ❌ No evaluation run results for '{eval_name}'")
+                failed_count += 1
+                continue
+
+            # Check that evaluations have scores > 0
+            all_passed = True
+            min_score = 100
+            for eval_run in eval_run_results:
+                evaluator_name = eval_run.get("evaluatorName", "Unknown")
+                result = eval_run.get("result", {})
+                score = result.get("score", 0)
+                min_score = min(min_score, score)
+
+                # Check if score is greater than 0
+                if score > 0:
+                    has_positive_scores = True
+                    print(f"  ✓ {evaluator_name}: score={score:.1f}")
+                else:
+                    print(f"  ✗ {evaluator_name}: score={score:.1f} (must be > 0)")
+                    all_passed = False
+
+            if all_passed and min_score > 0:
+                print(f"  ✓ All evaluators passed for '{eval_name}' (min score: {min_score:.1f})")
+                passed_count += 1
+            else:
+                print(f"  ✗ Some evaluators failed for '{eval_name}'")
+                failed_count += 1
+
+        except Exception as e:
+            print(f"  ✗ Error validating '{eval_name}': {e}")
+            failed_count += 1
+
+    # Final summary
+    print(f"\n{'='*60}")
+    print(f"Summary:")
+    print(f"  Total evaluations: {passed_count + failed_count}")
+    print(f"  ✓ Passed: {passed_count}")
+    print(f"  ✗ Failed: {failed_count}")
+    print(f"{'='*60}")
+
+    assert failed_count == 0, "Some assertions failed"
+    assert has_positive_scores, "No evaluation scores greater than 0 were found"
+
+    print("\n✅ All assertions passed!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/uipath/testcases/tools-evals/uipath.json b/packages/uipath/testcases/tools-evals/uipath.json
new file mode 100644
index 000000000..e8e2e79cd
--- /dev/null
+++ b/packages/uipath/testcases/tools-evals/uipath.json
@@ -0,0 +1,5 @@
+{
+  "functions": {
+    "main": "../../samples/weather_tools/main.py:main"
+  }
+}
\ No newline at end of file
diff --git a/tests/__init__.py b/packages/uipath/tests/__init__.py
similarity index 100%
rename from tests/__init__.py
rename to packages/uipath/tests/__init__.py
diff --git a/packages/uipath/tests/agent/models/test_agent.py b/packages/uipath/tests/agent/models/test_agent.py
new file mode 100644
index 000000000..202962c64
--- /dev/null
+++ b/packages/uipath/tests/agent/models/test_agent.py
@@ -0,0 +1,4603 @@
+from typing import Any
+
+import pytest
+from pydantic import TypeAdapter, ValidationError
+
+from uipath.agent.models.agent import (
+    AgentA2aResourceConfig,
+    AgentBooleanOperator,
+    AgentBooleanRule,
+    AgentBuiltInValidatorGuardrail,
+    AgentClientSideToolResourceConfig,
+    AgentContextResourceConfig,
+    AgentContextRetrievalMode,
+    AgentContextType,
+    AgentCustomGuardrail,
+    AgentDefinition,
+    AgentEscalationChannel,
+    AgentEscalationRecipient,
+    AgentEscalationRecipientType,
+    AgentEscalationResourceConfig,
+    AgentGuardrailActionType,
+    AgentGuardrailBlockAction,
+    AgentGuardrailEscalateAction,
+    AgentGuardrailLogAction,
+    AgentGuardrailSeverityLevel,
+    AgentGuardrailUnknownAction,
+    AgentIntegrationToolResourceConfig,
+    AgentInternalBatchTransformToolProperties,
+    AgentInternalDeepRagToolProperties,
+    AgentInternalToolResourceConfig,
+    AgentInternalToolType,
+    AgentIxpExtractionResourceConfig,
+    AgentIxpVsEscalationResourceConfig,
+    AgentMcpResourceConfig,
+    AgentMessageRole,
+    AgentNumberOperator,
+    AgentNumberRule,
+    AgentProcessToolResourceConfig,
+    AgentQuickFormChannelProperties,
+    AgentResourceType,
+    AgentToolArgumentPropertiesVariant,
+    AgentToolType,
+    AgentUnknownGuardrail,
+    AgentUnknownResourceConfig,
+    AgentUnknownToolResourceConfig,
+    AgentWordOperator,
+    AgentWordRule,
+    ArgumentEmailRecipient,
+    ArgumentGroupNameRecipient,
+    AssetRecipient,
+    BatchTransformFileExtension,
+    BatchTransformWebSearchGrounding,
+    CachedToolsConfig,
+    CitationMode,
+    CustomAssigneesRecipient,
+    DeepRagFileExtension,
+    RoundRobinRecipient,
+    StandardRecipient,
+    TaskTitleType,
+    TextBuilderTaskTitle,
+    TextToken,
+    TextTokenType,
+    ToolOutputRecipient,
+    WorkloadRecipient,
+)
+from uipath.platform.guardrails import (
+    EnumListParameterValue,
+    MapEnumParameterValue,
+)
+
+
+class TestAgentBuilderConfig:
+    def test_agent_with_all_tool_types_loads(self):
+        """Test that AgentDefinition can load a complete agent package with all tool types"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "e0f589ff-469a-44b3-8c5f-085826d8fa55",
+            "name": "Agent with All Tools",
+            "metadata": {"isConversational": False, "storageVersion": "22.0.0"},
+            "messages": [
+                {
+                    "role": "System",
+                    "content": "You are an agentic assistant.",
+                    "contentTokens": [
+                        {
+                            "type": "simpleText",
+                            "rawString": "You are an agentic assistant.",
+                        }
+                    ],
+                },
+                {
+                    "role": "User",
+                    "content": "Use the provided tools. Execute {{task}} the number of {{times}}.",
+                    "contentTokens": [
+                        {
+                            "type": "simpleText",
+                            "rawString": "Use the provided tools. Execute ",
+                        },
+                        {
+                            "type": "variable",
+                            "rawString": "input.task",
+                        },
+                        {
+                            "type": "simpleText",
+                            "rawString": " the number of ",
+                        },
+                        {
+                            "type": "variable",
+                            "rawString": "input.times",
+                        },
+                        {
+                            "type": "simpleText",
+                            "rawString": ".",
+                        },
+                    ],
+                },
+            ],
+            "inputSchema": {
+                "type": "object",
+                "required": ["task"],
+                "properties": {"task": {"type": "string"}, "times": {"type": "number"}},
+            },
+            "outputSchema": {
+                "type": "object",
+                "properties": {
+                    "task_summary": {
+                        "type": "string",
+                        "description": "describe the actions you have taken in a concise step by step summary",
+                    }
+                },
+                "title": "Outputs",
+                "required": ["task_summary"],
+            },
+            "settings": {
+                "model": "gpt-5-2025-08-07",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+                "byomProperties": {
+                    "connectionId": "test-byom-connection-id",
+                    "connectorKey": "uipath-openai-openai",
+                },
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "ProcessOrchestration",
+                    "$guardrailType": "custom",
+                    "id": "001",
+                    "rules": [{"$ruleType": "always", "applyTo": "inputAndOutput"}],
+                    "selector": {"scopes": ["Tool"]},
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {"in_arg": {"type": "string", "title": "in_arg"}},
+                        "required": [],
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "out_arg": {"type": "string", "title": "out_arg"}
+                        },
+                        "required": [],
+                    },
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "processName": "Basic.Agentic.Process.with.In.and.Out.Arguments",
+                        "folderPath": "TestFolder/Complete Solution 30 Sept",
+                    },
+                    "name": "Maestro Workflow",
+                    "description": "agentic process to be invoked by the agent",
+                },
+                {
+                    "$resourceType": "escalation",
+                    "id": "be506447-2cf1-47e6-a124-2930e6f0f3d8",
+                    "channels": [
+                        {
+                            "name": "Channel",
+                            "description": "Channel description",
+                            "type": "ActionCenter",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "AgentName": {"type": "string"},
+                                    "Statement": {"type": "string"},
+                                },
+                                "required": ["AgentName", "Statement"],
+                            },
+                            "outputSchema": {
+                                "type": "object",
+                                "properties": {"Reason": {"type": "string"}},
+                            },
+                            "outcomeMapping": {
+                                "Approve": "continue",
+                                "Reject": "continue",
+                            },
+                            "properties": {
+                                "appName": "AgentQuestionApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder/Complete Solution 30 Sept",
+                                "resourceKey": "b2ecb40b-dcce-4f71-96ae-8fa895905ae2",
+                                "isActionableMessageEnabled": True,
+                                "actionableMessageMetaData": {
+                                    "fieldSet": {
+                                        "type": "fieldSet",
+                                        "id": "3705cfbb-d1fb-4567-b1dd-036107c5c084",
+                                        "fields": [
+                                            {
+                                                "id": "AgentName",
+                                                "name": "AgentName",
+                                                "type": "Fact",
+                                                "placeHolderText": "",
+                                            },
+                                            {
+                                                "id": "Statement",
+                                                "name": "Statement",
+                                                "type": "Fact",
+                                                "placeHolderText": "",
+                                            },
+                                            {
+                                                "id": "Reason",
+                                                "name": "Reason",
+                                                "type": "Input.Text",
+                                                "placeHolderText": "",
+                                            },
+                                        ],
+                                    },
+                                    "actionSet": {
+                                        "type": "actionSet",
+                                        "id": "9ecd2de3-7ac3-47a6-836c-af1eaf67f9ca",
+                                        "actions": [
+                                            {
+                                                "id": "Approve",
+                                                "name": "Approve",
+                                                "title": "Approve",
+                                                "type": "Action.Http",
+                                                "isPrimary": True,
+                                            },
+                                            {
+                                                "id": "Reject",
+                                                "name": "Reject",
+                                                "title": "Reject",
+                                                "type": "Action.Http",
+                                                "isPrimary": True,
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                            "recipients": [
+                                {
+                                    "value": "a26a9809-69ee-427a-9f05-ba00623fef80",
+                                    "type": "UserId",
+                                }
+                            ],
+                            "taskTitle": "Test Task",
+                            "priority": "Medium",
+                            "labels": ["new", "stuff"],
+                        }
+                    ],
+                    "isAgentMemoryEnabled": True,
+                    "escalationType": 0,
+                    "name": "Human in the Loop App",
+                    "description": "an app for the agent to ask questions for the human",
+                },
+                {
+                    "$resourceType": "context",
+                    "folderPath": "TestFolder",
+                    "indexName": "MCP Documentation Index",
+                    "settings": {
+                        "threshold": 0,
+                        "resultCount": 3,
+                        "retrievalMode": "Semantic",
+                        "query": {
+                            "description": "The query for the Semantic strategy.",
+                            "variant": "Dynamic",
+                        },
+                        "folderPathPrefix": {},
+                        "fileExtension": {"value": "All"},
+                    },
+                    "name": "MCP Documentation Index",
+                    "description": "",
+                },
+                {
+                    "$resourceType": "tool",
+                    "id": "13b3928e-fad8-4bc1-ac06-31718143ded1",
+                    "referenceKey": "b54f2c33-40ee-4dda-b662-b6f787bc1ede",
+                    "name": "Basic RPA Process",
+                    "type": "process",
+                    "description": "RPA process to execute a given task",
+                    "location": "external",
+                    "isEnabled": True,
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {"task": {"type": "string"}},
+                        "required": ["task"],
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {"output": {"type": "string"}},
+                    },
+                    "settings": {},
+                    "argumentProperties": {
+                        "task": {
+                            "variant": "argument",
+                            "argumentPath": "$['task']",
+                            "isSensitive": False,
+                        }
+                    },
+                    "properties": {
+                        "processName": "Basic RPA Process",
+                        "folderPath": "TestFolder/Complete Solution 30 Sept",
+                    },
+                },
+                {
+                    "$resourceType": "tool",
+                    "type": "Api",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "success": {"type": "boolean"},
+                            "summary": {"type": "string"},
+                        },
+                        "title": "Outputs",
+                        "required": ["success", "summary"],
+                    },
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "processName": "Basic Http and Log API Wf",
+                        "folderPath": "TestFolder/Complete Solution 30 Sept",
+                    },
+                    "name": "Basic Http and Log API Wf",
+                    "description": "api workflow to be invoked by agent",
+                },
+                {
+                    "$resourceType": "mcp",
+                    "folderPath": "TestFolder/Complete Solution 30 Sept",
+                    "slug": "time-mcp",
+                    "availableTools": [
+                        {
+                            "name": "get_current_time",
+                            "description": "Get current time in a specific timezones",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "timezone": {
+                                        "type": "string",
+                                        "description": "IANA timezone name (e.g., 'America/New_York', 'Europe/London'). Use 'UTC' as local timezone if no timezone provided by the user.",
+                                    }
+                                },
+                                "required": ["timezone"],
+                            },
+                            "argumentProperties": {
+                                "timezone": {
+                                    "variant": "textBuilder",
+                                    "tokens": [
+                                        {
+                                            "type": "simpleText",
+                                            "rawString": "Europe/London",
+                                        },
+                                    ],
+                                    "isSensitive": False,
+                                },
+                            },
+                        },
+                        {
+                            "name": "convert_time",
+                            "description": "Convert time between timezones",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "source_timezone": {
+                                        "type": "string",
+                                        "description": "Source IANA timezone name (e.g., 'America/New_York', 'Europe/London'). Use 'UTC' as local timezone if no source timezone provided by the user.",
+                                    },
+                                    "time": {
+                                        "type": "string",
+                                        "description": "Time to convert in 24-hour format (HH:MM)",
+                                    },
+                                    "target_timezone": {
+                                        "type": "string",
+                                        "description": "Target IANA timezone name (e.g., 'Asia/Tokyo', 'America/San_Francisco'). Use 'UTC' as local timezone if no target timezone provided by the user.",
+                                    },
+                                },
+                                "required": [
+                                    "source_timezone",
+                                    "time",
+                                    "target_timezone",
+                                ],
+                            },
+                        },
+                    ],
+                    "name": "time_mcp",
+                    "description": "mcp server to get the current time",
+                },
+                {
+                    "$resourceType": "tool",
+                    "type": "Agent",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "content": {
+                                "type": "string",
+                                "description": "Output content",
+                            }
+                        },
+                    },
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "processName": "Current Date Agent",
+                        "folderPath": "TestFolder/Complete Solution 30 Sept",
+                    },
+                    "name": "Current Date Agent",
+                    "description": "subagent to be invoked by agent",
+                },
+                {
+                    "$resourceType": "tool",
+                    "type": "Integration",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "To": {"type": "string", "title": "To"},
+                            "Subject": {"type": "string", "title": "Subject"},
+                        },
+                        "required": ["To"],
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolPath": "/SendEmail",
+                        "objectName": "SendEmail",
+                        "toolDisplayName": "Send Email",
+                        "toolDescription": "Sends an email message",
+                        "method": "POST",
+                        "bodyStructure": {
+                            "contentType": "multipart",
+                            "jsonBodySection": "body",
+                        },
+                        "connection": {
+                            "id": "cccccccc-0000-0000-0000-000000000004",
+                            "name": "Gmail Connection",
+                            "elementInstanceId": 0,
+                            "apiBaseUri": "",
+                            "state": "enabled",
+                            "isDefault": False,
+                            "connector": {
+                                "key": "uipath-google-gmail",
+                                "name": "Gmail",
+                                "enabled": True,
+                            },
+                            "folder": {"key": "bbbbbbbb-0000-0000-0000-000000000004"},
+                            "solutionProperties": {
+                                "resourceKey": "cccccccc-0000-0000-0000-000000000004"
+                            },
+                        },
+                        "parameters": [
+                            {
+                                "name": "To",
+                                "displayName": "To",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "fieldVariant": "dynamic",
+                                "sortOrder": 1,
+                                "required": True,
+                            },
+                        ],
+                    },
+                    "name": "Send Email",
+                    "description": "Send an email via Gmail",
+                    "isEnabled": True,
+                },
+            ],
+            "features": [],
+        }
+
+        # Test that the model loads without errors
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Basic assertions
+        assert isinstance(config, AgentDefinition), (
+            "AgentDefinition should be a low code agent."
+        )
+        assert config.id == "e0f589ff-469a-44b3-8c5f-085826d8fa55"
+        assert config.name == "Agent with All Tools"
+        assert config.version == "1.0.0"
+        assert len(config.messages) == 2
+        assert len(config.resources) == 8  # All tool types + escalation + context + mcp
+        assert config.settings.engine == "basic-v1"
+        assert config.settings.max_tokens == 16384
+        assert config.settings.byom_properties is not None
+        assert (
+            config.settings.byom_properties.connection_id == "test-byom-connection-id"
+        )
+        assert config.settings.byom_properties.connector_key == "uipath-openai-openai"
+
+        # Validate resource types
+        resource_types = [resource.resource_type for resource in config.resources]
+        assert resource_types.count(AgentResourceType.ESCALATION) == 1
+        assert resource_types.count(AgentResourceType.TOOL) == 5
+        assert resource_types.count(AgentResourceType.CONTEXT) == 1
+        assert resource_types.count(AgentResourceType.MCP) == 1
+
+        # Validate tool types (ProcessOrchestration, Process, Api, Agent, Integration)
+        tool_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.TOOL
+        ]
+        assert len(tool_resources) == 5
+
+        tool_names = [t.name for t in tool_resources]
+        assert "Maestro Workflow" in tool_names  # ProcessOrchestration
+        assert "Basic RPA Process" in tool_names  # Process
+        assert "Basic Http and Log API Wf" in tool_names  # Api
+        assert "Current Date Agent" in tool_names  # Agent
+        assert "Send Email" in tool_names  # Integration
+
+        # Validate MCP resource
+        mcp_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.MCP
+        ]
+        assert len(mcp_resources) == 1
+        mcp_resource = mcp_resources[0]
+        assert isinstance(mcp_resource, AgentMcpResourceConfig)
+        assert mcp_resource.name == "time_mcp"
+        assert mcp_resource.slug == "time-mcp"
+        assert len(mcp_resource.available_tools) == 2
+        assert mcp_resource.available_tools[0].name == "get_current_time"
+        assert mcp_resource.available_tools[1].name == "convert_time"
+        # Validate that outputSchema is None when not provided in JSON
+        assert mcp_resource.available_tools[0].output_schema is None
+        assert mcp_resource.available_tools[1].output_schema is None
+
+        # Validate escalation resource with detailed properties
+        escalation_resource = next(
+            r
+            for r in config.resources
+            if r.resource_type == AgentResourceType.ESCALATION
+        )
+        assert isinstance(escalation_resource, AgentEscalationResourceConfig)
+        assert escalation_resource.name == "Human in the Loop App"
+        assert escalation_resource.is_agent_memory_enabled is True
+        assert len(escalation_resource.channels) == 1
+        channel = escalation_resource.channels[0]
+        assert channel.name == "Channel"
+        assert channel.task_title == "Test Task"
+        assert channel.priority == "Medium"
+        assert channel.labels == ["new", "stuff"]
+
+        # Validate context resource
+        context_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.CONTEXT
+        ]
+        assert len(context_resources) == 1
+        assert context_resources[0].name == "MCP Documentation Index"
+
+        # Validate Integration tool resource
+        integration_tools = [
+            r
+            for r in config.resources
+            if isinstance(r, AgentIntegrationToolResourceConfig)
+        ]
+        assert len(integration_tools) == 1
+        integration_tool = integration_tools[0]
+        assert integration_tool.type == AgentToolType.INTEGRATION
+        assert integration_tool.name == "Send Email"
+        assert integration_tool.properties.tool_path == "/SendEmail"
+        assert integration_tool.properties.method == "POST"
+        assert integration_tool.properties.connection.connector is not None
+        assert (
+            integration_tool.properties.connection.connector["key"]
+            == "uipath-google-gmail"
+        )
+        assert integration_tool.properties.body_structure is not None
+        assert integration_tool.properties.body_structure["contentType"] == "multipart"
+        assert len(integration_tool.properties.parameters) == 1
+        assert integration_tool.properties.parameters[0].name == "To"
+
+    def test_agent_config_loads_guardrails(self):
+        """Test that AgentConfig can load and parse both Custom and Built-in guardrails from real JSON"""
+
+        json_data = {
+            "id": "55f89eb5-e4dc-4129-8c3d-da80f6c7f921",
+            "name": "NumberTranslator",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {
+                "type": "object",
+                "required": ["number"],
+                "properties": {"number": {"type": "string", "description": "number"}},
+            },
+            "outputSchema": {
+                "type": "object",
+                "properties": {
+                    "content": {"type": "string", "description": "Output content"}
+                },
+            },
+            "metadata": {"storageVersion": "23.0.0", "isConversational": False},
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "name": "StringToNumber",
+                    "description": "Converts word to number",
+                    "type": "agent",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {"word": {"type": "string"}},
+                        "required": ["word"],
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "processName": "StringToNumber",
+                        "folderPath": "solution_folder",
+                    },
+                }
+            ],
+            "guardrails": [
+                {
+                    "$guardrailType": "builtInValidator",
+                    "id": "2f36abe1-2ae1-457b-b565-ccf7a1b6d088",
+                    "name": "PII detection guardrail",
+                    "description": "This validator is designed to detect personally identifiable information using Azure Cognitive Services",
+                    "validatorType": "pii_detection",
+                    "validatorParameters": [
+                        {
+                            "$parameterType": "enum-list",
+                            "id": "entities",
+                            "value": ["Email", "Address"],
+                        },
+                        {
+                            "$parameterType": "map-enum",
+                            "id": "entityThresholds",
+                            "value": {"Email": 1, "Address": 0.7},
+                        },
+                    ],
+                    "action": {
+                        "$actionType": "escalate",
+                        "app": {
+                            "id": "cf4cb73d-7310-49b1-9a9e-e7653dad7f4e",
+                            "version": "0",
+                            "name": "-Guardrail Form",
+                            "folderId": "d0195402-505d-54c1-0b94-5faa5bf69ad1",
+                            "folderName": "solution_folder",
+                        },
+                        "recipient": {
+                            "type": 1,
+                            "value": "5f872639-fc71-4a50-b17d-f68eb357b436",
+                            "displayName": "User Name",
+                        },
+                    },
+                    "enabledForEvals": True,
+                    "selector": {"scopes": ["Tool"], "matchNames": ["StringToNumber"]},
+                },
+                {
+                    "$guardrailType": "custom",
+                    "id": "7b2a9218-c3d2-4f19-a800-8d6fe77a64e2",
+                    "name": "ExcludeHELLO",
+                    "description": 'the input shouldn\'t be "hello"',
+                    "rules": [
+                        {
+                            "$ruleType": "word",
+                            "fieldSelector": {
+                                "$selectorType": "specific",
+                                "fields": [{"path": "word", "source": "input"}],
+                            },
+                            "operator": "doesNotContain",
+                            "value": "hello",
+                        }
+                    ],
+                    "action": {"$actionType": "block", "reason": 'Input is "hello"'},
+                    "enabledForEvals": True,
+                    "selector": {"scopes": ["Tool"], "matchNames": ["StringToNumber"]},
+                },
+            ],
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are a English to Romanian translator",
+                },
+                {
+                    "role": "user",
+                    "content": "Use the tool StringToNumber to convert the string {{number}} into a number type, then write the obtained number in romanian. ",
+                },
+            ],
+        }
+
+        # Parse with TypeAdapter
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate the main agent properties
+        assert isinstance(config, AgentDefinition), "Agent should be a AgentDefinition"
+
+        # Validate tool resource type discrimination
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig), (
+            "Tool should be parsed as AgentProcessToolResourceConfig based on type='Agent'"
+        )
+        assert tool_resource.resource_type == AgentResourceType.TOOL
+        assert tool_resource.type == AgentToolType.AGENT  # The discriminator field
+
+        # Validate agent-level guardrails
+        assert config.guardrails is not None
+        assert len(config.guardrails) == 2
+
+        # Test built-in validator at agent level
+        agent_builtin_guardrail = config.guardrails[0]
+        assert isinstance(agent_builtin_guardrail, AgentBuiltInValidatorGuardrail), (
+            "Agent guardrail should be AgentBuiltInValidatorGuardrail"
+        )
+
+        # Check base guardrail properties
+        assert agent_builtin_guardrail.id == "2f36abe1-2ae1-457b-b565-ccf7a1b6d088"
+        assert agent_builtin_guardrail.name == "PII detection guardrail"
+        assert (
+            agent_builtin_guardrail.description
+            == "This validator is designed to detect personally identifiable information using Azure Cognitive Services"
+        )
+        assert agent_builtin_guardrail.enabled_for_evals is True
+        assert agent_builtin_guardrail.selector is not None
+        assert agent_builtin_guardrail.selector.scopes == ["Tool"]
+        assert agent_builtin_guardrail.selector.match_names == ["StringToNumber"]
+
+        # Check built-in validator specific properties
+        assert agent_builtin_guardrail.guardrail_type == "builtInValidator"
+        assert agent_builtin_guardrail.validator_type == "pii_detection"
+        assert len(agent_builtin_guardrail.validator_parameters) == 2
+
+        # Check validator parameters
+        enum_param = agent_builtin_guardrail.validator_parameters[0]
+        assert isinstance(enum_param, EnumListParameterValue), (
+            "Should be EnumListParameterValue based on $parameterType='enum-list'"
+        )
+        assert enum_param.parameter_type == "enum-list"
+        assert enum_param.id == "entities"
+        assert enum_param.value == ["Email", "Address"]
+
+        map_param = agent_builtin_guardrail.validator_parameters[1]
+        assert isinstance(map_param, MapEnumParameterValue), (
+            "Should be MapEnumParameterValue based on $parameterType='map-enum'"
+        )
+        assert map_param.parameter_type == "map-enum"
+        assert map_param.id == "entityThresholds"
+        assert map_param.value == {"Email": 1, "Address": 0.7}
+
+        # Check action
+        escalate_action = agent_builtin_guardrail.action
+        assert isinstance(escalate_action, AgentGuardrailEscalateAction), (
+            "Should be EscalateAction based on $actionType='escalate'"
+        )
+        assert escalate_action.action_type == "escalate"
+        assert escalate_action.app.id == "cf4cb73d-7310-49b1-9a9e-e7653dad7f4e"
+        assert escalate_action.app.name == "-Guardrail Form"
+        assert escalate_action.app.folder_name == "solution_folder"
+        assert escalate_action.recipient.type == AgentEscalationRecipientType.USER_ID
+        assert escalate_action.recipient.value == "5f872639-fc71-4a50-b17d-f68eb357b436"
+        assert escalate_action.recipient.display_name == "User Name"
+
+        # Test custom guardrail at agent level
+        agent_custom_guardrail = config.guardrails[1]
+        assert isinstance(agent_custom_guardrail, AgentCustomGuardrail), (
+            "Agent custom guardrail should be AgentCustomGuardrail"
+        )
+
+        # Check base guardrail properties
+        assert agent_custom_guardrail.id == "7b2a9218-c3d2-4f19-a800-8d6fe77a64e2"
+        assert agent_custom_guardrail.name == "ExcludeHELLO"
+        assert agent_custom_guardrail.description == 'the input shouldn\'t be "hello"'
+        assert agent_custom_guardrail.enabled_for_evals is True
+        assert agent_custom_guardrail.selector.scopes == ["Tool"]
+        assert agent_custom_guardrail.selector.match_names == ["StringToNumber"]
+
+        # Check custom guardrail specific properties
+        assert agent_custom_guardrail.guardrail_type == "custom"
+        assert len(agent_custom_guardrail.rules) == 1
+
+        # Check rule
+        rule = agent_custom_guardrail.rules[0]
+        assert isinstance(rule, AgentWordRule), (
+            "Rule should be WordRule based on $ruleType='word'"
+        )
+        assert rule.rule_type == "word"
+        assert rule.operator == "doesNotContain"  # Updated to use the correct operator
+        assert rule.value == "hello"
+
+        # Check field selector
+        assert rule.field_selector.selector_type == "specific"
+        assert len(rule.field_selector.fields) == 1
+        assert rule.field_selector.fields[0].path == "word"
+        assert rule.field_selector.fields[0].source == "input"
+
+        # Check action
+        block_action = agent_custom_guardrail.action
+        assert isinstance(block_action, AgentGuardrailBlockAction), (
+            "Should be BlockAction based on $actionType='block'"
+        )
+        assert block_action.action_type == "block"
+        assert block_action.reason == 'Input is "hello"'
+
+    def test_agent_with_gmail_send_email_integration(self):
+        """Test agent with Gmail Send Email integration tool"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000001",
+            "name": "Agent with Send Email Tool",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "Integration",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "SaveAsDraft": {
+                                "type": "boolean",
+                                "title": "Save as draft",
+                                "description": "Send an email message. By default, the email will be saved as draft.",
+                            },
+                            "CC": {
+                                "type": "string",
+                                "title": "CC",
+                                "description": "The secondary recipients of the email, separated by comma (,)",
+                            },
+                            "Importance": {
+                                "type": "string",
+                                "title": "Importance",
+                                "description": "The importance of the mail",
+                                "enum": ["normal"],
+                                "oneOf": [
+                                    {"const": "normal", "title": "Normal"},
+                                    {"const": "high", "title": "High"},
+                                    {"const": "low", "title": "Low"},
+                                ],
+                            },
+                            "ReplyTo": {
+                                "type": "string",
+                                "title": "Reply to",
+                                "description": "The email addresses to use when replying, separated by comma (,)",
+                            },
+                            "BCC": {
+                                "type": "string",
+                                "title": "BCC",
+                                "description": "The hidden recipients of the email, separated by comma (,)",
+                            },
+                            "To": {
+                                "type": "string",
+                                "title": "To",
+                                "description": "The primary recipients of the email, separated by comma (,)",
+                            },
+                            "Body": {
+                                "type": "string",
+                                "title": "Body",
+                                "description": "The body of the email",
+                            },
+                            "Subject": {
+                                "type": "string",
+                                "title": "Subject",
+                                "description": "The subject of the email",
+                            },
+                        },
+                        "additionalProperties": False,
+                        "required": ["To"],
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolPath": "/SendEmail",
+                        "objectName": "SendEmail",
+                        "toolDisplayName": "Send Email",
+                        "toolDescription": "Sends an email message",
+                        "method": "POST",
+                        "bodyStructure": {
+                            "contentType": "multipart",
+                            "jsonBodySection": "body",
+                        },
+                        "connection": {
+                            "id": "cccccccc-0000-0000-0000-000000000001",
+                            "name": "Gmail Connection",
+                            "elementInstanceId": 0,
+                            "apiBaseUri": "",
+                            "state": "enabled",
+                            "isDefault": False,
+                            "connector": {
+                                "key": "uipath-google-gmail",
+                                "name": "Gmail",
+                                "enabled": True,
+                            },
+                            "folder": {"key": "bbbbbbbb-0000-0000-0000-000000000001"},
+                            "solutionProperties": {
+                                "resourceKey": "cccccccc-0000-0000-0000-000000000001"
+                            },
+                        },
+                        "parameters": [
+                            {
+                                "name": "body",
+                                "displayName": "Body",
+                                "type": "string",
+                                "fieldLocation": "multipart",
+                                "value": "{{prompt}}",
+                                "description": "The message body\n",
+                                "position": "primary",
+                                "sortOrder": 1,
+                                "required": True,
+                                "fieldVariant": "dynamic",
+                                "dynamic": True,
+                                "isCascading": False,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "SaveAsDraft",
+                                "displayName": "Save as draft",
+                                "type": "boolean",
+                                "fieldLocation": "query",
+                                "value": False,
+                                "description": "",
+                                "position": "primary",
+                                "sortOrder": 2,
+                                "required": False,
+                                "fieldVariant": "static",
+                                "dynamic": True,
+                                "isCascading": False,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "To",
+                                "displayName": "To",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The primary recipients of the email, separated by comma (,)",
+                                "position": "primary",
+                                "sortOrder": 3,
+                                "required": True,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "Subject",
+                                "displayName": "Subject",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The subject of the email",
+                                "position": "primary",
+                                "sortOrder": 4,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "Body",
+                                "displayName": "Body",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The body of the email",
+                                "componentType": "RichTextEditorHTML",
+                                "position": "primary",
+                                "sortOrder": 5,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "file",
+                                "displayName": "Attachment",
+                                "type": "file",
+                                "fieldLocation": "multipart",
+                                "value": "{{prompt}}",
+                                "description": "The attachment to be sent with the email",
+                                "position": "primary",
+                                "sortOrder": 6,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "dynamic": True,
+                                "isCascading": False,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "Importance",
+                                "displayName": "Importance",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "normal",
+                                "description": "",
+                                "position": "secondary",
+                                "sortOrder": 7,
+                                "required": False,
+                                "fieldVariant": "static",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": [
+                                    {"name": "Normal", "value": "normal"},
+                                    {"name": "High", "value": "high"},
+                                    {"name": "Low", "value": "low"},
+                                ],
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "ReplyTo",
+                                "displayName": "Reply to",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The email addresses to use when replying, separated by comma (,)",
+                                "position": "secondary",
+                                "sortOrder": 8,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "CC",
+                                "displayName": "CC",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The secondary recipients of the email, separated by comma (,)",
+                                "position": "secondary",
+                                "sortOrder": 9,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                            {
+                                "name": "BCC",
+                                "displayName": "BCC",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "description": "The hidden recipients of the email, separated by comma (,)",
+                                "position": "secondary",
+                                "sortOrder": 10,
+                                "required": False,
+                                "fieldVariant": "dynamic",
+                                "isCascading": False,
+                                "dynamic": True,
+                                "enumValues": None,
+                                "loadReferenceOptionsByDefault": None,
+                                "dynamicBehavior": [],
+                                "reference": None,
+                            },
+                        ],
+                    },
+                    "name": "Send Email",
+                    "description": "Sends an email message",
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        # Test deserialization
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate agent
+        assert config.id == "aaaaaaaa-0000-0000-0000-000000000001"
+        assert config.name == "Agent with Send Email Tool"
+        assert len(config.resources) == 1
+
+        # Validate integration tool
+        tool = config.resources[0]
+        assert isinstance(tool, AgentIntegrationToolResourceConfig)
+        assert tool.type == AgentToolType.INTEGRATION
+        assert tool.name == "Send Email"
+        assert tool.description == "Sends an email message"
+
+        # Validate tool properties
+        assert tool.properties.tool_path == "/SendEmail"
+        assert tool.properties.object_name == "SendEmail"
+        assert tool.properties.tool_display_name == "Send Email"
+        assert tool.properties.method == "POST"
+
+        # Validate connection
+        assert tool.properties.connection is not None
+        assert tool.properties.connection.connector is not None
+        assert tool.properties.connection.connector["key"] == "uipath-google-gmail"
+
+        # Validate body structure
+        assert tool.properties.body_structure is not None
+        assert tool.properties.body_structure["contentType"] == "multipart"
+
+        # Validate parameters
+        assert len(tool.properties.parameters) == 10
+        assert tool.properties.parameters[0].name == "body"
+        assert tool.properties.parameters[0].field_location == "multipart"
+        assert tool.properties.parameters[0].required is True
+
+        # Validate additional email parameters
+        param_names = [p.name for p in tool.properties.parameters]
+        assert "Subject" in param_names
+        assert "Body" in param_names
+        assert "CC" in param_names
+        assert "BCC" in param_names
+        assert "ReplyTo" in param_names
+        assert "Importance" in param_names
+
+        # Validate input_schema properties
+        assert tool.input_schema is not None
+        assert tool.input_schema["type"] == "object"
+        assert "properties" in tool.input_schema
+        assert "required" in tool.input_schema
+        assert tool.input_schema["required"] == ["To"]
+        assert tool.input_schema["additionalProperties"] is False
+
+        # Validate input_schema property fields
+        schema_props = tool.input_schema["properties"]
+        assert "SaveAsDraft" in schema_props
+        assert schema_props["SaveAsDraft"]["type"] == "boolean"
+        assert schema_props["SaveAsDraft"]["title"] == "Save as draft"
+
+        assert "To" in schema_props
+        assert schema_props["To"]["type"] == "string"
+        assert schema_props["To"]["title"] == "To"
+        assert "separated by comma" in schema_props["To"]["description"]
+
+        assert "Subject" in schema_props
+        assert schema_props["Subject"]["type"] == "string"
+
+        assert "Body" in schema_props
+        assert schema_props["Body"]["type"] == "string"
+        assert schema_props["Body"]["description"] == "The body of the email"
+
+        assert "CC" in schema_props
+        assert schema_props["CC"]["type"] == "string"
+
+        assert "BCC" in schema_props
+        assert schema_props["BCC"]["type"] == "string"
+
+        assert "ReplyTo" in schema_props
+        assert schema_props["ReplyTo"]["type"] == "string"
+        assert schema_props["ReplyTo"]["title"] == "Reply to"
+
+        assert "Importance" in schema_props
+        assert schema_props["Importance"]["type"] == "string"
+        assert "enum" in schema_props["Importance"]
+        assert schema_props["Importance"]["enum"] == ["normal"]
+        assert "oneOf" in schema_props["Importance"]
+        assert len(schema_props["Importance"]["oneOf"]) == 3
+
+    def test_agent_with_jira_create_issue_integration(self):
+        """Test agent with Jira Create Issue (Task) integration tool"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000002",
+            "name": "Jira CreateIssue Agent",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "Integration",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "projectKey": {"type": "string", "title": "Project Key"},
+                            "summary": {"type": "string", "title": "Summary"},
+                            "description": {"type": "string", "title": "Description"},
+                        },
+                        "required": ["projectKey", "summary"],
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "key": {"type": "string"},
+                        },
+                    },
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolPath": "/CreateIssue",
+                        "objectName": "CreateIssue",
+                        "toolDisplayName": "Create Issue",
+                        "toolDescription": "Creates a new Jira issue",
+                        "method": "POST",
+                        "bodyStructure": {
+                            "contentType": "json",
+                            "jsonBodySection": "body",
+                        },
+                        "connection": {
+                            "id": "cccccccc-0000-0000-0000-000000000002",
+                            "name": "Jira Connection",
+                            "elementInstanceId": 0,
+                            "apiBaseUri": "",
+                            "state": "enabled",
+                            "isDefault": False,
+                            "connector": {
+                                "key": "uipath-atlassian-jira",
+                                "name": "Jira",
+                                "enabled": True,
+                            },
+                            "folder": {"key": "bbbbbbbb-0000-0000-0000-000000000002"},
+                            "solutionProperties": {
+                                "resourceKey": "cccccccc-0000-0000-0000-000000000002"
+                            },
+                        },
+                        "parameters": [
+                            {
+                                "name": "projectKey",
+                                "displayName": "Project Key",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "fieldVariant": "dynamic",
+                                "sortOrder": 1,
+                                "required": True,
+                            },
+                            {
+                                "name": "summary",
+                                "displayName": "Summary",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "fieldVariant": "dynamic",
+                                "sortOrder": 2,
+                                "required": True,
+                            },
+                            {
+                                "name": "issueType",
+                                "displayName": "Issue Type",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "Task",
+                                "fieldVariant": "static",
+                                "sortOrder": 3,
+                                "required": True,
+                            },
+                        ],
+                    },
+                    "name": "Create Issue",
+                    "description": "Creates a new Jira issue",
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        # Test deserialization
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate agent
+        assert config.name == "Jira CreateIssue Agent"
+        assert len(config.resources) == 1
+
+        # Validate integration tool
+        tool = config.resources[0]
+        assert isinstance(tool, AgentIntegrationToolResourceConfig)
+        assert tool.type == AgentToolType.INTEGRATION
+        assert tool.name == "Create Issue"
+
+        # Validate tool properties
+        assert tool.properties.tool_path == "/CreateIssue"
+        assert tool.properties.method == "POST"
+        assert tool.properties.connection is not None
+        assert tool.properties.connection.connector is not None
+        assert tool.properties.connection.connector["key"] == "uipath-atlassian-jira"
+
+        # Validate body structure
+        assert tool.properties.body_structure is not None
+        assert tool.properties.body_structure["contentType"] == "json"
+
+        # Validate parameters
+        assert len(tool.properties.parameters) == 3
+        # Check for static parameter
+        static_param = next(
+            p for p in tool.properties.parameters if p.field_variant == "static"
+        )
+        assert static_param.name == "issueType"
+        assert static_param.value == "Task"
+
+        # Validate input_schema properties
+        assert tool.input_schema is not None
+        assert tool.input_schema["type"] == "object"
+        assert "properties" in tool.input_schema
+        assert "required" in tool.input_schema
+        assert tool.input_schema["required"] == ["projectKey", "summary"]
+
+        # Validate input_schema property fields
+        schema_props = tool.input_schema["properties"]
+        assert "projectKey" in schema_props
+        assert schema_props["projectKey"]["type"] == "string"
+        assert schema_props["projectKey"]["title"] == "Project Key"
+
+        assert "summary" in schema_props
+        assert schema_props["summary"]["type"] == "string"
+        assert schema_props["summary"]["title"] == "Summary"
+
+        assert "description" in schema_props
+        assert schema_props["description"]["type"] == "string"
+        assert schema_props["description"]["title"] == "Description"
+
+    def test_agent_with_jira_search_issues_integration(self):
+        """Test agent with Jira Search Issues integration tool"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000003",
+            "name": "Jira SearchIssues Agent",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "Integration",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "jql": {
+                                "type": "string",
+                                "title": "JQL Query",
+                                "description": "Jira Query Language query string",
+                            }
+                        },
+                        "required": ["jql"],
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "issues": {"type": "array"},
+                            "total": {"type": "integer"},
+                        },
+                    },
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolPath": "/SearchIssues",
+                        "objectName": "SearchIssues",
+                        "toolDisplayName": "Search Issues",
+                        "toolDescription": "Search issues in Jira",
+                        "method": "GET",
+                        "bodyStructure": {
+                            "contentType": "json",
+                            "jsonBodySection": "body",
+                        },
+                        "connection": {
+                            "id": "cccccccc-0000-0000-0000-000000000003",
+                            "name": "Jira Connection",
+                            "elementInstanceId": 0,
+                            "apiBaseUri": "",
+                            "state": "enabled",
+                            "isDefault": False,
+                            "connector": {
+                                "key": "uipath-atlassian-jira",
+                                "name": "Jira",
+                                "enabled": True,
+                            },
+                            "folder": {"key": "bbbbbbbb-0000-0000-0000-000000000003"},
+                            "solutionProperties": {
+                                "resourceKey": "cccccccc-0000-0000-0000-000000000003"
+                            },
+                        },
+                        "parameters": [
+                            {
+                                "name": "jql",
+                                "displayName": "JQL Query",
+                                "type": "string",
+                                "fieldLocation": "query",
+                                "value": "{{prompt}}",
+                                "fieldVariant": "dynamic",
+                                "sortOrder": 1,
+                                "required": True,
+                            }
+                        ],
+                    },
+                    "name": "Search Issues",
+                    "description": "Search issues in Jira",
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        # Test deserialization
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate agent
+        assert config.name == "Jira SearchIssues Agent"
+        assert len(config.resources) == 1
+
+        # Validate integration tool
+        tool = config.resources[0]
+        assert isinstance(tool, AgentIntegrationToolResourceConfig)
+        assert tool.type == AgentToolType.INTEGRATION
+        assert tool.name == "Search Issues"
+
+        # Validate tool properties
+        assert tool.properties.tool_path == "/SearchIssues"
+        assert tool.properties.method == "GET"
+        assert tool.properties.connection is not None
+        assert tool.properties.connection.connector is not None
+        assert tool.properties.connection.connector["key"] == "uipath-atlassian-jira"
+
+        # Validate parameters - query parameter
+        assert len(tool.properties.parameters) == 1
+        param = tool.properties.parameters[0]
+        assert param.name == "jql"
+        assert param.field_location == "query"  # GET method uses query parameters
+        assert param.required is True
+
+        # Validate input_schema properties
+        assert tool.input_schema is not None
+        assert tool.input_schema["type"] == "object"
+        assert "properties" in tool.input_schema
+        assert "required" in tool.input_schema
+        assert tool.input_schema["required"] == ["jql"]
+
+        # Validate input_schema property fields
+        schema_props = tool.input_schema["properties"]
+        assert "jql" in schema_props
+        assert schema_props["jql"]["type"] == "string"
+        assert schema_props["jql"]["title"] == "JQL Query"
+        assert schema_props["jql"]["description"] == "Jira Query Language query string"
+
+    def test_agent_with_unknown_guardrail_type(self):
+        """Test that AgentDefinition handles unknown guardrail types gracefully"""
+
+        json_data = {
+            "id": "test-unknown-guardrail",
+            "name": "Agent with Unknown Guardrail",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "guardrails": [
+                {
+                    "$guardrailType": "futureGuardrailType",
+                    "id": "future-guardrail-id",
+                    "name": "Future Guardrail",
+                    "description": "A guardrail type that doesn't exist yet",
+                    "someNewField": "someValue",
+                    "action": {"$actionType": "block", "reason": "Test reason"},
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.guardrails is not None
+        assert len(config.guardrails) == 1
+
+        unknown_guardrail = config.guardrails[0]
+        assert isinstance(unknown_guardrail, AgentUnknownGuardrail)
+        assert unknown_guardrail.guardrail_type == "unknown"
+        assert unknown_guardrail.raw["$guardrailType"] == "futureGuardrailType"
+        assert unknown_guardrail.raw["name"] == "Future Guardrail"
+        assert unknown_guardrail.raw["someNewField"] == "someValue"
+
+    def test_agent_with_unknown_action_type(self):
+        """Test that AgentDefinition handles unknown action types gracefully"""
+
+        json_data = {
+            "id": "test-unknown-action",
+            "name": "Agent with Unknown Action",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "guardrails": [
+                {
+                    "$guardrailType": "custom",
+                    "id": "custom-guardrail-with-unknown-action",
+                    "name": "Custom Guardrail",
+                    "description": "Custom guardrail with unknown action",
+                    "rules": [{"$ruleType": "always", "applyTo": "inputAndOutput"}],
+                    "action": {
+                        "$actionType": "futureActionType",
+                        "someParameter": "someValue",
+                        "anotherParameter": 123,
+                    },
+                    "enabledForEvals": True,
+                    "selector": {"scopes": ["Agent"]},
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.guardrails is not None
+        assert len(config.guardrails) == 1
+
+        custom_guardrail = config.guardrails[0]
+        assert isinstance(custom_guardrail, AgentCustomGuardrail)
+        assert custom_guardrail.guardrail_type == "custom"
+
+        action = custom_guardrail.action
+        assert isinstance(action, AgentGuardrailUnknownAction)
+        assert action.action_type == AgentGuardrailActionType.UNKNOWN
+        assert action.details is not None
+        assert action.details["$actionType"] == "futureActionType"
+        assert action.details["someParameter"] == "someValue"
+        assert action.details["anotherParameter"] == 123
+
+    def test_agent_with_unknown_context_retrieval_mode(self):
+        """Test that AgentDefinition handles unknown context retrieval modes gracefully"""
+
+        json_data = {
+            "id": "test-unknown-retrieval-mode",
+            "name": "Agent with Unknown Retrieval Mode",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "context",
+                    "folderPath": "TestFolder",
+                    "indexName": "Test Index",
+                    "settings": {
+                        "threshold": 0.5,
+                        "resultCount": 5,
+                        "retrievalMode": "FutureRetrievalMode",
+                        "query": {"description": "Test query", "variant": "Dynamic"},
+                    },
+                    "name": "Test Context",
+                    "description": "Context with unknown retrieval mode",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert len(config.resources) == 1
+
+        context_resource = config.resources[0]
+        assert isinstance(context_resource, AgentContextResourceConfig)
+        assert context_resource.resource_type == AgentResourceType.CONTEXT
+        assert context_resource.settings is not None
+        assert (
+            context_resource.settings.retrieval_mode
+            == AgentContextRetrievalMode.UNKNOWN
+        )
+
+    def test_context_settings_variant_case_insensitive(self):
+        """Test that context query setting variant handles different casings."""
+
+        json_data = {
+            "id": "test-variant-case",
+            "name": "Agent with mixed-case variants",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "context",
+                    "folderPath": "TestFolder",
+                    "indexName": "Test Index",
+                    "settings": {
+                        "threshold": 0.5,
+                        "resultCount": 5,
+                        "retrievalMode": "semantic",
+                        "query": {
+                            "value": "{{searchQuery}}",
+                            "variant": "Argument",
+                        },
+                        "folderPathPrefix": {
+                            "variant": "Static",
+                            "value": "/docs",
+                        },
+                    },
+                    "name": "Test Context",
+                    "description": "Context with mixed-case variants",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        context_resource = config.resources[0]
+        assert isinstance(context_resource, AgentContextResourceConfig)
+        assert context_resource.settings is not None
+        assert (
+            context_resource.settings.query.variant
+            == AgentToolArgumentPropertiesVariant.ARGUMENT
+        )
+        assert context_resource.settings.folder_path_prefix is not None
+        assert (
+            context_resource.settings.folder_path_prefix.variant
+            == AgentToolArgumentPropertiesVariant.STATIC
+        )
+
+    def test_agent_with_unknown_resource_type(self):
+        """Test that AgentDefinition handles unknown resource types gracefully"""
+
+        json_data = {
+            "id": "test-unknown-resource",
+            "name": "Agent with Unknown Resource",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "futureResourceType",
+                    "name": "Future Resource",
+                    "description": "A resource type that doesn't exist yet",
+                    "someNewField": "someValue",
+                    "anotherField": {"nested": "data"},
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert len(config.resources) == 1
+
+        unknown_resource = config.resources[0]
+        assert isinstance(unknown_resource, AgentUnknownResourceConfig)
+        assert unknown_resource.resource_type == AgentResourceType.UNKNOWN
+        assert unknown_resource.name == "Future Resource"
+        assert unknown_resource.description == "A resource type that doesn't exist yet"
+
+    def test_agent_with_unknown_tool_type(self):
+        """Test that AgentDefinition handles unknown tool types gracefully"""
+
+        json_data = {
+            "id": "test-unknown-tool",
+            "name": "Agent with Unknown Tool",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "FutureToolType",
+                    "name": "Future Tool",
+                    "description": "A tool type that doesn't exist yet",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "someNewToolField": "someValue",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert len(config.resources) == 1
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentUnknownToolResourceConfig)
+        assert tool_resource.resource_type == AgentResourceType.TOOL
+        assert tool_resource.type == AgentToolType.UNKNOWN
+        assert tool_resource.name == "Future Tool"
+        assert tool_resource.description == "A tool type that doesn't exist yet"
+
+    def test_agent_with_mixed_known_and_unknown_types(self):
+        """Test that AgentDefinition handles a mix of known and unknown types"""
+
+        json_data = {
+            "id": "test-mixed-types",
+            "name": "Agent with Mixed Types",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "type": "Agent",
+                    "name": "Valid Agent Tool",
+                    "description": "A valid agent tool",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {},
+                    "properties": {
+                        "processName": "TestAgent",
+                        "folderPath": "TestFolder",
+                    },
+                },
+                {
+                    "$resourceType": "tool",
+                    "type": "UnknownToolType",
+                    "name": "Unknown Tool",
+                    "description": "An unknown tool type",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                },
+                {
+                    "$resourceType": "context",
+                    "folderPath": "TestFolder",
+                    "indexName": "Test Index",
+                    "settings": {
+                        "threshold": 0,
+                        "resultCount": 3,
+                        "retrievalMode": "Semantic",
+                    },
+                    "name": "Valid Context",
+                    "description": "A valid context resource",
+                },
+                {
+                    "$resourceType": "unknownResourceType",
+                    "name": "Unknown Resource",
+                    "description": "An unknown resource type",
+                },
+            ],
+            "guardrails": [
+                {
+                    "$guardrailType": "custom",
+                    "id": "valid-custom",
+                    "name": "Valid Custom Guardrail",
+                    "description": "A valid custom guardrail",
+                    "rules": [{"$ruleType": "always", "applyTo": "inputAndOutput"}],
+                    "action": {"$actionType": "block", "reason": "Test reason"},
+                    "enabledForEvals": True,
+                    "selector": {"scopes": ["Agent"]},
+                },
+                {
+                    "$guardrailType": "unknownGuardrailType",
+                    "id": "unknown-guardrail",
+                    "name": "Unknown Guardrail",
+                    "description": "An unknown guardrail type",
+                },
+                {
+                    "$guardrailType": "builtInValidator",
+                    "id": "valid-builtin",
+                    "name": "Valid Built-in Guardrail",
+                    "description": "A valid built-in guardrail",
+                    "validatorType": "pii_detection",
+                    "validatorParameters": [],
+                    "action": {
+                        "$actionType": "unknownActionType",
+                        "someParameter": "value",
+                    },
+                    "enabledForEvals": True,
+                    "selector": {"scopes": ["Agent"]},
+                },
+            ],
+            "messages": [{"role": "system", "content": "Test system message"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate resources
+        assert len(config.resources) == 4
+
+        # First resource should be a valid agent tool
+        assert isinstance(config.resources[0], AgentProcessToolResourceConfig)
+        assert config.resources[0].type == AgentToolType.AGENT
+
+        # Second resource should be unknown tool
+        assert isinstance(config.resources[1], AgentUnknownToolResourceConfig)
+        assert config.resources[1].type == AgentToolType.UNKNOWN
+
+        # Third resource should be valid context
+        assert isinstance(config.resources[2], AgentContextResourceConfig)
+        assert config.resources[2].resource_type == AgentResourceType.CONTEXT
+
+        # Fourth resource should be unknown resource
+        assert isinstance(config.resources[3], AgentUnknownResourceConfig)
+        assert config.resources[3].resource_type == AgentResourceType.UNKNOWN
+
+        # Validate guardrails
+        assert config.guardrails is not None
+        assert len(config.guardrails) == 3
+
+        # First guardrail should be valid custom
+        assert isinstance(config.guardrails[0], AgentCustomGuardrail)
+        assert config.guardrails[0].guardrail_type == "custom"
+        assert isinstance(config.guardrails[0].action, AgentGuardrailBlockAction)
+
+        # Second guardrail should be unknown
+        assert isinstance(config.guardrails[1], AgentUnknownGuardrail)
+        assert config.guardrails[1].guardrail_type == "unknown"
+
+        # Third guardrail should be valid built-in with unknown action
+        assert isinstance(config.guardrails[2], AgentBuiltInValidatorGuardrail)
+        assert config.guardrails[2].guardrail_type == "builtInValidator"
+        assert isinstance(config.guardrails[2].action, AgentGuardrailUnknownAction)
+        assert (
+            config.guardrails[2].action.action_type == AgentGuardrailActionType.UNKNOWN
+        )
+
+    def test_mcp_resource_with_output_schema(self):
+        """Test that AgentDefinition can load MCP resources with outputSchema in tools"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "test-mcp-output-schema",
+            "name": "Agent with MCP Output Schema",
+            "metadata": {"isConversational": False, "storageVersion": "36.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."}
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "mcp",
+                    "folderPath": "solution_folder",
+                    "slug": "tavily-mcp",
+                    "availableTools": [
+                        {
+                            "name": "tavily-search",
+                            "description": "Search the web using Tavily API",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "query": {
+                                        "type": "string",
+                                        "description": "Search query",
+                                    }
+                                },
+                                "required": ["query"],
+                            },
+                            "outputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "results": {
+                                        "type": "array",
+                                        "description": "Search results",
+                                    }
+                                },
+                                "required": ["results"],
+                            },
+                        },
+                        {
+                            "name": "tavily-extract",
+                            "description": "Extract content from URLs",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "urls": {
+                                        "type": "array",
+                                        "description": "URLs to extract",
+                                    }
+                                },
+                                "required": ["urls"],
+                            },
+                            "outputSchema": {
+                                "type": "object",
+                                "properties": {"content": {"type": "string"}},
+                            },
+                        },
+                    ],
+                    "name": "tavily",
+                    "description": "Tavily search and extraction tools",
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+            "guardrails": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate MCP resource with outputSchema
+        mcp_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.MCP
+        ]
+        assert len(mcp_resources) == 1
+        mcp_resource = mcp_resources[0]
+        assert isinstance(mcp_resource, AgentMcpResourceConfig)
+        assert mcp_resource.name == "tavily"
+        assert mcp_resource.slug == "tavily-mcp"
+        assert mcp_resource.description == "Tavily search and extraction tools"
+        assert mcp_resource.is_enabled is True
+        assert len(mcp_resource.available_tools) == 2
+
+        # Validate first tool with outputSchema
+        tool1 = mcp_resource.available_tools[0]
+        assert tool1.name == "tavily-search"
+        assert tool1.description == "Search the web using Tavily API"
+        assert tool1.input_schema is not None
+        assert tool1.output_schema is not None
+        assert "results" in tool1.output_schema["properties"]
+        assert tool1.output_schema["required"] == ["results"]
+
+        # Validate second tool with outputSchema
+        tool2 = mcp_resource.available_tools[1]
+        assert tool2.name == "tavily-extract"
+        assert tool2.output_schema is not None
+        assert "content" in tool2.output_schema["properties"]
+
+    def test_cached_tools_config_refresh_schema_default(self):
+        """CachedToolsConfig defaults refresh_schema_before_call to True."""
+
+        config = CachedToolsConfig()
+        assert config.type == "cached"
+        assert config.refresh_schema_before_call is True
+
+    def test_cached_tools_config_refresh_schema_alias_roundtrip(self):
+        """refresh_schema_before_call parses from and serializes to refreshSchemaBeforeCall."""
+
+        config = TypeAdapter(CachedToolsConfig).validate_python(
+            {"type": "cached", "refreshSchemaBeforeCall": False}
+        )
+        assert config.refresh_schema_before_call is False
+        assert config.model_dump(by_alias=True)["refreshSchemaBeforeCall"] is False
+
+    def test_mcp_resource_with_cached_tools_configuration(self):
+        """AgentMcpResourceConfig parses a cached toolsConfiguration with the refresh flag."""
+
+        json_data = {
+            "$resourceType": "mcp",
+            "folderPath": "solution_folder",
+            "slug": "tavily-mcp",
+            "name": "tavily",
+            "description": "Tavily search tools",
+            "isEnabled": True,
+            "availableTools": [
+                {
+                    "name": "tavily-search",
+                    "description": "Search the web",
+                    "inputSchema": {"type": "object", "properties": {}},
+                }
+            ],
+            "toolsConfiguration": {
+                "discoveryMode": {
+                    "type": "cached",
+                    "refreshSchemaBeforeCall": False,
+                }
+            },
+        }
+
+        mcp_resource = TypeAdapter(AgentMcpResourceConfig).validate_python(json_data)
+        assert mcp_resource.tools_configuration is not None
+        discovery_mode = mcp_resource.tools_configuration.discovery_mode
+        assert isinstance(discovery_mode, CachedToolsConfig)
+        assert discovery_mode.refresh_schema_before_call is False
+
+    @pytest.mark.parametrize(
+        "recipient_type_int,value,expected_type",
+        [
+            (1, "user-123", AgentEscalationRecipientType.USER_ID),
+            (2, "group-456", AgentEscalationRecipientType.GROUP_ID),
+            (3, "user@example.com", AgentEscalationRecipientType.USER_EMAIL),
+            (5, "Test Group", AgentEscalationRecipientType.GROUP_NAME),
+        ],
+    )
+    def test_escalation_standard_recipient_type_normalization(
+        self, recipient_type_int, value, expected_type
+    ):
+        """Test that escalation recipient types are normalized from integers to enum strings."""
+
+        json_data = {
+            "id": "test-recipient-normalization",
+            "name": "Agent with Integer Recipient Types",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "name": "Test Channel",
+                            "description": "Test escalation channel",
+                            "type": "ActionCenter",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "properties": {
+                                "appName": "TestApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder",
+                                "resourceKey": "test-key",
+                            },
+                            "recipients": [
+                                {"type": recipient_type_int, "value": value},
+                            ],
+                        }
+                    ],
+                    "name": "Test Escalation",
+                    "description": "Test escalation with integer recipient types",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentEscalationResourceConfig)
+        assert len(escalation.channels) == 1
+
+        channel = escalation.channels[0]
+        assert len(channel.recipients) == 1
+
+        assert isinstance(channel.recipients[0], StandardRecipient)
+
+        # Verify integer types were normalized to enum strings
+        assert channel.recipients[0].type == expected_type
+        assert channel.recipients[0].value == value
+
+    @pytest.mark.parametrize(
+        "recipient_type_int,asset_name,folder_path,expected_type",
+        [
+            (4, "email_asset", "Shared", AgentEscalationRecipientType.ASSET_USER_EMAIL),
+            (6, "group_asset", "Shared", AgentEscalationRecipientType.ASSET_GROUP_NAME),
+        ],
+    )
+    def test_escalation_asset_recipient_type_normalization_from_int(
+        self, recipient_type_int, asset_name, folder_path, expected_type
+    ):
+        """Test that escalation asset recipient types are normalized from integers to enum strings."""
+
+        json_data = {
+            "id": "test-asset-recipient",
+            "name": "Agent with Asset Recipient",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "name": "Test Channel",
+                            "description": "Test escalation channel",
+                            "type": "ActionCenter",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "properties": {
+                                "appName": "TestApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder",
+                                "resourceKey": "test-key",
+                            },
+                            "recipients": [
+                                {
+                                    "type": recipient_type_int,
+                                    "assetName": asset_name,
+                                    "folderPath": folder_path,
+                                }
+                            ],
+                        }
+                    ],
+                    "name": "Test Escalation",
+                    "description": "Test escalation with asset recipient",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentEscalationResourceConfig)
+
+        channel = escalation.channels[0]
+
+        recipient = channel.recipients[0]
+        assert isinstance(recipient, AssetRecipient)
+
+        # Verify integer types were normalized to enum strings
+        assert recipient.type == expected_type
+        assert recipient.asset_name == asset_name
+        assert recipient.folder_path == folder_path
+
+    @pytest.mark.parametrize(
+        "recipient_type_int,value,expected_type",
+        [
+            (1, "user-123", AgentEscalationRecipientType.USER_ID),
+            (2, "group-456", AgentEscalationRecipientType.GROUP_ID),
+            (3, "user@example.com", AgentEscalationRecipientType.USER_EMAIL),
+            (5, "Test Group", AgentEscalationRecipientType.GROUP_NAME),
+        ],
+    )
+    def test_standard_recipient_discrimination(
+        self, recipient_type_int, value, expected_type
+    ):
+        """Test that StandardRecipient is correctly discriminated."""
+
+        json_data = {
+            "id": "test-standard-recipient",
+            "name": "Agent with Standard Recipients",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "name": "Test Channel",
+                            "description": "Test",
+                            "type": "ActionCenter",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "properties": {
+                                "appName": "TestApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder",
+                                "resourceKey": "test-key",
+                            },
+                            "recipients": [
+                                {
+                                    "type": recipient_type_int,
+                                    "value": value,
+                                }
+                            ],
+                        }
+                    ],
+                    "name": "Test Escalation",
+                    "description": "Test",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentEscalationResourceConfig)
+
+        channel = escalation.channels[0]
+
+        # All should be StandardRecipient instances
+        assert isinstance(channel.recipients[0], StandardRecipient)
+        assert channel.recipients[0].type == expected_type
+        assert channel.recipients[0].value == value
+
+    @pytest.mark.parametrize(
+        "recipient_type_int,asset_name,folder_path,expected_type",
+        [
+            (4, "email_asset", "Shared", AgentEscalationRecipientType.ASSET_USER_EMAIL),
+            (6, "group_asset", "Shared", AgentEscalationRecipientType.ASSET_GROUP_NAME),
+        ],
+    )
+    def test_asset_recipient_discrimination(
+        self, recipient_type_int, asset_name, folder_path, expected_type
+    ):
+        """Test that AssetRecipient is correctly discriminated."""
+
+        json_data = {
+            "id": "test-asset-recipient-discrimination",
+            "name": "Agent with Asset Recipient",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "name": "Test Channel",
+                            "description": "Test",
+                            "type": "ActionCenter",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "properties": {
+                                "appName": "TestApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder",
+                                "resourceKey": "test-key",
+                            },
+                            "recipients": [
+                                {
+                                    "type": recipient_type_int,
+                                    "assetName": asset_name,
+                                    "folderPath": folder_path,
+                                }
+                            ],
+                        }
+                    ],
+                    "name": "Test Escalation",
+                    "description": "Test",
+                }
+            ],
+            "messages": [{"role": "system", "content": "Test"}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentEscalationResourceConfig)
+
+        channel = escalation.channels[0]
+
+        recipient = channel.recipients[0]
+        assert isinstance(recipient, AssetRecipient)
+
+        # Should be AssetRecipient instance
+        assert recipient.type == expected_type
+        assert recipient.asset_name == asset_name
+        assert recipient.folder_path == folder_path
+
+    @pytest.mark.parametrize(
+        "recipient_data,expected_type,recipient_class",
+        [
+            (
+                {"type": 1, "value": "user-123"},
+                AgentEscalationRecipientType.USER_ID,
+                StandardRecipient,
+            ),
+            (
+                {"type": 2, "value": "group-456"},
+                AgentEscalationRecipientType.GROUP_ID,
+                StandardRecipient,
+            ),
+            (
+                {"type": 3, "value": "user@example.com"},
+                AgentEscalationRecipientType.USER_EMAIL,
+                StandardRecipient,
+            ),
+            (
+                {"type": 4, "assetName": "EmailAsset", "folderPath": "Shared"},
+                AgentEscalationRecipientType.ASSET_USER_EMAIL,
+                AssetRecipient,
+            ),
+            (
+                {"type": 5, "value": "User Test Group"},
+                AgentEscalationRecipientType.GROUP_NAME,
+                StandardRecipient,
+            ),
+            (
+                {"type": 6, "assetName": "GroupAsset", "folderPath": "Shared"},
+                AgentEscalationRecipientType.ASSET_GROUP_NAME,
+                AssetRecipient,
+            ),
+        ],
+    )
+    def test_direct_recipient_instantiation(
+        self, recipient_data, expected_type, recipient_class
+    ):
+        """Test direct recipient instantiation with integer types.
+
+        Regression test for BeforeValidator on AgentEscalationRecipient working
+        with direct instantiation, not just through AgentDefinition normalization.
+        """
+        recipient: StandardRecipient | AssetRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(recipient_data)
+
+        assert isinstance(recipient, recipient_class)
+        assert recipient.type == expected_type
+
+    def test_agent_with_ixp_extraction_tool(self):
+        """Test agent with IXP extraction tool resource"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000005",
+            "name": "Agent with IXP Extraction Tool",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "id": "43931770-a441-48f7-894d-0792bf45f6b9",
+                    "name": "document_extraction",
+                    "description": "Extract data from input files",
+                    "location": "external",
+                    "type": "ixp",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "attachment": {
+                                "description": "file to extract the data from",
+                                "$ref": "#/definitions/job-attachment",
+                            }
+                        },
+                        "required": ["attachment"],
+                        "definitions": {
+                            "job-attachment": {
+                                "type": "object",
+                                "required": ["ID"],
+                                "x-uipath-resource-kind": "JobAttachment",
+                                "properties": {
+                                    "ID": {
+                                        "type": "string",
+                                        "description": "Orchestrator attachment key",
+                                    },
+                                    "FullName": {
+                                        "type": "string",
+                                        "description": "File name",
+                                    },
+                                    "MimeType": {
+                                        "type": "string",
+                                        "description": 'The MIME type of the content, such as "application/json" or "image/png"',
+                                    },
+                                    "Metadata": {
+                                        "type": "object",
+                                        "description": "Dictionary<string, string> of metadata",
+                                        "additionalProperties": {"type": "string"},
+                                    },
+                                },
+                            }
+                        },
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "settings": {},
+                    "properties": {
+                        "projectName": "extraction-project",
+                        "versionTag": "latest",
+                    },
+                    "guardrail": {"policies": []},
+                    "isEnabled": True,
+                    "argumentProperties": {},
+                }
+            ],
+            "features": [],
+        }
+
+        # Test deserialization
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate agent
+        assert config.id == "aaaaaaaa-0000-0000-0000-000000000005"
+        assert config.name == "Agent with IXP Extraction Tool"
+        assert len(config.resources) == 1
+
+        # Validate IXP extraction tool
+        tool = config.resources[0]
+        assert isinstance(tool, AgentIxpExtractionResourceConfig)
+        assert tool.resource_type == AgentResourceType.TOOL
+        assert tool.type == AgentToolType.IXP
+        assert tool.name == "document_extraction"
+        assert tool.description == "Extract data from input files"
+
+        # Validate tool properties
+        assert tool.properties.project_name == "extraction-project"
+        assert tool.properties.version_tag == "latest"
+
+        # Validate input schema with definitions
+        assert tool.input_schema is not None
+        assert tool.input_schema["type"] == "object"
+        assert "properties" in tool.input_schema
+        assert "attachment" in tool.input_schema["properties"]
+        assert tool.input_schema["required"] == ["attachment"]
+        assert "definitions" in tool.input_schema
+        assert "job-attachment" in tool.input_schema["definitions"]
+
+        # Validate job-attachment definition
+        job_attachment_def = tool.input_schema["definitions"]["job-attachment"]
+        assert job_attachment_def["type"] == "object"
+        assert job_attachment_def["required"] == ["ID"]
+        assert job_attachment_def["x-uipath-resource-kind"] == "JobAttachment"
+        assert "ID" in job_attachment_def["properties"]
+        assert "FullName" in job_attachment_def["properties"]
+        assert "MimeType" in job_attachment_def["properties"]
+        assert "Metadata" in job_attachment_def["properties"]
+
+        # Validate output schema
+        assert tool.output_schema is not None
+        assert tool.output_schema["type"] == "object"
+        assert tool.output_schema["properties"] == {}
+
+        # Validate settings
+        assert tool.settings is not None
+
+    def test_agent_with_ixp_vs_escalation(self):
+        """Test agent with IXP VS escalation resource"""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000006",
+            "name": "Agent with IXP VS Escalation",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "id": "b445425d-302c-4f37-9236-c6d44ef25dea",
+                    "name": "IxpEscalation",
+                    "description": "IXP VS escalation channel",
+                    "channels": [
+                        {
+                            "id": "640f5f8f-dc9c-4a2f-8c3b-493f93545adb",
+                            "name": "Channel",
+                            "description": "Channel description",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "inputSchemaDotnetTypeMapping": None,
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "outputSchemaDotnetTypeMapping": None,
+                            "outcomeMapping": None,
+                            "recipients": [],
+                            "type": "actionCenter",
+                            "properties": {
+                                "appName": None,
+                                "appVersion": 1,
+                                "folderName": None,
+                                "resourceKey": None,
+                                "isActionableMessageEnabled": False,
+                                "actionableMessageMetaData": None,
+                            },
+                        }
+                    ],
+                    "isAgentMemoryEnabled": False,
+                    "governanceProperties": {"isEscalatedAtRuntime": False},
+                    "escalationType": 1,
+                    "vsEscalationProperties": {
+                        "ixpToolId": "some_tool_id",
+                        "storageBucketName": "some_storage_bucket_name",
+                        "storageBucketFolderPath": "solution_folder",
+                    },
+                    "properties": {},
+                }
+            ],
+            "features": [],
+        }
+
+        # Test deserialization
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate agent
+        assert config.id == "aaaaaaaa-0000-0000-0000-000000000006"
+        assert config.name == "Agent with IXP VS Escalation"
+        assert len(config.resources) == 1
+
+        # Validate IXP VS escalation resource
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentIxpVsEscalationResourceConfig)
+        assert escalation.resource_type == AgentResourceType.ESCALATION
+        assert escalation.escalation_type == 1
+        assert escalation.name == "IxpEscalation"
+        assert escalation.description == "IXP VS escalation channel"
+        assert escalation.is_agent_memory_enabled is False
+
+        # Validate VS escalation properties
+        assert escalation.vs_escalation_properties.ixp_tool_id == "some_tool_id"
+        assert (
+            escalation.vs_escalation_properties.storage_bucket_name
+            == "some_storage_bucket_name"
+        )
+        assert (
+            escalation.vs_escalation_properties.storage_bucket_folder_path
+            == "solution_folder"
+        )
+
+        # Validate channels
+        assert len(escalation.channels) == 1
+        channel = escalation.channels[0]
+        assert channel.name == "Channel"
+        assert channel.description == "Channel description"
+        assert channel.type == "actionCenter"
+        assert len(channel.recipients) == 0
+
+        # Validate channel properties
+        assert isinstance(channel, AgentEscalationChannel)
+        assert channel.properties.app_name is None
+        assert channel.properties.app_version == 1
+        assert channel.properties.folder_name is None
+        assert channel.properties.resource_key is None
+
+    def test_quick_form_channel_properties_derive_schema_id_from_body(self):
+        """schema_id reads the schemaId nested inside the schema body."""
+
+        props = AgentQuickFormChannelProperties.model_validate(
+            {
+                "schema": {
+                    "schemaId": "e74ebb74-80ba-47b9-a370-532a1ba4c41e",
+                    "fields": [],
+                    "outcomes": [],
+                },
+            }
+        )
+        assert props.schema_id == "e74ebb74-80ba-47b9-a370-532a1ba4c41e"
+
+    def test_quick_form_channel_properties_schema_id_none_when_absent(self):
+        """schema_id is None when the schema body carries no schemaId."""
+
+        props = AgentQuickFormChannelProperties.model_validate(
+            {"schema": {"fields": [], "outcomes": []}}
+        )
+        assert props.schema_id is None
+
+    def test_quick_form_channel_properties_require_schema(self):
+        with pytest.raises(ValidationError):
+            AgentQuickFormChannelProperties.model_validate(
+                {"isActionableMessageEnabled": False}
+            )
+
+    def test_quick_form_channel_requires_schema(self):
+        """A quick-form channel without a schema fails to parse."""
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationResourceConfig).validate_python(
+                {
+                    "$resourceType": "escalation",
+                    "name": "Escalation",
+                    "description": "",
+                    "channels": [
+                        {
+                            "name": "c",
+                            "description": "",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "type": "actionCenterQuickForm",
+                            "recipients": [],
+                            "properties": {"isActionableMessageEnabled": False},
+                        }
+                    ],
+                    "isAgentMemoryEnabled": False,
+                }
+            )
+
+    def test_unknown_escalation_channel_type_is_rejected(self):
+        """An unrecognized channel type fails to parse; the runtime cannot handle it."""
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationResourceConfig).validate_python(
+                {
+                    "$resourceType": "escalation",
+                    "name": "Escalation",
+                    "description": "",
+                    "channels": [
+                        {
+                            "name": "c",
+                            "description": "",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "type": "someFutureChannel",
+                            "recipients": [],
+                            "properties": {},
+                        }
+                    ],
+                    "isAgentMemoryEnabled": False,
+                }
+            )
+
+    def test_task_title_text_builder_type(self):
+        """Test TextBuilderTaskTitle with tokens."""
+        from uipath.agent.models.agent import (
+            TaskTitleType,
+            TextBuilderTaskTitle,
+            TextTokenType,
+        )
+
+        task_title = TextBuilderTaskTitle(
+            type=TaskTitleType.TEXT_BUILDER,
+            tokens=[
+                TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Approve "),
+                TextToken(type=TextTokenType.VARIABLE, raw_string="requestType"),
+            ],
+        )
+
+        assert task_title.type == TaskTitleType.TEXT_BUILDER
+        assert len(task_title.tokens) == 2
+        assert task_title.tokens[0].type == TextTokenType.SIMPLE_TEXT
+
+    def test_task_title_dynamic_type(self):
+        """Test DynamicTaskTitle with argument path."""
+        from uipath.agent.models.agent import DynamicTaskTitle, TaskTitleType
+
+        task_title = DynamicTaskTitle(
+            type=TaskTitleType.DYNAMIC, argument_path="input.title"
+        )
+
+        assert task_title.type == TaskTitleType.DYNAMIC
+        assert task_title.argument_path == "input.title"
+
+    def test_escalation_channel_uses_task_title_v2_when_present(self):
+        """Test that taskTitleV2 with TEXT_BUILDER is used when present."""
+
+        channel_data = {
+            "name": "test_channel",
+            "type": "actionCenter",
+            "description": "Test channel",
+            "inputSchema": {"type": "object"},
+            "outputSchema": {"type": "object"},
+            "properties": {
+                "appName": "TestApp",
+                "appVersion": 1,
+                "resourceKey": "test-key",
+            },
+            "recipients": [],
+            "taskTitleV2": {
+                "type": "textBuilder",
+                "tokens": [{"type": "simpleText", "rawString": "Test Task"}],
+            },
+        }
+
+        channel = AgentEscalationChannel(**channel_data)  # type: ignore[arg-type]
+
+        assert isinstance(channel.task_title, dict) or hasattr(
+            channel.task_title, "tokens"
+        )
+
+    def test_escalation_channel_uses_legacy_task_title(self):
+        """Test that legacy taskTitle string is preserved."""
+
+        channel_data = {
+            "name": "test_channel",
+            "type": "actionCenter",
+            "description": "Test channel",
+            "inputSchema": {"type": "object"},
+            "outputSchema": {"type": "object"},
+            "properties": {
+                "appName": "TestApp",
+                "appVersion": 1,
+                "resourceKey": "test-key",
+            },
+            "recipients": [],
+            "taskTitle": "Legacy Task Title",
+        }
+
+        channel = AgentEscalationChannel(**channel_data)  # type: ignore[arg-type]
+
+        assert channel.task_title == "Legacy Task Title"
+
+    def test_escalation_channel_defaults_to_escalation_task(self):
+        """Test that taskTitle defaults to 'Escalation Task' when not provided."""
+
+        channel_data = {
+            "name": "test_channel",
+            "type": "actionCenter",
+            "description": "Test channel",
+            "inputSchema": {"type": "object"},
+            "outputSchema": {"type": "object"},
+            "properties": {
+                "appName": "TestApp",
+                "appVersion": 1,
+                "resourceKey": "test-key",
+            },
+            "recipients": [],
+        }
+
+        channel = AgentEscalationChannel(**channel_data)  # type: ignore[arg-type]
+
+        assert channel.task_title == "Escalation Task"
+
+    def test_case_insensitive_enums(self):
+        """Test that enums with alternative casings are deserialized correctly."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "e0f589ff-469a-44b3-8c5f-085826d8fa55",
+            "name": "Packaged Agent",
+            "metadata": {"isConversational": False, "storageVersion": "22.0.0"},
+            "messages": [
+                {
+                    "role": "System",
+                    "content": "You are an agentic assistant.",
+                    "contentTokens": [
+                        {
+                            "type": "SimpleText",
+                            "rawString": "You are an agentic assistant.",
+                        }
+                    ],
+                },
+                {
+                    "role": "User",
+                    "content": "Use the provided tools. Execute {{task}} the number of {{times}}.",
+                    "contentTokens": [
+                        {
+                            "type": "SimpleText",
+                            "rawString": "Use the provided tools. Execute ",
+                        },
+                        {
+                            "type": "Variable",
+                            "rawString": "input.task",
+                        },
+                        {
+                            "type": "SimpleText",
+                            "rawString": " the number of ",
+                        },
+                        {
+                            "type": "Variable",
+                            "rawString": "input.times",
+                        },
+                        {
+                            "type": "SimpleText",
+                            "rawString": ".",
+                        },
+                    ],
+                },
+            ],
+            "inputSchema": {
+                "type": "object",
+                "required": ["task"],
+                "properties": {"task": {"type": "string"}, "times": {"type": "number"}},
+            },
+            "outputSchema": {
+                "type": "object",
+                "properties": {
+                    "task_summary": {
+                        "type": "string",
+                        "description": "describe the actions you have taken in a concise step by step summary",
+                    }
+                },
+                "title": "Outputs",
+                "required": ["task_summary"],
+            },
+            "settings": {
+                "model": "gpt-5-2025-08-07",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+                "byomProperties": {
+                    "connectionId": "test-byom-connection-id",
+                    "connectorKey": "uipath-openai-openai",
+                },
+            },
+            "resources": [
+                {
+                    "$resourceType": "Escalation",
+                    "id": "be506447-2cf1-47e6-a124-2930e6f0f3d8",
+                    "channels": [
+                        {
+                            "name": "Channel",
+                            "description": "Channel description",
+                            "type": "ActionCenter",
+                            "inputSchema": {
+                                "type": "object",
+                                "properties": {
+                                    "AgentName": {"type": "string"},
+                                    "Statement": {"type": "string"},
+                                },
+                                "required": ["AgentName", "Statement"],
+                            },
+                            "outputSchema": {
+                                "type": "object",
+                                "properties": {"Reason": {"type": "string"}},
+                            },
+                            "outcomeMapping": {
+                                "Approve": "continue",
+                                "Reject": "continue",
+                            },
+                            "properties": {
+                                "appName": "AgentQuestionApp",
+                                "appVersion": 1,
+                                "folderName": "TestFolder/Complete Solution 30 Sept",
+                                "resourceKey": "b2ecb40b-dcce-4f71-96ae-8fa895905ae2",
+                                "isActionableMessageEnabled": True,
+                                "actionableMessageMetaData": {
+                                    "fieldSet": {
+                                        "type": "fieldSet",
+                                        "id": "3705cfbb-d1fb-4567-b1dd-036107c5c084",
+                                        "fields": [
+                                            {
+                                                "id": "AgentName",
+                                                "name": "AgentName",
+                                                "type": "Fact",
+                                                "placeHolderText": "",
+                                            },
+                                            {
+                                                "id": "Statement",
+                                                "name": "Statement",
+                                                "type": "Fact",
+                                                "placeHolderText": "",
+                                            },
+                                            {
+                                                "id": "Reason",
+                                                "name": "Reason",
+                                                "type": "Input.Text",
+                                                "placeHolderText": "",
+                                            },
+                                        ],
+                                    },
+                                    "actionSet": {
+                                        "type": "actionSet",
+                                        "id": "9ecd2de3-7ac3-47a6-836c-af1eaf67f9ca",
+                                        "actions": [
+                                            {
+                                                "id": "Approve",
+                                                "name": "Approve",
+                                                "title": "Approve",
+                                                "type": "Action.Http",
+                                                "isPrimary": True,
+                                            },
+                                            {
+                                                "id": "Reject",
+                                                "name": "Reject",
+                                                "title": "Reject",
+                                                "type": "Action.Http",
+                                                "isPrimary": True,
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                            "recipients": [
+                                {
+                                    "value": "a26a9809-69ee-427a-9f05-ba00623fef80",
+                                    "type": "userid",
+                                }
+                            ],
+                            "taskTitle": "Test Task",
+                            "taskTitleV2": {
+                                "type": "TextBuilder",
+                                "tokens": [
+                                    {
+                                        "type": "SimpleText",
+                                        "rawString": "Test Task",
+                                    }
+                                ],
+                            },
+                            "priority": "Medium",
+                            "labels": ["new", "stuff"],
+                        }
+                    ],
+                    "isAgentMemoryEnabled": True,
+                    "escalationType": 0,
+                    "name": "Human in the Loop App",
+                    "description": "an app for the agent to ask questions for the human",
+                },
+                {
+                    "$resourceType": "Context",
+                    "folderPath": "TestFolder",
+                    "indexName": "MCP Documentation Index",
+                    "settings": {
+                        "threshold": 0,
+                        "resultCount": 3,
+                        "retrievalMode": "semantic",
+                        "query": {
+                            "description": "The query for the Semantic strategy.",
+                            "variant": "dynamic",
+                        },
+                        "folderPathPrefix": {},
+                        "fileExtension": {"value": "All"},
+                    },
+                    "name": "MCP Documentation Index",
+                    "description": "",
+                },
+                {
+                    "$resourceType": "Tool",
+                    "type": "Api",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "To": {"type": "string", "title": "To"},
+                            "Subject": {"type": "string", "title": "Subject"},
+                        },
+                        "required": ["To"],
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "argumentProperties": {
+                        "To": {
+                            "variant": "Static",
+                            "isSensitive": False,
+                            "value": "test@example.com",
+                        },
+                        "Subject": {
+                            "variant": "TextBuilder",
+                            "isSensitive": False,
+                            "tokens": [{"type": "SimpleText", "rawString": "Hello"}],
+                        },
+                    },
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolPath": "/SendEmail",
+                        "objectName": "SendEmail",
+                        "toolDisplayName": "Send Email",
+                        "toolDescription": "Sends an email message",
+                        "method": "POST",
+                        "bodyStructure": {
+                            "contentType": "multipart",
+                            "jsonBodySection": "body",
+                        },
+                        "connection": {
+                            "id": "cccccccc-0000-0000-0000-000000000004",
+                            "name": "Gmail Connection",
+                            "elementInstanceId": 0,
+                            "apiBaseUri": "",
+                            "state": "enabled",
+                            "isDefault": False,
+                            "connector": {
+                                "key": "uipath-google-gmail",
+                                "name": "Gmail",
+                                "enabled": True,
+                            },
+                            "folder": {"key": "bbbbbbbb-0000-0000-0000-000000000004"},
+                            "solutionProperties": {
+                                "resourceKey": "cccccccc-0000-0000-0000-000000000004"
+                            },
+                        },
+                        "parameters": [
+                            {
+                                "name": "To",
+                                "displayName": "To",
+                                "type": "string",
+                                "fieldLocation": "body",
+                                "value": "{{prompt}}",
+                                "fieldVariant": "Dynamic",
+                                "sortOrder": 1,
+                                "required": True,
+                            },
+                        ],
+                    },
+                    "name": "Send Email",
+                    "description": "Send an email via Gmail",
+                    "isEnabled": True,
+                },
+                {
+                    "$resourceType": "Tool",
+                    "type": "Internal",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {},
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolType": "Deep-Rag",
+                        "settings": {
+                            "contextType": "dataService",
+                            "query": {"value": "test query", "variant": "static"},
+                            "citationMode": {"value": "inline"},
+                            "fileExtension": {"value": "PDF"},
+                        },
+                    },
+                    "argumentProperties": {},
+                    "name": "Deep RAG Tool",
+                    "description": "Test deep rag tool",
+                    "isEnabled": True,
+                },
+                {
+                    "$resourceType": "Tool",
+                    "type": "Internal",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {},
+                    },
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "arguments": {},
+                    "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                    "properties": {
+                        "toolType": "batch-transform",
+                        "settings": {
+                            "contextType": "dataService",
+                            "query": {"value": "batch query", "variant": "static"},
+                            "fileExtension": {"value": "CSV"},
+                            "outputColumns": [
+                                {
+                                    "name": "output1",
+                                    "description": "Test output",
+                                    "required": True,
+                                }
+                            ],
+                            "webSearchGrounding": {"value": "enabled"},
+                        },
+                    },
+                    "argumentProperties": {},
+                    "name": "Batch Transform Tool",
+                    "description": "Test batch transform tool",
+                    "isEnabled": True,
+                },
+            ],
+            "guardrails": [
+                {
+                    "$guardrailType": "custom",
+                    "id": "test-guardrail-1",
+                    "name": "Test Custom Guardrail",
+                    "description": "Test guardrail with various operators",
+                    "selector": {"$selectorType": "universal"},
+                    "rules": [
+                        {
+                            "$ruleType": "word",
+                            "fieldSelector": {"$selectorType": "all"},
+                            "operator": "DoesNotContain",
+                            "value": "forbidden",
+                        },
+                        {
+                            "$ruleType": "number",
+                            "fieldSelector": {"$selectorType": "all"},
+                            "operator": "GreaterThan",
+                            "value": 10,
+                        },
+                        {
+                            "$ruleType": "boolean",
+                            "fieldSelector": {"$selectorType": "all"},
+                            "operator": "Equals",
+                            "value": True,
+                        },
+                    ],
+                    "action": {
+                        "$actionType": "Block",
+                        "reason": "Guardrail triggered",
+                    },
+                },
+                {
+                    "$guardrailType": "custom",
+                    "id": "test-guardrail-2",
+                    "name": "Log Guardrail",
+                    "description": "Test log action with severity",
+                    "selector": {"$selectorType": "universal"},
+                    "rules": [
+                        {
+                            "$ruleType": "word",
+                            "fieldSelector": {"$selectorType": "all"},
+                            "operator": "contains",
+                            "value": "test",
+                        }
+                    ],
+                    "action": {
+                        "$actionType": "log",
+                        "message": "Test log message",
+                        "severityLevel": "Warning",
+                    },
+                },
+            ],
+            "features": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.messages[0].role == AgentMessageRole.SYSTEM
+        assert config.messages[1].role == AgentMessageRole.USER
+
+        escalation = config.resources[0]
+        assert isinstance(escalation, AgentEscalationResourceConfig)
+        assert escalation.resource_type == AgentResourceType.ESCALATION
+        channel = escalation.channels[0]
+        assert channel.recipients[0].type == AgentEscalationRecipientType.USER_ID
+        assert isinstance(channel.task_title, TextBuilderTaskTitle)
+        assert channel.task_title.type == TaskTitleType.TEXT_BUILDER
+        assert channel.task_title.tokens[0].type == TextTokenType.SIMPLE_TEXT
+
+        context = config.resources[1]
+        assert isinstance(context, AgentContextResourceConfig)
+        assert context.resource_type == AgentResourceType.CONTEXT
+        assert context.settings is not None
+        assert context.settings.retrieval_mode == AgentContextRetrievalMode.SEMANTIC
+        assert context.settings.query is not None
+        assert (
+            context.settings.query.variant == AgentToolArgumentPropertiesVariant.DYNAMIC
+        )
+
+        api_tool = config.resources[2]
+        assert isinstance(api_tool, AgentProcessToolResourceConfig)
+        assert api_tool.type == AgentToolType.API
+        assert (
+            api_tool.argument_properties["To"].variant
+            == AgentToolArgumentPropertiesVariant.STATIC
+        )
+        assert (
+            api_tool.argument_properties["Subject"].variant
+            == AgentToolArgumentPropertiesVariant.TEXT_BUILDER
+        )
+
+        deep_rag_tool = config.resources[3]
+        assert isinstance(deep_rag_tool, AgentInternalToolResourceConfig)
+        assert isinstance(deep_rag_tool.properties, AgentInternalDeepRagToolProperties)
+        assert deep_rag_tool.properties.tool_type == AgentInternalToolType.DEEP_RAG
+        assert (
+            deep_rag_tool.properties.settings.citation_mode.value == CitationMode.INLINE
+        )
+        assert (
+            deep_rag_tool.properties.settings.file_extension.value
+            == DeepRagFileExtension.PDF
+        )
+
+        batch_tool = config.resources[4]
+        assert isinstance(batch_tool, AgentInternalToolResourceConfig)
+        assert isinstance(
+            batch_tool.properties, AgentInternalBatchTransformToolProperties
+        )
+        assert (
+            batch_tool.properties.settings.file_extension.value
+            == BatchTransformFileExtension.CSV
+        )
+
+        assert (
+            batch_tool.properties.settings.web_search_grounding.value
+            == BatchTransformWebSearchGrounding.ENABLED
+        )
+
+        assert config.guardrails is not None
+        custom_guardrail = config.guardrails[0]
+        assert isinstance(custom_guardrail, AgentCustomGuardrail)
+
+        word_rule = custom_guardrail.rules[0]
+        assert isinstance(word_rule, AgentWordRule)
+        assert word_rule.operator == AgentWordOperator.DOES_NOT_CONTAIN
+
+        number_rule = custom_guardrail.rules[1]
+        assert isinstance(number_rule, AgentNumberRule)
+        assert number_rule.operator == AgentNumberOperator.GREATER_THAN
+
+        boolean_rule = custom_guardrail.rules[2]
+        assert isinstance(boolean_rule, AgentBooleanRule)
+        assert boolean_rule.operator == AgentBooleanOperator.EQUALS
+
+        assert custom_guardrail.action.action_type == AgentGuardrailActionType.BLOCK
+
+        log_guardrail = config.guardrails[1]
+        assert isinstance(log_guardrail, AgentCustomGuardrail)
+        log_action = log_guardrail.action
+        assert isinstance(log_action, AgentGuardrailLogAction)
+        assert log_action.severity_level == AgentGuardrailSeverityLevel.WARNING
+
+
+class TestAgentDefinitionIsConversational:
+    """Tests for AgentDefinition.is_conversational property."""
+
+    def test_is_conversational_true_when_metadata_set(self):
+        """Returns True when metadata.is_conversational is True."""
+        json_data = {
+            "id": "test-conversational",
+            "name": "Conversational Agent",
+            "version": "1.0.0",
+            "metadata": {"isConversational": True, "storageVersion": "1.0.0"},
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0.7,
+                "engine": "conversational-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [
+                {"role": "system", "content": "You are a conversational agent."}
+            ],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_conversational is True
+
+    def test_is_conversational_false_when_metadata_set_false(self):
+        """Returns False when metadata.is_conversational is False."""
+        json_data = {
+            "id": "test-non-conversational",
+            "name": "Non-Conversational Agent",
+            "version": "1.0.0",
+            "metadata": {"isConversational": False, "storageVersion": "1.0.0"},
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "You are an agent."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_conversational is False
+
+    def test_is_conversational_false_when_no_metadata(self):
+        """Returns False when agent has no metadata."""
+        json_data = {
+            "id": "test-no-metadata",
+            "name": "Agent Without Metadata",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "You are an agent."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.metadata is None
+        assert config.is_conversational is False
+
+    def test_is_conversational_false_by_default(self):
+        """Default agent definition returns False."""
+        # Minimal agent definition without conversational settings
+        json_data = {
+            "id": "test-default",
+            "name": "Default Agent",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "Default system prompt."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_conversational is False
+
+
+class TestAgentDefinitionIsCaseManager:
+    """Tests for AgentDefinition.is_case_manager property."""
+
+    def test_is_case_manager_true_when_variant_is_case_manager(self):
+        """Returns True when metadata.variant is "caseManager"."""
+        json_data = {
+            "id": "test-case-manager",
+            "name": "Case Manager Agent",
+            "version": "1.0.0",
+            "metadata": {
+                "isConversational": False,
+                "variant": "caseManager",
+                "storageVersion": "1.0.0",
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [
+                {"role": "system", "content": "You are a case manager agent."}
+            ],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_case_manager is True
+
+    def test_is_case_manager_false_when_variant_is_none(self):
+        """Returns False when metadata.variant is None."""
+        json_data = {
+            "id": "test-non-case-manager",
+            "name": "Regular Agent",
+            "version": "1.0.0",
+            "metadata": {
+                "isConversational": False,
+                "variant": None,
+                "storageVersion": "1.0.0",
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "You are an agent."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_case_manager is False
+
+    def test_is_case_manager_false_when_variant_not_in_metadata(self):
+        """Returns False when variant is not present in metadata."""
+        json_data = {
+            "id": "test-no-variant-field",
+            "name": "Agent Without Variant Field",
+            "version": "1.0.0",
+            "metadata": {"isConversational": False, "storageVersion": "1.0.0"},
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "You are an agent."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_case_manager is False
+
+    def test_is_case_manager_false_when_no_metadata(self):
+        """Returns False when agent has no metadata."""
+        json_data = {
+            "id": "test-no-metadata",
+            "name": "Agent Without Metadata",
+            "version": "1.0.0",
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "resources": [],
+            "messages": [{"role": "system", "content": "You are an agent."}],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.is_case_manager is False
+
+
+class TestAgentBuilderConfigResources:
+    """Tests for AgentDefinition resource configuration parsing."""
+
+    def _agent_dict_with_resources(self, resources: list[Any]) -> dict[str, Any]:
+        """Helper method that returns an agent dict with default fields and provided resources."""
+        return {
+            "version": "1.0.0",
+            "id": "test-agent-id",
+            "name": "Test Agent",
+            "metadata": {"isConversational": False, "storageVersion": "22.0.0"},
+            "messages": [
+                {
+                    "role": "System",
+                    "content": "You are a test agent.",
+                }
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 4096,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "resources": resources,
+        }
+
+    def test_escalation_with_static_group_name_recipient_type(self):
+        """Test that escalation with StaticGroupName recipientType is parsed correctly."""
+        resources = [
+            {
+                "$resourceType": "escalation",
+                "id": "escalation-1",
+                "channels": [
+                    {
+                        "name": "Test Channel",
+                        "description": "Test channel description",
+                        "type": "ActionCenter",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {"field": {"type": "string"}},
+                        },
+                        "outputSchema": {"type": "object", "properties": {}},
+                        "outcomeMapping": {"Approve": "continue"},
+                        "properties": {
+                            "appName": "TestApp",
+                            "appVersion": 1,
+                            "folderName": "TestFolder",
+                            "resourceKey": "test-key",
+                        },
+                        "recipients": [
+                            {
+                                "value": "TestGroup",
+                                "type": "staticgroupname",
+                            }
+                        ],
+                        "taskTitle": "Test Task",
+                        "priority": "Medium",
+                    }
+                ],
+                "isAgentMemoryEnabled": False,
+                "escalationType": 0,
+                "name": "Test Escalation",
+                "description": "Test escalation",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation_resource = config.resources[0]
+        assert isinstance(escalation_resource, AgentEscalationResourceConfig)
+        recipient = escalation_resource.channels[0].recipients[0]
+        assert isinstance(recipient, StandardRecipient)
+        assert recipient.type == AgentEscalationRecipientType.GROUP_NAME
+        assert recipient.value == "TestGroup"
+
+    def test_escalation_with_lowercase_userid_recipient_type(self):
+        """Test that escalation with lowercase userid recipientType is parsed correctly."""
+        resources = [
+            {
+                "$resourceType": "escalation",
+                "id": "escalation-2",
+                "channels": [
+                    {
+                        "name": "Test Channel",
+                        "description": "Test channel description",
+                        "type": "ActionCenter",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {"field": {"type": "string"}},
+                        },
+                        "outputSchema": {"type": "object", "properties": {}},
+                        "outcomeMapping": {"Approve": "continue"},
+                        "properties": {
+                            "appName": "TestApp",
+                            "appVersion": 1,
+                            "folderName": "TestFolder",
+                            "resourceKey": "test-key",
+                        },
+                        "recipients": [
+                            {
+                                "value": "user-123",
+                                "type": "userid",
+                            }
+                        ],
+                        "taskTitle": "Test Task",
+                        "priority": "Medium",
+                    }
+                ],
+                "isAgentMemoryEnabled": False,
+                "escalationType": 0,
+                "name": "Test Escalation",
+                "description": "Test escalation",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation_resource = config.resources[0]
+        assert isinstance(escalation_resource, AgentEscalationResourceConfig)
+        recipient = escalation_resource.channels[0].recipients[0]
+        assert isinstance(recipient, StandardRecipient)
+        assert recipient.type == AgentEscalationRecipientType.USER_ID
+        assert recipient.value == "user-123"
+
+    def test_process_tool_missing_output_schema(self):
+        """Test that process tool without outputSchema is parsed correctly."""
+        resources = [
+            {
+                "$resourceType": "tool",
+                "type": "ProcessOrchestration",
+                "id": "process-tool-1",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"input": {"type": "string"}},
+                },
+                "arguments": {},
+                "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                "properties": {
+                    "processName": "TestProcess",
+                    "folderPath": "TestFolder",
+                },
+                "name": "Test Process",
+                "description": "Test process tool",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig)
+        assert tool_resource.output_schema == {"type": "object", "properties": {}}
+
+    def test_flow_tool_type_enum_value(self):
+        """AgentToolType.FLOW exists with the wire value 'Flow' and is case-insensitive."""
+        assert AgentToolType.FLOW.value == "Flow"
+        assert AgentToolType("flow") is AgentToolType.FLOW
+        assert AgentToolType("FLOW") is AgentToolType.FLOW
+
+    def test_flow_tool_resource_deserialization(self):
+        """A resource with type='Flow' is parsed as AgentProcessToolResourceConfig."""
+        resources = [
+            {
+                "$resourceType": "tool",
+                "type": "Flow",
+                "id": "flow-tool-1",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"input": {"type": "string"}},
+                },
+                "outputSchema": {"type": "object", "properties": {}},
+                "arguments": {},
+                "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                "properties": {
+                    "processName": "MyFlow",
+                    "folderPath": "/Shared/Flows",
+                },
+                "name": "Flow Tool",
+                "description": "Test Flow tool",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig)
+        assert tool_resource.type == AgentToolType.FLOW
+        assert tool_resource.properties.process_name == "MyFlow"
+        assert tool_resource.properties.folder_path == "/Shared/Flows"
+
+    def test_flow_tool_resource_case_insensitive(self):
+        """A resource with lowercase type='flow' also deserializes via CaseInsensitiveEnum."""
+        resources = [
+            {
+                "$resourceType": "tool",
+                "type": "flow",
+                "id": "flow-tool-2",
+                "inputSchema": {"type": "object", "properties": {}},
+                "outputSchema": {"type": "object", "properties": {}},
+                "arguments": {},
+                "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                "properties": {
+                    "processName": "MyFlow",
+                    "folderPath": "/Shared/Flows",
+                },
+                "name": "Flow Tool",
+                "description": "Test Flow tool",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig)
+        assert tool_resource.type == AgentToolType.FLOW
+
+    def test_function_tool_type_enum_value(self):
+        """AgentToolType.FUNCTION exists with the wire value 'Function' and is case-insensitive."""
+        assert AgentToolType.FUNCTION.value == "Function"
+        assert AgentToolType("function") is AgentToolType.FUNCTION
+        assert AgentToolType("FUNCTION") is AgentToolType.FUNCTION
+
+    def test_function_tool_resource_deserialization(self):
+        """A resource with type='Function' is parsed as AgentProcessToolResourceConfig."""
+        resources = [
+            {
+                "$resourceType": "tool",
+                "type": "Function",
+                "id": "function-tool-1",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"input": {"type": "string"}},
+                },
+                "outputSchema": {"type": "object", "properties": {}},
+                "arguments": {},
+                "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                "properties": {
+                    "processName": "MyFunction",
+                    "folderPath": "/Shared/Functions",
+                },
+                "name": "Function Tool",
+                "description": "Test Function tool",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig)
+        assert tool_resource.type == AgentToolType.FUNCTION
+        assert tool_resource.properties.process_name == "MyFunction"
+        assert tool_resource.properties.folder_path == "/Shared/Functions"
+
+    def test_function_tool_resource_case_insensitive(self):
+        """A resource with lowercase type='function' also deserializes via CaseInsensitiveEnum."""
+        resources = [
+            {
+                "$resourceType": "tool",
+                "type": "function",
+                "id": "function-tool-2",
+                "inputSchema": {"type": "object", "properties": {}},
+                "outputSchema": {"type": "object", "properties": {}},
+                "arguments": {},
+                "settings": {"timeout": 0, "maxAttempts": 0, "retryDelay": 0},
+                "properties": {
+                    "processName": "MyFunction",
+                    "folderPath": "/Shared/Functions",
+                },
+                "name": "Function Tool",
+                "description": "Test Function tool",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool_resource = config.resources[0]
+        assert isinstance(tool_resource, AgentProcessToolResourceConfig)
+        assert tool_resource.type == AgentToolType.FUNCTION
+
+    def test_escalation_missing_escalation_type_defaults_to_zero(self):
+        """Test that missing escalationType defaults to 0."""
+        resources = [
+            {
+                "$resourceType": "escalation",
+                "id": "escalation-3",
+                "channels": [
+                    {
+                        "name": "Test Channel",
+                        "description": "Test channel description",
+                        "type": "ActionCenter",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {"field": {"type": "string"}},
+                        },
+                        "outputSchema": {"type": "object", "properties": {}},
+                        "outcomeMapping": {"Approve": "continue"},
+                        "properties": {
+                            "appName": "TestApp",
+                            "appVersion": 1,
+                            "folderName": "TestFolder",
+                            "resourceKey": "test-key",
+                        },
+                        "recipients": [
+                            {
+                                "value": "user-123",
+                                "type": "UserId",
+                            }
+                        ],
+                        "taskTitle": "Test Task",
+                        "priority": "Medium",
+                    }
+                ],
+                "isAgentMemoryEnabled": False,
+                "name": "Test Escalation",
+                "description": "Test escalation",
+            }
+        ]
+
+        json_data = self._agent_dict_with_resources(resources)
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        escalation_resource = config.resources[0]
+        assert isinstance(escalation_resource, AgentEscalationResourceConfig)
+        assert escalation_resource.escalation_type == 0
+
+
+class TestDataFabricContextConfig:
+    """Tests for Data Fabric context resource configuration."""
+
+    def test_datafabric_context_config_parses(self):
+        """Test v48 format with contextType and entitySet."""
+        config = {
+            "$resourceType": "context",
+            "name": "TestDataFabric",
+            "description": "",
+            "contextType": "datafabricentityset",
+            "entitySet": [
+                {
+                    "id": "abc-123",
+                    "name": "Customers",
+                    "folderId": "folder-1",
+                    "description": "Customer records",
+                },
+                {
+                    "id": "def-456",
+                    "referenceKey": "orders-ref",
+                    "name": "Orders",
+                    "folderId": "folder-2",
+                    "description": None,
+                },
+            ],
+        }
+
+        parsed = AgentContextResourceConfig.model_validate(config)
+
+        assert parsed.context_type == AgentContextType.DATA_FABRIC_ENTITY_SET
+        assert parsed.folder_path is None
+        assert parsed.index_name is None
+        assert parsed.settings is None
+        assert parsed.entity_set is not None
+        assert len(parsed.entity_set) == 2
+        assert parsed.entity_set[0].id == "abc-123"
+        assert parsed.entity_set[0].name == "Customers"
+        assert parsed.entity_set[0].folder_key == "folder-1"
+        assert parsed.entity_set[0].description == "Customer records"
+        assert parsed.entity_set[0].entity_key is None
+        assert parsed.entity_set[1].entity_key == "orders-ref"
+        assert parsed.entity_set[1].description is None
+
+    def test_is_datafabric(self):
+        """Test is_datafabric property with datafabricentityset contextType."""
+        config = {
+            "$resourceType": "context",
+            "name": "Test",
+            "description": "",
+            "contextType": "datafabricentityset",
+            "entitySet": [
+                {"id": "abc-123", "name": "E", "folderId": "", "description": None}
+            ],
+        }
+        parsed = AgentContextResourceConfig.model_validate(config)
+        assert parsed.is_datafabric is True
+
+    def test_is_datafabric_false_for_semantic(self):
+        """Test is_datafabric is False for Semantic contexts."""
+        config = {
+            "$resourceType": "context",
+            "name": "Test",
+            "description": "",
+            "folderPath": "Shared",
+            "indexName": "my-index",
+            "settings": {"retrievalMode": "Semantic", "resultCount": 5},
+        }
+        parsed = AgentContextResourceConfig.model_validate(config)
+        assert parsed.is_datafabric is False
+
+    def test_datafabric_entity_identifiers(self):
+        """Test entity identifiers extracted from entitySet."""
+        config = {
+            "$resourceType": "context",
+            "name": "Test",
+            "description": "",
+            "contextType": "datafabricentityset",
+            "entitySet": [
+                {"id": "id-1", "name": "E1", "folderId": "", "description": None},
+                {"id": "id-2", "name": "E2", "folderId": "", "description": None},
+            ],
+        }
+        parsed = AgentContextResourceConfig.model_validate(config)
+        assert parsed.datafabric_entity_identifiers == ["id-1", "id-2"]
+
+    def test_datafabric_entity_identifiers_empty(self):
+        """Test empty entity identifiers when no entitySet provided."""
+        config = {
+            "$resourceType": "context",
+            "name": "Test",
+            "description": "",
+            "contextType": "datafabricentityset",
+        }
+        parsed = AgentContextResourceConfig.model_validate(config)
+        assert parsed.datafabric_entity_identifiers == []
+
+    def test_a2a_resource(self):
+        """Test that AgentDefinition can load A2A resources."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "test-a2a-resource",
+            "name": "Agent with A2A Resource",
+            "metadata": {"isConversational": False, "storageVersion": "36.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."}
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "a2a",
+                    "id": "755e2f7d-5a3d-47f3-8e9d-7ff0bf226357",
+                    "name": "Philosopher Agent",
+                    "slug": "philosopher-agent",
+                    "description": "A philosophical agent that answers questions with wisdom and philosopher quotes",
+                    "folderPath": "shared",
+                    "cachedAgentCard": {
+                        "name": "Philosopher Agent",
+                        "description": "Philosopher Agent assistant",
+                        "url": "https://philosopher-agent.example.com/a2a/5045dca3",
+                        "supportedInterfaces": [
+                            {
+                                "url": "https://philosopher-agent.example.com/a2a/5045dca3",
+                                "protocolBinding": "jsonrpc",
+                                "protocolVersion": "1.0",
+                            }
+                        ],
+                        "capabilities": {
+                            "streaming": True,
+                            "pushNotifications": False,
+                            "stateTransitionHistory": False,
+                        },
+                        "defaultInputModes": [
+                            "application/json",
+                            "text/plain",
+                        ],
+                        "defaultOutputModes": [
+                            "application/json",
+                            "text/plain",
+                        ],
+                        "skills": [
+                            {
+                                "id": "5045dca3-main",
+                                "name": "Philosopher Agent Capabilities",
+                                "description": "Philosopher Agent assistant",
+                                "tags": ["assistant", "langgraph"],
+                                "examples": [],
+                                "inputModes": [
+                                    "application/json",
+                                    "text/plain",
+                                ],
+                                "outputModes": [
+                                    "application/json",
+                                    "text/plain",
+                                ],
+                                "metadata": {
+                                    "inputSchema": {
+                                        "required": ["messages"],
+                                        "properties": ["messages"],
+                                        "supportsA2A": True,
+                                    }
+                                },
+                            }
+                        ],
+                        "version": "0.7.70",
+                    },
+                }
+            ],
+            "features": [],
+            "guardrails": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        # Validate A2A resource
+        a2a_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.A2A
+        ]
+        assert len(a2a_resources) == 1
+        a2a_resource = a2a_resources[0]
+        assert isinstance(a2a_resource, AgentA2aResourceConfig)
+        assert a2a_resource.name == "Philosopher Agent"
+        assert a2a_resource.slug == "philosopher-agent"
+        assert (
+            a2a_resource.description
+            == "A philosophical agent that answers questions with wisdom and philosopher quotes"
+        )
+        assert a2a_resource.id == "755e2f7d-5a3d-47f3-8e9d-7ff0bf226357"
+        assert a2a_resource.folder_path == "shared"
+
+        # Validate cached agent card is a plain dict
+        card = a2a_resource.cached_agent_card
+        assert isinstance(card, dict)
+        assert card["name"] == "Philosopher Agent"
+        assert card["url"] == "https://philosopher-agent.example.com/a2a/5045dca3"
+        assert card["version"] == "0.7.70"
+        assert len(card["supportedInterfaces"]) == 1
+        assert card["supportedInterfaces"][0]["protocolBinding"] == "jsonrpc"
+        assert card["capabilities"]["streaming"] is True
+        assert len(card["skills"]) == 1
+        assert card["skills"][0]["name"] == "Philosopher Agent Capabilities"
+
+    def test_a2a_resource_without_cached_card(self):
+        """Test A2A resource with no cachedAgentCard."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "test-a2a-no-card",
+            "name": "Agent with minimal A2A",
+            "metadata": {"isConversational": False, "storageVersion": "36.0.0"},
+            "messages": [{"role": "System", "content": "You are an assistant."}],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "a2a",
+                    "id": "abc-123",
+                    "name": "Minimal A2A Agent",
+                    "slug": "minimal-a2a",
+                    "description": "A minimal A2A agent",
+                    "folderPath": "shared",
+                }
+            ],
+            "features": [],
+            "guardrails": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        a2a_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.A2A
+        ]
+        assert len(a2a_resources) == 1
+        a2a_resource = a2a_resources[0]
+        assert isinstance(a2a_resource, AgentA2aResourceConfig)
+        assert a2a_resource.name == "Minimal A2A Agent"
+        assert a2a_resource.slug == "minimal-a2a"
+        assert a2a_resource.folder_path == "shared"
+        assert a2a_resource.cached_agent_card is None
+
+    def test_a2a_resource_case_insensitive(self):
+        """Test that A2A resource type is parsed case-insensitively."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "test-a2a-case",
+            "name": "Agent A2A case test",
+            "metadata": {"isConversational": False, "storageVersion": "36.0.0"},
+            "messages": [{"role": "System", "content": "You are an assistant."}],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {"type": "object", "properties": {}},
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "A2A",
+                    "id": "case-test-id",
+                    "name": "Case Test Agent",
+                    "slug": "case-test",
+                    "description": "Testing case insensitive parsing",
+                    "folderPath": "shared",
+                }
+            ],
+            "features": [],
+            "guardrails": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        a2a_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.A2A
+        ]
+        assert len(a2a_resources) == 1
+        assert isinstance(a2a_resources[0], AgentA2aResourceConfig)
+
+
+class TestArgumentRecipientDeserialization:
+    def test_argument_email_recipient_by_type_int(self):
+        payload = {"type": 7, "argumentName": "assigneeEmail"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ArgumentEmailRecipient)
+        assert recipient.argument_path == "assigneeEmail"
+        assert recipient.type == AgentEscalationRecipientType.ARGUMENT_EMAIL
+
+    def test_argument_group_name_recipient_by_type_int(self):
+        payload = {"type": 8, "argumentName": "assigneeGroup"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ArgumentGroupNameRecipient)
+        assert recipient.argument_path == "assigneeGroup"
+        assert recipient.type == AgentEscalationRecipientType.ARGUMENT_GROUP_NAME
+
+    def test_argument_email_recipient_by_type_string(self):
+        payload = {"type": "ArgumentEmail", "argumentName": "emailArg"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ArgumentEmailRecipient)
+        assert recipient.argument_path == "emailArg"
+
+    def test_argument_group_name_recipient_by_type_string(self):
+        payload = {"type": "ArgumentGroupName", "argumentName": "groupArg"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ArgumentGroupNameRecipient)
+        assert recipient.argument_path == "groupArg"
+
+    def test_argument_email_recipient_missing_argument_name_raises(self):
+        payload = {"type": 7}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_argument_group_name_recipient_missing_argument_name_raises(self):
+        payload = {"type": 8}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_agent_with_client_side_tool(self):
+        """Test agent with ClientSide tool resource."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000010",
+            "name": "Agent with ClientSide Tool",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "id": "cst-0001-0000-0000-000000000001",
+                    "name": "browser_navigate",
+                    "description": "Navigate to a URL in the browser",
+                    "location": "external",
+                    "type": "ClientSide",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "url": {
+                                "type": "string",
+                                "description": "The URL to navigate to",
+                            }
+                        },
+                        "required": ["url"],
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "title": {"type": "string"},
+                            "content": {"type": "string"},
+                        },
+                    },
+                    "arguments": {"timeout": 30},
+                    "properties": {},
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        assert config.name == "Agent with ClientSide Tool"
+        assert len(config.resources) == 1
+
+        tool = config.resources[0]
+        assert isinstance(tool, AgentClientSideToolResourceConfig)
+        assert tool.resource_type == AgentResourceType.TOOL
+        assert tool.type == AgentToolType.CLIENT_SIDE
+        assert tool.name == "browser_navigate"
+        assert tool.description == "Navigate to a URL in the browser"
+
+        # Validate input schema
+        assert tool.input_schema["type"] == "object"
+        assert "url" in tool.input_schema["properties"]
+        assert tool.input_schema["required"] == ["url"]
+
+        # Validate outputSchema alias deserializes to output_schema
+        assert tool.output_schema is not None
+        assert tool.output_schema["type"] == "object"
+        assert "title" in tool.output_schema["properties"]
+        assert "content" in tool.output_schema["properties"]
+
+        # Validate arguments
+        assert tool.arguments == {"timeout": 30}
+
+    def test_agent_with_client_side_tool_lowercase_type(self):
+        """Test that _normalize_resources handles lowercase 'clientside' type."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000011",
+            "name": "Agent with clientside Tool",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "id": "cst-0002-0000-0000-000000000001",
+                    "name": "clipboard_copy",
+                    "description": "Copy text to clipboard",
+                    "location": "external",
+                    "type": "clientside",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "text": {"type": "string"},
+                        },
+                    },
+                    "properties": {},
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool = config.resources[0]
+        assert isinstance(tool, AgentClientSideToolResourceConfig)
+        assert tool.type == AgentToolType.CLIENT_SIDE
+        assert tool.name == "clipboard_copy"
+
+        # output_schema and arguments should default
+        assert tool.output_schema is None
+        assert tool.arguments == {}
+
+    def test_agent_with_client_side_tool_output_schema_alias(self):
+        """Test that the outputSchema alias correctly maps to output_schema."""
+
+        json_data = {
+            "version": "1.0.0",
+            "id": "aaaaaaaa-0000-0000-0000-000000000012",
+            "name": "Agent with ClientSide outputSchema alias",
+            "metadata": {"isConversational": False, "storageVersion": "26.0.0"},
+            "messages": [
+                {"role": "System", "content": "You are an agentic assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v2",
+            },
+            "resources": [
+                {
+                    "$resourceType": "tool",
+                    "id": "cst-0003-0000-0000-000000000001",
+                    "name": "screen_capture",
+                    "description": "Capture a screenshot",
+                    "location": "external",
+                    "type": "ClientSide",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "region": {"type": "string"},
+                        },
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "imageBase64": {
+                                "type": "string",
+                                "description": "Base64-encoded image",
+                            }
+                        },
+                        "required": ["imageBase64"],
+                    },
+                    "properties": {},
+                    "isEnabled": True,
+                }
+            ],
+            "features": [],
+        }
+
+        config: AgentDefinition = TypeAdapter(AgentDefinition).validate_python(
+            json_data
+        )
+
+        tool = config.resources[0]
+        assert isinstance(tool, AgentClientSideToolResourceConfig)
+
+        # Access via Python attribute name (snake_case)
+        assert tool.output_schema is not None
+        assert tool.output_schema["type"] == "object"
+        assert "imageBase64" in tool.output_schema["properties"]
+        assert tool.output_schema["required"] == ["imageBase64"]
+
+
+class TestCustomAssignmentRecipientDeserialization:
+    def test_workload_recipient_by_type_int(self):
+        payload = {"type": 9, "value": "group-1", "displayName": "Support Team"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, WorkloadRecipient)
+        assert recipient.value == "group-1"
+        assert recipient.display_name == "Support Team"
+        assert recipient.type == AgentEscalationRecipientType.WORKLOAD
+
+    def test_workload_recipient_by_type_string(self):
+        payload = {
+            "type": "Workload",
+            "value": "group-1",
+            "displayName": "Support Team",
+        }
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, WorkloadRecipient)
+        assert recipient.value == "group-1"
+        assert recipient.display_name == "Support Team"
+
+    def test_round_robin_recipient_by_type_int(self):
+        payload = {"type": 10, "value": "group-1", "displayName": "Support Team"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, RoundRobinRecipient)
+        assert recipient.value == "group-1"
+        assert recipient.display_name == "Support Team"
+        assert recipient.type == AgentEscalationRecipientType.ROUND_ROBIN
+
+    def test_round_robin_recipient_by_type_string(self):
+        payload = {
+            "type": "RoundRobin",
+            "value": "group-1",
+            "displayName": "Support Team",
+        }
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, RoundRobinRecipient)
+
+    def test_custom_assignees_recipient_by_type_int(self):
+        payload = {
+            "type": 11,
+            "value": "alice@example.com",
+            "displayName": "Alice",
+        }
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, CustomAssigneesRecipient)
+        assert recipient.value == "alice@example.com"
+        assert recipient.display_name == "Alice"
+        assert recipient.type == AgentEscalationRecipientType.CUSTOM_ASSIGNEES
+
+    def test_custom_assignees_recipient_by_type_string(self):
+        payload = {"type": "CustomAssignees", "value": "alice@example.com"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, CustomAssigneesRecipient)
+        assert recipient.value == "alice@example.com"
+        assert recipient.display_name is None
+
+    def test_custom_assignees_recipient_accepts_empty_value_sentinel(self):
+        payload = {"type": 11, "value": ""}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, CustomAssigneesRecipient)
+        assert recipient.value == ""
+
+    def test_workload_recipient_missing_value_raises(self):
+        payload = {"type": 9, "displayName": "Support Team"}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_workload_recipient_missing_display_name_raises(self):
+        payload = {"type": 9, "value": "group-1"}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_round_robin_recipient_missing_value_raises(self):
+        payload = {"type": 10, "displayName": "Support Team"}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_custom_assignees_recipient_missing_value_raises(self):
+        payload = {"type": 11}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+
+class TestToolOutputRecipientDeserialization:
+    @pytest.mark.parametrize(
+        "recipient_type",
+        [1, 2, 9, 10, 11],
+    )
+    def test_tool_output_recipient_by_type_int_for_supported_types(
+        self, recipient_type
+    ):
+        payload = {
+            "type": recipient_type,
+            "source": "toolOutput",
+            "toolName": "API workflow A",
+            "outputPath": "includeEmails",
+        }
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ToolOutputRecipient)
+        assert recipient.tool_name == "API workflow A"
+        assert recipient.output_path == "includeEmails"
+        assert recipient.source == "toolOutput"
+
+    def test_tool_output_recipient_for_custom_assignees_by_type_string(self):
+        payload = {
+            "type": "CustomAssignees",
+            "source": "toolOutput",
+            "toolName": "API workflow A",
+            "outputPath": "includeEmails",
+        }
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, ToolOutputRecipient)
+        assert recipient.type == AgentEscalationRecipientType.CUSTOM_ASSIGNEES
+
+    def test_tool_output_recipient_missing_tool_name_raises(self):
+        payload = {"type": 11, "source": "toolOutput", "outputPath": "emails"}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_tool_output_recipient_missing_output_path_raises(self):
+        payload = {"type": 11, "source": "toolOutput", "toolName": "A"}
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_tool_output_recipient_unknown_source_raises(self):
+        payload = {
+            "type": 11,
+            "source": "magicBox",
+            "toolName": "A",
+            "outputPath": "emails",
+        }
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    @pytest.mark.parametrize(
+        "recipient_type",
+        [3, 4, 5, 6, 7, 8],
+    )
+    def test_tool_output_recipient_not_allowed_for_static_asset_argument_types(
+        self, recipient_type
+    ):
+        # Static/asset/argument types (3, 4, 5, 6, 7, 8) are not supported
+        # for tool-output binding because they have their own design-time
+        # resolution rules.
+        payload = {
+            "type": recipient_type,
+            "source": "toolOutput",
+            "toolName": "A",
+            "outputPath": "emails",
+        }
+        with pytest.raises(ValidationError):
+            TypeAdapter(AgentEscalationRecipient).validate_python(payload)
+
+    def test_literal_recipient_without_source_still_parses_to_literal_class(self):
+        # Backward compat: a payload without `source` still matches the literal class.
+        payload = {"type": 11, "value": "alice@example.com", "displayName": "Alice"}
+        recipient: AgentEscalationRecipient = TypeAdapter(
+            AgentEscalationRecipient
+        ).validate_python(payload)
+        assert isinstance(recipient, CustomAssigneesRecipient)
+        assert not isinstance(recipient, ToolOutputRecipient)
diff --git a/packages/uipath/tests/agent/models/test_evals.py b/packages/uipath/tests/agent/models/test_evals.py
new file mode 100644
index 000000000..4f93511c3
--- /dev/null
+++ b/packages/uipath/tests/agent/models/test_evals.py
@@ -0,0 +1,523 @@
+from pydantic import TypeAdapter
+
+from uipath.agent.models.agent import AgentResourceType, AgentUnknownResourceConfig
+from uipath.agent.models.evals import AgentEvalsDefinition
+
+
+class TestEvalsAgentDefinition:
+    def test_evals_agent_loads_complete_json(self):
+        """Test that EvalsAgentDefinition can load from the complete JSON with evaluators and evaluation sets"""
+
+        json_data = {
+            "features": [],
+            "id": "0e2201f2-b983-42c6-8231-64806c09ae54",
+            "inputSchema": {
+                "properties": {"inputProp": {"type": "string"}},
+                "type": "object",
+            },
+            "messages": [
+                {"content": "You're a helpful agent.", "role": "system"},
+                {
+                    "content": "Use the provided tools. This is the input argument: {{inputProp}}",
+                    "role": "user",
+                },
+            ],
+            "name": "Agent",
+            "outputSchema": {
+                "properties": {
+                    "content": {"description": "Output content", "type": "string"}
+                },
+                "type": "object",
+            },
+            "resources": [
+                {
+                    "$resourceType": "escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "id": "Channel id",
+                            "description": "Channel description",
+                            "inputSchema": {"properties": {}, "type": "object"},
+                            "name": "Channel",
+                            "outcomeMapping": {"Submit": "continue"},
+                            "outputSchema": {
+                                "properties": {
+                                    "Content": {
+                                        "description": "Text content related to the escalation prompt",
+                                        "type": "string",
+                                    }
+                                },
+                                "required": ["Content"],
+                                "type": "object",
+                            },
+                            "properties": {
+                                "appName": "Untitled",
+                                "appVersion": 1,
+                                "folderName": None,
+                                "resourceKey": "c0aa40e2-9f14-4cea-83f9-c874e229986f",
+                            },
+                            "recipients": [
+                                {
+                                    "type": "UserId",
+                                    "value": "e314e6a1-2499-4ff4-af0b-bb81dc29a6ec",
+                                }
+                            ],
+                            "type": "ActionCenter",
+                        }
+                    ],
+                    "description": '"escalation prompt"',
+                    "id": "2841bace-fa75-4503-9ff0-dff2c1f68750",
+                    "isAgentMemoryEnabled": False,
+                    "name": "Escalation_1",
+                },
+                {
+                    "$resourceType": "tool",
+                    "arguments": {},
+                    "description": "this is an agent package",
+                    "inputSchema": {"properties": {}, "type": "object"},
+                    "name": "Agent tool",
+                    "outputSchema": {
+                        "properties": {"output": {"type": "string"}},
+                        "type": "object",
+                    },
+                    "properties": {
+                        "folderPath": "Solution Folder",
+                        "processName": "Test-Basic-Agent",
+                    },
+                    "settings": {"maxAttempts": 0, "retryDelay": 0, "timeout": 0},
+                    "type": "Agent",
+                },
+                {
+                    "$resourceType": "tool",
+                    "arguments": {},
+                    "description": "Creates an appointment given: first name, second name, personal unique number, doctor specialist, cabinet number, datetime.\nReturns the appointment ID",
+                    "guardrail": {
+                        "policies": [
+                            {
+                                "action": {
+                                    "$actionType": "log",
+                                    "severityLevel": "Info",
+                                },
+                                "description": "test",
+                                "enabledForEvals": True,
+                                "name": "Guardrail_1",
+                                "rules": [
+                                    {"$ruleType": "always", "applyTo": "InputAndOutput"}
+                                ],
+                            }
+                        ]
+                    },
+                    "inputSchema": {
+                        "properties": {
+                            "cabinet_number": {"type": "integer"},
+                            "datetime": {"type": "string"},
+                            "doctor_specialist": {"type": "string"},
+                            "first_name": {"type": "string"},
+                            "personal_unique_number": {"type": "string"},
+                            "second_name": {"type": "string"},
+                        },
+                        "required": [],
+                        "type": "object",
+                    },
+                    "name": "Process tool with a guardrail",
+                    "outputSchema": {
+                        "properties": {"appointment_id": {"type": "integer"}},
+                        "required": [],
+                        "type": "object",
+                    },
+                    "properties": {
+                        "folderPath": "Solution Folder",
+                        "processName": "Add_Appointment",
+                    },
+                    "settings": {"maxAttempts": 0, "retryDelay": 0, "timeout": 0},
+                    "type": "Process",
+                },
+                {
+                    "$resourceType": "tool",
+                    "arguments": {},
+                    "description": "Extract readable text from a publicly accessible URL and provide it in a structured format.",
+                    "inputSchema": {
+                        "additionalProperties": False,
+                        "properties": {
+                            "provider": {
+                                "description": "The search engine to use.",
+                                "enum": ["Jina"],
+                                "title": "Search Engine",
+                                "type": "string",
+                            },
+                            "url": {
+                                "description": "A publicly accessible URL",
+                                "title": "URL",
+                                "type": "string",
+                            },
+                        },
+                        "required": ["provider", "url"],
+                        "type": "object",
+                    },
+                    "name": "IS tool",
+                    "outputSchema": {"properties": {}, "type": "object"},
+                    "properties": {
+                        "connection": {
+                            "apiBaseUri": "https://alpha.uipath.com/adminstudiotest/cicd/elements_",
+                            "connector": {
+                                "enabled": True,
+                                "image": "https://alpha.uipath.com/elements_/scaleunit_/3854d037-4ab5-4881-909b-968c433f6d88/v3/element/elements/uipath-uipath-airdk/image",
+                                "key": "uipath-uipath-airdk",
+                                "name": "UiPath GenAI Activities",
+                            },
+                            "elementInstanceId": 180169,
+                            "folder": {
+                                "key": "eb6e6ba2-f2ae-4603-b10d-ab101f0ba91f",
+                                "path": "Agents Test",
+                            },
+                            "id": "1c5b8b0a-03ed-4cd2-bfe5-9c3a4341443d",
+                            "isDefault": False,
+                            "name": "andrei.neculaesei@uipath.com #2",
+                            "solutionProperties": {
+                                "folder": {
+                                    "fullyQualifiedName": "Solution Folder",
+                                    "path": "e02827d6-1426-4bfb-13e9-08dd9dd1a5a3",
+                                },
+                                "resourceKey": "449e43cf-4663-4c44-98c3-5e1a52bd36a3",
+                            },
+                            "state": "Enabled",
+                        },
+                        "method": "POST",
+                        "objectName": "v1::webRead",
+                        "parameters": [
+                            {
+                                "description": "The search engine to use.",
+                                "displayName": "Search Engine",
+                                "dynamic": False,
+                                "dynamicBehavior": [],
+                                "enumValues": [{"name": "Jina", "value": "Jina"}],
+                                "fieldLocation": "body",
+                                "fieldVariant": "static",
+                                "loadReferenceOptionsByDefault": None,
+                                "name": "provider",
+                                "position": "primary",
+                                "reference": None,
+                                "required": True,
+                                "sortOrder": 1,
+                                "type": "string",
+                                "value": "Jina",
+                            },
+                            {
+                                "description": "A publicly accessible URL",
+                                "displayName": "URL",
+                                "dynamic": True,
+                                "dynamicBehavior": [],
+                                "enumValues": None,
+                                "fieldLocation": "body",
+                                "fieldVariant": "dynamic",
+                                "loadReferenceOptionsByDefault": None,
+                                "name": "url",
+                                "position": "primary",
+                                "reference": None,
+                                "required": True,
+                                "sortOrder": 2,
+                                "type": "string",
+                            },
+                        ],
+                        "toolDescription": "Extract readable text from a publicly accessible URL and provide it in a structured format.",
+                        "toolDisplayName": "Web Reader",
+                        "toolPath": "/v1/webRead",
+                    },
+                    "settings": {"maxAttempts": 0, "retryDelay": 0, "timeout": 0},
+                    "type": "Integration",
+                },
+                {
+                    "$resourceType": "context",
+                    "description": "",
+                    "folderPath": "Solution Folder",
+                    "indexName": "Medical Index",
+                    "name": "Medical Index Semantic",
+                    "settings": {
+                        "resultCount": 3,
+                        "retrievalMode": "Semantic",
+                        "threshold": 0,
+                    },
+                },
+                {
+                    "$resourceType": "context",
+                    "description": "",
+                    "folderPath": "Solution Folder",
+                    "indexName": "Medical Index",
+                    "name": "Medical Index Structured",
+                    "settings": {
+                        "resultCount": 3,
+                        "retrievalMode": "Structured",
+                        "threshold": 0,
+                    },
+                },
+            ],
+            "settings": {
+                "engine": "basic-v1",
+                "maxTokens": 16384,
+                "model": "gpt-4o-2024-11-20",
+                "temperature": 0,
+            },
+            "evaluators": [
+                {
+                    "fileName": "evaluator-default.json",
+                    "id": "c395579a-4e15-425e-b400-a630a63a6237",
+                    "name": "Default Evaluator",
+                    "description": "An evaluator that uses a LLM to score the similarity of the actual output to the expected output",
+                    "category": 1,
+                    "type": 5,
+                    "prompt": "As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nExpectedOutput:\n{{ExpectedOutput}}\n----\nActualOutput:\n{{ActualOutput}}\n",
+                    "model": "same-as-agent",
+                    "targetOutputKey": "*",
+                    "createdAt": "2025-06-09T18:20:06.080Z",
+                    "updatedAt": "2025-06-09T18:20:06.080Z",
+                },
+                {
+                    "fileName": "evaluator-default-simulation.json",
+                    "id": "3c82e1a2-0112-4e3b-ba45-25f379298faa",
+                    "name": "Default Simulation Evaluator",
+                    "description": "An evaluator that uses a LLM to score the similarity of the actual output to the expected output",
+                    "category": 3,
+                    "type": 7,
+                    "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+                    "model": "same-as-agent",
+                    "targetOutputKey": "*",
+                    "createdAt": "2025-06-09T18:20:06.335Z",
+                    "updatedAt": "2025-06-09T18:20:06.335Z",
+                },
+                {
+                    "fileName": "evaluator-default-trajectory.json",
+                    "id": "a544a330-5e6b-4dca-a4e5-ea5fd024779b",
+                    "name": "Default Trajectory Evaluator",
+                    "description": "An evaluator that judges the agent based on it's run history and expected behavior",
+                    "category": 3,
+                    "type": 7,
+                    "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+                    "model": "same-as-agent",
+                    "targetOutputKey": "*",
+                    "createdAt": "2025-06-26T17:45:39.651Z",
+                    "updatedAt": "2025-06-26T17:45:39.651Z",
+                },
+            ],
+            "evaluationSets": [
+                {
+                    "fileName": "evaluation-set-1757012098378.json",
+                    "id": "d649e632-1582-4cb1-9e68-c3aff46c2802",
+                    "name": "Loan Agent Evaluation Set",
+                    "batchSize": 10,
+                    "evaluatorRefs": [
+                        "c395579a-4e15-425e-b400-a630a63a6237",
+                        "a544a330-5e6b-4dca-a4e5-ea5fd024779b",
+                    ],
+                    "evaluations": [
+                        {
+                            "id": "7309b5dc-46c5-46cb-b6cb-dbb5d9ff5ccf",
+                            "name": "Low Credit Score Rejection",
+                            "inputs": {},
+                            "evaluationCriterias": {
+                                "Default Evaluator": {"content": '"rejected"'}
+                            },
+                            "simulationInstructions": "The A2ALoanCreditRatingTool should return a credit rating of 650.",
+                            "expectedAgentBehavior": "The agent should reject the loan application due to the credit rating being below 700.",
+                            "simulateInput": True,
+                            "inputGenerationInstructions": "Generate a loan application query with name, loan amount, and loan type (mortgage or personal loan).",
+                            "simulateTools": True,
+                            "toolsToSimulate": [
+                                {"name": "A2ALoanCreditRatingTool"},
+                                {"name": "escalate_escalation_1"},
+                            ],
+                            "evalSetId": "7e4a91a3-e387-47c6-b4e2-75cd503a77d3",
+                            "createdAt": "2025-09-04T18:54:58.378Z",
+                            "updatedAt": "2025-09-04T18:55:55.416Z",
+                        },
+                        {
+                            "id": "f8e31cc4-1e70-4043-80df-eac1439f6120",
+                            "name": "High Credit Score Small Loan Approval",
+                            "inputs": {},
+                            "evaluationCriterias": {},
+                            "simulationInstructions": "The A2ALoanCreditRatingTool should return a credit rating of 850.",
+                            "expectedAgentBehavior": "The agent should approve the loan application due to the credit rating being above 800 and the loan amount being less than $10,000.",
+                            "simulateInput": True,
+                            "inputGenerationInstructions": "Generate a loan application query with name, loan amount under $10,000, and loan type (mortgage or personal loan).",
+                            "simulateTools": True,
+                            "toolsToSimulate": [
+                                {"name": "A2ALoanCreditRatingTool"},
+                                {"name": "escalate_escalation_1"},
+                            ],
+                            "evalSetId": "7e4a91a3-e387-47c6-b4e2-75cd503a77d3",
+                            "createdAt": "2025-09-04T18:54:58.378Z",
+                            "updatedAt": "2025-09-04T18:54:58.378Z",
+                        },
+                        {
+                            "id": "73a5dc37-9147-4184-9427-dd7306ed8e71",
+                            "name": "Manual Review Escalation",
+                            "inputs": {},
+                            "evaluationCriterias": {},
+                            "simulationInstructions": "The A2ALoanCreditRatingTool should return a credit rating of 750.",
+                            "expectedAgentBehavior": "The agent should escalate the application for manual review as the credit rating is between 700 and 800.",
+                            "simulateInput": True,
+                            "inputGenerationInstructions": "Generate a loan application query with name, loan amount over $10,000, and loan type (mortgage or personal loan).",
+                            "simulateTools": True,
+                            "toolsToSimulate": [
+                                {"name": "A2ALoanCreditRatingTool"},
+                                {"name": "escalate_escalation_1"},
+                            ],
+                            "evalSetId": "7e4a91a3-e387-47c6-b4e2-75cd503a77d3",
+                            "createdAt": "2025-09-04T18:54:58.378Z",
+                            "updatedAt": "2025-09-04T18:54:58.378Z",
+                        },
+                        {
+                            "id": "5c8f2030-0129-478f-8c56-140c287f22ab",
+                            "name": "Incomplete Application",
+                            "inputs": {},
+                            "evaluationCriterias": {},
+                            "simulationInstructions": "No tool calls should be made.",
+                            "expectedAgentBehavior": "The agent should inform the user that all mandatory details (name, loan amount, and loan type) are required to process the application.",
+                            "simulateInput": True,
+                            "inputGenerationInstructions": "Generate a loan application query missing one of the mandatory details (name, loan amount, or loan type).",
+                            "simulateTools": True,
+                            "toolsToSimulate": [
+                                {"name": "A2ALoanCreditRatingTool"},
+                                {"name": "escalate_escalation_1"},
+                            ],
+                            "evalSetId": "7e4a91a3-e387-47c6-b4e2-75cd503a77d3",
+                            "createdAt": "2025-09-04T18:54:58.378Z",
+                            "updatedAt": "2025-09-04T18:54:58.378Z",
+                        },
+                    ],
+                    "modelSettings": [],
+                    "createdAt": "2025-09-04T18:54:58.379Z",
+                    "updatedAt": "2025-09-04T18:55:55.416Z",
+                },
+                {
+                    "fileName": "evaluation-set-default.json",
+                    "id": "aee3efd3-252a-439b-baf7-565cef3d0ef4",
+                    "name": "Default Evaluation Set",
+                    "batchSize": 10,
+                    "evaluatorRefs": ["c395579a-4e15-425e-b400-a630a63a6237"],
+                    "evaluations": [],
+                    "modelSettings": [],
+                    "createdAt": "2025-06-09T18:20:06.644Z",
+                    "updatedAt": "2025-06-09T18:20:06.644Z",
+                },
+                {
+                    "fileName": "evaluation-set-simulation-default-simulation_set.json",
+                    "id": "f52b67e1-6fe5-4cb6-966a-082f2ccbf0ae",
+                    "name": "Default Simulation Evaluation Set",
+                    "batchSize": 10,
+                    "evaluatorRefs": ["3c82e1a2-0112-4e3b-ba45-25f379298faa"],
+                    "evaluations": [],
+                    "modelSettings": [],
+                    "createdAt": "2025-06-09T18:20:07.045Z",
+                    "updatedAt": "2025-06-09T18:20:07.045Z",
+                },
+            ],
+            "version": "1.0.0",
+        }
+
+        # Test that the model loads without errors
+        config: AgentEvalsDefinition = TypeAdapter(
+            AgentEvalsDefinition
+        ).validate_python(json_data)
+
+        # Basic assertions
+        assert isinstance(config, AgentEvalsDefinition)
+        assert config.id == "0e2201f2-b983-42c6-8231-64806c09ae54"
+        assert config.name == "Agent"
+        assert config.version == "1.0.0"
+        assert len(config.messages) == 2
+        assert len(config.resources) == 6  # 1 escalation + 3 tools + 2 context
+        assert config.settings.engine == "basic-v1"
+        assert config.settings.max_tokens == 16384
+
+        # Validate resource types
+        resource_types = [resource.resource_type for resource in config.resources]
+        assert resource_types.count(AgentResourceType.ESCALATION) == 1
+        assert resource_types.count(AgentResourceType.TOOL) == 3
+        assert resource_types.count(AgentResourceType.CONTEXT) == 2
+
+        # Validate specific resources
+        escalation_resource = next(
+            r
+            for r in config.resources
+            if r.resource_type == AgentResourceType.ESCALATION
+        )
+        assert escalation_resource.name == "Escalation_1"
+
+        tool_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.TOOL
+        ]
+        tool_names = [t.name for t in tool_resources]
+        assert "Agent tool" in tool_names
+        assert "Process tool with a guardrail" in tool_names
+        assert "IS tool" in tool_names
+
+        context_resources = [
+            r for r in config.resources if r.resource_type == AgentResourceType.CONTEXT
+        ]
+        context_names = [c.name for c in context_resources]
+        assert "Medical Index Semantic" in context_names
+        assert "Medical Index Structured" in context_names
+
+    def test_evals_agent_loads_unknown_resource_json(self):
+        """Test that EvalsAgentDefinition can load JSON with an unknown resource type"""
+
+        json_data = {
+            "id": "b2564199-e479-4b6f-9336-dc50f457afda",
+            "version": "1.0.0",
+            "name": "Agent",
+            "metadata": {
+                "storageVersion": "19.0.0",
+                "isConversational": False,
+            },
+            "messages": [
+                {"role": "system", "content": "You are an agentic assistant."},
+                {"role": "user", "content": "Search the code..."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {
+                    "content": {"type": "string", "description": "Output content"}
+                },
+            },
+            "settings": {
+                "model": "gpt-4o-2024-11-20",
+                "maxTokens": 16384,
+                "temperature": 0,
+                "engine": "basic-v1",
+            },
+            "resources": [
+                {
+                    "$resourceType": "unknownType",
+                    "id": "84250efc-8eb3-471c-8e01-437068dfc464",
+                    "name": "mystery_resource",
+                    "description": "Some new resource we don't know about",
+                    "slug": "mystery-resource",
+                    "folderPath": "Solution Folder",
+                    "extraField": {"foo": "bar"},
+                }
+            ],
+        }
+
+        config: AgentEvalsDefinition = TypeAdapter(
+            AgentEvalsDefinition
+        ).validate_python(json_data)
+
+        # Basic assertions
+        assert isinstance(config, AgentEvalsDefinition)
+        assert config.id == "b2564199-e479-4b6f-9336-dc50f457afda"
+        assert config.name == "Agent"
+        assert config.version == "1.0.0"
+        assert config.settings.engine == "basic-v1"
+        assert config.settings.max_tokens == 16384
+
+        # Validate resources
+        assert len(config.resources) == 1
+        resource = config.resources[0]
+
+        # Should fall back to UnknownAgentResourceConfig
+        assert isinstance(resource, AgentUnknownResourceConfig)
+        assert resource.resource_type == "unknown"
+        assert resource.name == "mystery_resource"
+        assert resource.extraField == {"foo": "bar"}
+        assert resource.slug == "mystery-resource"
diff --git a/packages/uipath/tests/agent/models/test_legacy.py b/packages/uipath/tests/agent/models/test_legacy.py
new file mode 100644
index 000000000..998501071
--- /dev/null
+++ b/packages/uipath/tests/agent/models/test_legacy.py
@@ -0,0 +1,301 @@
+"""Tests for legacy AgentDefinition backwards compatibility."""
+
+import copy
+
+from pydantic import TypeAdapter
+
+from uipath.agent.models._legacy import normalize_legacy_format
+from uipath.agent.models.agent import (
+    AgentDefinition,
+    AgentResourceType,
+)
+from uipath.agent.models.evals import AgentEvalsDefinition
+
+_MINIMAL_SETTINGS = {
+    "engine": "basic-v1",
+    "model": "gpt-4o",
+    "maxTokens": 4096,
+    "temperature": 0,
+}
+
+_MINIMAL_SCHEMAS = {
+    "inputSchema": {"type": "object", "properties": {}},
+    "outputSchema": {"type": "object", "properties": {}},
+}
+
+
+def _base(**overrides):
+    """Return a minimal modern-format dict, with overrides merged in."""
+    d = {
+        "version": "1.0.0",
+        "settings": _MINIMAL_SETTINGS,
+        **_MINIMAL_SCHEMAS,
+    }
+    d.update(overrides)
+    return d
+
+
+class TestNormalizeLegacyFormatMessages:
+    def test_modern_format_passes_through_unchanged(self):
+        data = _base(
+            messages=[
+                {"role": "system", "content": "hello"},
+                {"role": "user", "content": "world"},
+            ],
+            resources=[],
+        )
+        original = copy.deepcopy(data)
+        normalize_legacy_format(data)
+        assert data["messages"] == original["messages"]
+        assert data["resources"] == original["resources"]
+
+    def test_system_and_user_prompt_strings(self):
+        data = _base(systemPrompt="sys", userPrompt="usr")
+        normalize_legacy_format(data)
+        assert len(data["messages"]) == 2
+        assert data["messages"][0] == {"role": "system", "content": "sys"}
+        assert data["messages"][1] == {"role": "user", "content": "usr"}
+        assert "systemPrompt" not in data
+        assert "userPrompt" not in data
+
+    def test_system_prompt_only(self):
+        data = _base(systemPrompt={"content": "sys only"})
+        normalize_legacy_format(data)
+        assert len(data["messages"]) == 1
+        assert data["messages"][0]["role"] == "system"
+        assert data["messages"][0]["content"] == "sys only"
+
+    def test_user_prompt_only(self):
+        data = _base(userPrompt={"content": "usr only"})
+        normalize_legacy_format(data)
+        assert len(data["messages"]) == 1
+        assert data["messages"][0]["role"] == "user"
+        assert data["messages"][0]["content"] == "usr only"
+
+    def test_prompts_as_dicts(self):
+        data = _base(
+            systemPrompt={"content": "sys dict"},
+            userPrompt={"content": "usr dict"},
+        )
+        normalize_legacy_format(data)
+        assert data["messages"][0] == {"role": "system", "content": "sys dict"}
+        assert data["messages"][1] == {"role": "user", "content": "usr dict"}
+
+    def test_existing_messages_not_overwritten(self):
+        data = _base(
+            messages=[{"role": "system", "content": "keep me"}],
+            systemPrompt={"content": "should be ignored"},
+            userPrompt={"content": "should also be ignored"},
+        )
+        normalize_legacy_format(data)
+        assert len(data["messages"]) == 1
+        assert data["messages"][0]["content"] == "keep me"
+        # legacy fields still cleaned up
+        assert "systemPrompt" not in data
+        assert "userPrompt" not in data
+
+
+class TestNormalizeLegacyFormatResources:
+    def test_tools_become_tool_resources(self):
+        tool = {
+            "name": "t1",
+            "description": "d1",
+            "type": "Process",
+            "inputSchema": {},
+            "outputSchema": {},
+            "properties": {},
+            "settings": {},
+        }
+        data = _base(tools=[tool])
+        normalize_legacy_format(data)
+        assert len(data["resources"]) == 1
+        assert data["resources"][0]["$resourceType"] == "tool"
+        assert data["resources"][0]["isEnabled"] is True
+        assert "tools" not in data
+
+    def test_contexts_become_context_resources(self):
+        ctx = {
+            "name": "c1",
+            "description": "d1",
+            "folderPath": "f",
+            "indexName": "i",
+            "settings": {"resultCount": 3, "retrievalMode": "Semantic"},
+        }
+        data = _base(contexts=[ctx])
+        normalize_legacy_format(data)
+        assert len(data["resources"]) == 1
+        assert data["resources"][0]["$resourceType"] == "context"
+        assert "contexts" not in data
+
+    def test_escalations_become_escalation_resources(self):
+        esc = {"name": "e1", "description": "d1", "channels": [], "escalationType": 0}
+        data = _base(escalations=[esc])
+        normalize_legacy_format(data)
+        assert len(data["resources"]) == 1
+        assert data["resources"][0]["$resourceType"] == "escalation"
+        assert "escalations" not in data
+
+    def test_mixed_legacy_resources_maintain_order(self):
+        tool = {"name": "t", "description": "d"}
+        ctx = {"name": "c", "description": "d"}
+        esc = {"name": "e", "description": "d"}
+        data = _base(tools=[tool], contexts=[ctx], escalations=[esc])
+        normalize_legacy_format(data)
+        types = [r["$resourceType"] for r in data["resources"]]
+        assert types == ["tool", "context", "escalation"]
+
+    def test_existing_resources_not_overwritten(self):
+        data = _base(
+            resources=[{"$resourceType": "tool", "name": "keep"}],
+            tools=[{"name": "ignored", "description": "d"}],
+        )
+        normalize_legacy_format(data)
+        assert len(data["resources"]) == 1
+        assert data["resources"][0]["name"] == "keep"
+
+    def test_setdefault_does_not_overwrite_existing_resource_type(self):
+        tool = {"name": "t", "description": "d", "$resourceType": "custom"}
+        data = _base(tools=[tool])
+        normalize_legacy_format(data)
+        assert data["resources"][0]["$resourceType"] == "custom"
+
+
+class TestNormalizeLegacyFormatCleanup:
+    def test_legacy_fields_removed(self):
+        data = _base(
+            systemPrompt={"content": "s"},
+            userPrompt={"content": "u"},
+            tools=[],
+            contexts=[],
+            escalations=[],
+        )
+        normalize_legacy_format(data)
+        legacy_fields = [
+            "systemPrompt",
+            "userPrompt",
+            "tools",
+            "contexts",
+            "escalations",
+        ]
+        for key in legacy_fields:
+            assert key not in data
+
+
+class TestNormalizeLegacyFormatIdempotent:
+    def test_double_application_is_stable(self):
+        data = _base(
+            systemPrompt={"content": "sys"},
+            userPrompt={"content": "usr"},
+            tools=[{"name": "t", "description": "d"}],
+        )
+        normalize_legacy_format(data)
+        snapshot = copy.deepcopy(data)
+        normalize_legacy_format(data)
+        assert data == snapshot
+
+
+class TestLegacyAgentDefinitionIntegration:
+    def _legacy_payload(self, **extra):
+        """Build a complete legacy payload that should parse into AgentDefinition."""
+        payload = {
+            "version": "1.0.0",
+            "settings": _MINIMAL_SETTINGS,
+            **_MINIMAL_SCHEMAS,
+            "systemPrompt": {"content": "You are an assistant."},
+            "userPrompt": {"content": "Help with {{task}}."},
+        }
+        payload.update(extra)
+        return payload
+
+    def test_basic_legacy_payload_parses(self):
+        data = self._legacy_payload()
+        agent = TypeAdapter(AgentDefinition).validate_python(data)
+        assert len(agent.messages) == 2
+        assert agent.messages[0].role == "system"
+        assert agent.messages[0].content == "You are an assistant."
+        assert agent.messages[1].role == "user"
+        assert agent.messages[1].content == "Help with {{task}}."
+
+    def test_legacy_payload_with_all_resource_types(self):
+        data = self._legacy_payload(
+            tools=[
+                {
+                    "name": "MyTool",
+                    "description": "A process tool",
+                    "type": "Process",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "properties": {"folderPath": "f", "processName": "p"},
+                    "settings": {"maxAttempts": 0, "retryDelay": 0, "timeout": 0},
+                }
+            ],
+            contexts=[
+                {
+                    "name": "MyContext",
+                    "description": "A context",
+                    "folderPath": "f",
+                    "indexName": "idx",
+                    "settings": {
+                        "resultCount": 5,
+                        "retrievalMode": "Semantic",
+                        "threshold": 0,
+                    },
+                }
+            ],
+            escalations=[
+                {
+                    "name": "MyEscalation",
+                    "description": "An escalation",
+                    "escalationType": 0,
+                    "channels": [
+                        {
+                            "name": "ch",
+                            "type": "ActionCenter",
+                            "description": "chan desc",
+                            "inputSchema": {"type": "object", "properties": {}},
+                            "outputSchema": {"type": "object", "properties": {}},
+                            "properties": {"appVersion": 1},
+                            "recipients": [{"type": "UserId", "value": "uid"}],
+                        }
+                    ],
+                }
+            ],
+        )
+
+        agent = TypeAdapter(AgentDefinition).validate_python(data)
+
+        assert len(agent.messages) == 2
+        assert len(agent.resources) == 3
+
+        types = [r.resource_type for r in agent.resources]
+        assert AgentResourceType.TOOL in types
+        assert AgentResourceType.CONTEXT in types
+        assert AgentResourceType.ESCALATION in types
+
+    def test_legacy_format_through_evals_definition(self):
+        data = {
+            "version": "1.0.0",
+            "settings": _MINIMAL_SETTINGS,
+            **_MINIMAL_SCHEMAS,
+            "systemPrompt": {"content": "Eval agent prompt"},
+            "userPrompt": {"content": "Eval user prompt"},
+            "tools": [
+                {
+                    "name": "EvalTool",
+                    "description": "Tool for eval",
+                    "type": "Process",
+                    "inputSchema": {"type": "object", "properties": {}},
+                    "outputSchema": {"type": "object", "properties": {}},
+                    "properties": {"folderPath": "f", "processName": "p"},
+                    "settings": {"maxAttempts": 0, "retryDelay": 0, "timeout": 0},
+                }
+            ],
+        }
+
+        agent = TypeAdapter(AgentEvalsDefinition).validate_python(data)
+
+        assert isinstance(agent, AgentEvalsDefinition)
+        assert len(agent.messages) == 2
+        assert agent.messages[0].content == "Eval agent prompt"
+        assert len(agent.resources) == 1
+        assert agent.resources[0].resource_type == AgentResourceType.TOOL
diff --git a/packages/uipath/tests/agent/react/__init__.py b/packages/uipath/tests/agent/react/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/tests/agent/react/test_conversational_prompts.py b/packages/uipath/tests/agent/react/test_conversational_prompts.py
new file mode 100644
index 000000000..434f68465
--- /dev/null
+++ b/packages/uipath/tests/agent/react/test_conversational_prompts.py
@@ -0,0 +1,350 @@
+"""Tests for conversational agent prompt generation."""
+
+import json
+import re
+from datetime import datetime, timezone
+from unittest.mock import patch
+
+from uipath.agent.react.conversational_prompts import (
+    PromptUserSettings,
+    get_chat_system_prompt,
+    get_user_settings_template,
+)
+
+SYSTEM_MESSAGE = "You are a helpful assistant."
+
+
+class TestGenerateConversationalAgentSystemPrompt:
+    """Tests for get_chat_system_prompt function."""
+
+    def test_generate_system_prompt_basic(self):
+        """Generate prompt with minimal inputs."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Basic Agent",
+            user_settings=None,
+        )
+
+        assert "You are Basic Agent." in prompt
+        assert "You are a helpful assistant." in prompt
+        assert "AGENT SYSTEM PROMPT" in prompt
+        assert "TOOL USAGE RULES" in prompt
+
+    def test_generate_system_prompt_with_user_settings(self):
+        """Prompt includes user context when PromptUserSettings provided."""
+        user_settings = PromptUserSettings(
+            name="John Doe",
+            email="john.doe@example.com",
+            role="Developer",
+            department="Engineering",
+            company="Acme Corp",
+            country="USA",
+            timezone="America/New_York",
+        )
+
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=user_settings,
+        )
+
+        assert "USER CONTEXT" in prompt
+        assert "John Doe" in prompt
+        assert "john.doe@example.com" in prompt
+        assert "Developer" in prompt
+        assert "Engineering" in prompt
+        assert "Acme Corp" in prompt
+        assert "USA" in prompt
+        assert "America/New_York" in prompt
+
+    def test_generate_system_prompt_without_user_settings(self):
+        """Prompt excludes user context section when user_settings=None."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert "USER CONTEXT" not in prompt
+
+    def test_generate_system_prompt_with_partial_user_settings(self):
+        """Only non-None user settings fields are included in JSON."""
+        user_settings = PromptUserSettings(
+            name="Jane Doe",
+            email="jane@example.com",
+            # Other fields are None
+        )
+
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=user_settings,
+        )
+
+        assert "USER CONTEXT" in prompt
+        assert "Jane Doe" in prompt
+        assert "jane@example.com" in prompt
+        # None fields should not appear in the JSON
+        assert '"role":' not in prompt
+        assert '"department":' not in prompt
+
+    def test_generate_system_prompt_includes_agent_name(self):
+        """Agent name is substituted into prompt."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Customer Support Bot",
+            user_settings=None,
+        )
+
+        assert "You are Customer Support Bot." in prompt
+
+    def test_generate_system_prompt_includes_current_date(self):
+        """Current date in ISO 8601 format is included."""
+        # Mock datetime to have a predictable value
+        mock_dt = datetime(2026, 1, 15, 10, 30, tzinfo=timezone.utc)
+        with patch(
+            "uipath.agent.react.conversational_prompts.datetime"
+        ) as mock_datetime:
+            mock_datetime.now.return_value = mock_dt
+            mock_datetime.side_effect = lambda *args, **kwargs: datetime(
+                *args, **kwargs
+            )
+
+            prompt = get_chat_system_prompt(
+                model="claude-3-sonnet",
+                system_message=SYSTEM_MESSAGE,
+                agent_name="Test Agent",
+                user_settings=None,
+            )
+
+        assert "2026-01-15T10:30Z" in prompt
+
+    def test_generate_system_prompt_includes_attachments_section(self):
+        """Attachments template is always included."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert "ATTACHMENTS" in prompt
+        assert "job attachments" in prompt.lower()
+        assert "<uip:attachments>" in prompt
+
+    def test_generate_system_prompt_unnamed_agent_uses_default(self):
+        """Unnamed agent defaults to 'Unnamed Agent'."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name=None,
+            user_settings=None,
+        )
+
+        assert "You are Unnamed Agent." in prompt
+
+
+class TestConversationIdInPrompt:
+    """Tests for conversation_id in generated prompts."""
+
+    def test_prompt_includes_conversation_id_when_provided(self):
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+            conversation_id="conv-abc-123",
+        )
+
+        assert "The current conversation ID is conv-abc-123" in prompt
+        assert (
+            "This may be useful to include in tool-calls when tool parameters specify passing in the conversation ID."
+            in prompt
+        )
+        assert (
+            "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_conversationIdPrompt}}" not in prompt
+        )
+
+    def test_prompt_omits_section_when_none(self):
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+            conversation_id=None,
+        )
+
+        assert "conversation ID" not in prompt
+        assert (
+            "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_conversationIdPrompt}}" not in prompt
+        )
+
+    def test_prompt_omits_section_when_empty_string(self):
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+            conversation_id="",
+        )
+
+        assert "conversation ID" not in prompt
+
+    def test_prompt_defaults_to_no_conversation_id(self):
+        """conversation_id defaults to None — call sites that don't pass it
+        must not get a dangling placeholder."""
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert (
+            "{{CONVERSATIONAL_AGENT_SERVICE_PREFIX_conversationIdPrompt}}" not in prompt
+        )
+        assert "conversation ID" not in prompt
+
+
+class TestCitationFormat:
+    """Tests for citation format in generated prompts."""
+
+    def test_citation_format_claude(self):
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert (
+            '<uip:cite title="Document Title" reference="https://url" page_number="1"/>'
+            in prompt
+        )
+
+    def test_citation_format_gpt(self):
+        prompt = get_chat_system_prompt(
+            model="gpt-4o",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert (
+            '<uip:cite title="Document Title" reference="https://url" page_number="1"/>'
+            in prompt
+        )
+
+    def test_citation_examples_in_prompt(self):
+        prompt = get_chat_system_prompt(
+            model="claude-3-sonnet",
+            system_message=SYSTEM_MESSAGE,
+            agent_name="Test Agent",
+            user_settings=None,
+        )
+
+        assert "EXAMPLES OF CORRECT USAGE:" in prompt
+        assert (
+            '<uip:cite title="Industry Study" url="https://example.com/study"/>'
+            in prompt
+        )
+        assert (
+            '<uip:cite title="Policy Manual v2.pdf" reference="https://docs.example.com/ref" page_number="15"/>'
+            in prompt
+        )
+        assert "CRITICAL ERRORS TO AVOID:" in prompt
+
+
+class TestPromptUserSettings:
+    """Tests for PromptUserSettings dataclass."""
+
+    def test_all_fields_populated(self):
+        """All fields populated in PromptUserSettings."""
+        settings = PromptUserSettings(
+            name="Test User",
+            email="test@example.com",
+            role="Admin",
+            department="IT",
+            company="Test Co",
+            country="Canada",
+            timezone="America/Toronto",
+        )
+
+        assert settings.name == "Test User"
+        assert settings.email == "test@example.com"
+        assert settings.role == "Admin"
+        assert settings.department == "IT"
+        assert settings.company == "Test Co"
+        assert settings.country == "Canada"
+        assert settings.timezone == "America/Toronto"
+
+    def test_default_none_values(self):
+        """Default values are None."""
+        settings = PromptUserSettings()
+
+        assert settings.name is None
+        assert settings.email is None
+        assert settings.role is None
+        assert settings.department is None
+        assert settings.company is None
+        assert settings.country is None
+        assert settings.timezone is None
+
+
+class TestGetUserSettingsTemplate:
+    """Tests for get_user_settings_template helper."""
+
+    def test_none_returns_empty(self):
+        """Returns empty string when user_settings is None."""
+        result = get_user_settings_template(None)
+        assert result == ""
+
+    def test_empty_settings_returns_empty(self):
+        """Returns empty string when all fields are None."""
+        settings = PromptUserSettings()
+        result = get_user_settings_template(settings)
+        assert result == ""
+
+    def test_partial_settings_includes_non_none_only(self):
+        """Only includes non-None fields in JSON."""
+        settings = PromptUserSettings(name="Test", email="test@example.com")
+        result = get_user_settings_template(settings)
+
+        assert "USER CONTEXT" in result
+        assert '"name": "Test"' in result or '"name":"Test"' in result
+        assert "test@example.com" in result
+        # None fields should not be present
+        assert "role" not in result
+        assert "department" not in result
+
+    def test_full_settings_json_format(self):
+        """Full settings are formatted as valid JSON."""
+        settings = PromptUserSettings(
+            name="Full User",
+            email="full@example.com",
+            role="Manager",
+            department="Sales",
+            company="Big Corp",
+            country="UK",
+            timezone="Europe/London",
+        )
+        result = get_user_settings_template(settings)
+
+        # Extract JSON from the result
+        json_match = re.search(r"```json\s*(\{[^`]+\})\s*```", result)
+        assert json_match is not None
+
+        # Validate it's proper JSON
+        json_data = json.loads(json_match.group(1))
+        assert json_data["name"] == "Full User"
+        assert json_data["email"] == "full@example.com"
+        assert json_data["role"] == "Manager"
+        assert json_data["department"] == "Sales"
+        assert json_data["company"] == "Big Corp"
+        assert json_data["country"] == "UK"
+        assert json_data["timezone"] == "Europe/London"
diff --git a/packages/uipath/tests/agent/react/test_conversational_voice_prompts.py b/packages/uipath/tests/agent/react/test_conversational_voice_prompts.py
new file mode 100644
index 000000000..ece66ea92
--- /dev/null
+++ b/packages/uipath/tests/agent/react/test_conversational_voice_prompts.py
@@ -0,0 +1,40 @@
+"""Tests for voice agent prompt generation."""
+
+from uipath.agent.react import PromptUserSettings, get_voice_system_prompt
+
+
+class TestGetVoiceSystemPrompt:
+    """Test get_voice_system_prompt with various user settings."""
+
+    def test_no_user_settings(self) -> None:
+        result = get_voice_system_prompt("Be helpful.", "Agent")
+        assert "USER CONTEXT" not in result
+        assert "Be helpful." in result
+
+    def test_with_user_settings(self) -> None:
+        settings = PromptUserSettings(name="Alice", email="alice@test.com")
+        result = get_voice_system_prompt("Be helpful.", "Agent", user_settings=settings)
+        assert "USER CONTEXT" in result
+        assert '"name": "Alice"' in result
+        assert '"email": "alice@test.com"' in result
+
+    def test_user_settings_none_values_excluded(self) -> None:
+        settings = PromptUserSettings(name="Bob")
+        result = get_voice_system_prompt("Be helpful.", "Agent", user_settings=settings)
+        assert '"name": "Bob"' in result
+        assert "email" not in result
+
+    def test_user_settings_all_none_skipped(self) -> None:
+        settings = PromptUserSettings()
+        result = get_voice_system_prompt("Be helpful.", "Agent", user_settings=settings)
+        assert "USER CONTEXT" not in result
+
+    def test_default_agent_name(self) -> None:
+        result = get_voice_system_prompt("Hello.", None)
+        assert "You are Voice Assistant." in result
+
+    def test_includes_date_and_system_message(self) -> None:
+        result = get_voice_system_prompt("Do things.", "MyAgent")
+        assert "You are MyAgent." in result
+        assert "The current date is:" in result
+        assert "Do things." in result
diff --git a/packages/uipath/tests/agent/utils/test_load_agent_definition.py b/packages/uipath/tests/agent/utils/test_load_agent_definition.py
new file mode 100644
index 000000000..996eaf420
--- /dev/null
+++ b/packages/uipath/tests/agent/utils/test_load_agent_definition.py
@@ -0,0 +1,326 @@
+"""Tests for load_agent_definition function from uipath.agent.utils._utils."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from uipath.agent.models.evals import AgentEvalsDefinition
+from uipath.agent.utils._utils import load_agent_definition
+
+
+@pytest.fixture
+def temp_project_dir():
+    """Create a temporary project directory for testing."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield Path(tmpdir)
+
+
+class TestLoadAgentDefinition:
+    """Test suite for load_agent_definition function."""
+
+    def test_load_agent_definition_with_legacy_evaluators(self, temp_project_dir):
+        """Test loading agent definition with legacy evaluators."""
+        # Create agent.json
+        agent_data = {
+            "id": "test-agent-1",
+            "name": "Test Agent",
+            "version": "1.0.0",
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Help the user."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 2048,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+        }
+
+        with open(temp_project_dir / "agent.json", "w") as f:
+            json.dump(agent_data, f)
+
+        # Create evaluators directory with a legacy evaluator
+        evals_dir = temp_project_dir / "evaluations" / "evaluators"
+        evals_dir.mkdir(parents=True, exist_ok=True)
+
+        legacy_evaluator = {
+            "fileName": "evaluator-default.json",
+            "id": "legacy-eval-1",
+            "name": "Default Evaluator",
+            "description": "An LLM-based evaluator",
+            "category": 1,  # LlmAsAJudge
+            "type": 5,
+            "prompt": "Evaluate the output.",
+            "model": "same-as-agent",
+            "targetOutputKey": "*",
+            "createdAt": "2025-02-04T00:00:00.000Z",
+            "updatedAt": "2025-02-04T00:00:00.000Z",
+        }
+
+        with open(evals_dir / "evaluator-default.json", "w") as f:
+            json.dump(legacy_evaluator, f)
+
+        # Create eval-sets directory (empty)
+        eval_sets_dir = temp_project_dir / "evaluations" / "eval-sets"
+        eval_sets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load and validate
+        result = load_agent_definition(temp_project_dir)
+
+        assert isinstance(result, AgentEvalsDefinition)
+        assert result.id == "test-agent-1"
+        assert result.name == "Test Agent"
+        assert result.version == "1.0.0"
+        # Evaluators should be loaded
+        assert len(result.evaluators or []) == 1
+        evaluator = (result.evaluators or [])[0]
+        assert evaluator.id == "legacy-eval-1"
+
+    def test_load_agent_definition_with_coded_evaluators(self, temp_project_dir):
+        """Test loading agent definition with non-legacy (coded) evaluators."""
+        # Create agent.json
+        agent_data = {
+            "id": "test-agent-2",
+            "name": "Test Agent with Coded Evaluators",
+            "version": "1.0.0",
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Help the user."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 2048,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+        }
+
+        with open(temp_project_dir / "agent.json", "w") as f:
+            json.dump(agent_data, f)
+
+        # Create evaluators directory with a coded evaluator (ExactMatchEvaluator)
+        evals_dir = temp_project_dir / "evaluations" / "evaluators"
+        evals_dir.mkdir(parents=True, exist_ok=True)
+
+        coded_evaluator = {
+            "version": "1.0",
+            "id": "exact-match-eval",
+            "description": "Checks if the response exactly matches the expected value.",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {
+                "name": "ExactMatchEvaluator",
+                "targetOutputKey": "*",
+                "negated": False,
+                "caseSensitive": False,
+                "defaultEvaluationCriteria": {"expectedOutput": "expected response"},
+            },
+        }
+
+        with open(evals_dir / "exact-match.json", "w") as f:
+            json.dump(coded_evaluator, f)
+
+        # Create eval-sets directory (empty)
+        eval_sets_dir = temp_project_dir / "evaluations" / "eval-sets"
+        eval_sets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load and validate
+        result = load_agent_definition(temp_project_dir)
+
+        assert isinstance(result, AgentEvalsDefinition)
+        assert result.id == "test-agent-2"
+        assert result.name == "Test Agent with Coded Evaluators"
+        # Evaluators should be loaded
+        assert len(result.evaluators or []) == 1
+        evaluator = (result.evaluators or [])[0]
+        assert evaluator.id == "exact-match-eval"
+
+    def test_load_agent_definition_with_mixed_evaluators(self, temp_project_dir):
+        """Test loading agent definition with both legacy and coded evaluators."""
+        # Create agent.json
+        agent_data = {
+            "id": "test-agent-3",
+            "name": "Test Agent with Mixed Evaluators",
+            "version": "1.0.0",
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Help the user."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 2048,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+        }
+
+        with open(temp_project_dir / "agent.json", "w") as f:
+            json.dump(agent_data, f)
+
+        # Create evaluators directory with both legacy and coded evaluators
+        evals_dir = temp_project_dir / "evaluations" / "evaluators"
+        evals_dir.mkdir(parents=True, exist_ok=True)
+
+        # Legacy evaluator
+        legacy_evaluator = {
+            "fileName": "evaluator-legacy.json",
+            "id": "legacy-eval",
+            "name": "Legacy Evaluator",
+            "category": 1,
+            "type": 5,
+            "prompt": "Evaluate the output.",
+            "model": "same-as-agent",
+            "targetOutputKey": "*",
+            "createdAt": "2025-02-04T00:00:00.000Z",
+            "updatedAt": "2025-02-04T00:00:00.000Z",
+        }
+
+        with open(evals_dir / "legacy.json", "w") as f:
+            json.dump(legacy_evaluator, f)
+
+        # Coded evaluator
+        coded_evaluator = {
+            "version": "1.0",
+            "id": "exact-match-eval",
+            "description": "Exact match evaluator",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {
+                "name": "ExactMatchEvaluator",
+                "targetOutputKey": "*",
+                "negated": False,
+                "caseSensitive": False,
+                "defaultEvaluationCriteria": {"expectedOutput": "expected"},
+            },
+        }
+
+        with open(evals_dir / "exact-match.json", "w") as f:
+            json.dump(coded_evaluator, f)
+
+        # Create eval-sets directory (empty)
+        eval_sets_dir = temp_project_dir / "evaluations" / "eval-sets"
+        eval_sets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load and validate
+        result = load_agent_definition(temp_project_dir)
+
+        assert isinstance(result, AgentEvalsDefinition)
+        assert result.id == "test-agent-3"
+        assert len(result.evaluators or []) == 2
+
+        # Verify both evaluators are present
+        evaluator_ids = [e.id for e in (result.evaluators or [])]
+        assert "legacy-eval" in evaluator_ids
+        assert "exact-match-eval" in evaluator_ids
+
+    def test_load_agent_definition_with_evaluator_and_resources(self, temp_project_dir):
+        """Test loading agent definition with coded evaluator and agent.json resources."""
+        # Create agent.json with resources
+        agent_data = {
+            "id": "test-agent-4",
+            "name": "Agent with Evaluator and Resources",
+            "version": "1.0.0",
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 2048,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+        }
+
+        with open(temp_project_dir / "agent.json", "w") as f:
+            json.dump(agent_data, f)
+
+        # Create evaluators directory with a coded evaluator
+        evals_dir = temp_project_dir / "evaluations" / "evaluators"
+        evals_dir.mkdir(parents=True, exist_ok=True)
+
+        coded_evaluator = {
+            "version": "1.0",
+            "id": "exact-match-eval-4",
+            "description": "Exact match evaluator",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {
+                "name": "ExactMatchEvaluator",
+                "targetOutputKey": "*",
+                "negated": False,
+                "caseSensitive": False,
+                "defaultEvaluationCriteria": {"expectedOutput": "expected"},
+            },
+        }
+
+        with open(evals_dir / "exact-match.json", "w") as f:
+            json.dump(coded_evaluator, f)
+
+        # Create eval-sets directory (empty)
+        eval_sets_dir = temp_project_dir / "evaluations" / "eval-sets"
+        eval_sets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load and validate
+        result = load_agent_definition(temp_project_dir)
+
+        assert isinstance(result, AgentEvalsDefinition)
+        assert result.id == "test-agent-4"
+        assert len(result.evaluators or []) == 1
+        evaluator = (result.evaluators or [])[0]
+        assert evaluator.id == "exact-match-eval-4"
+
+    def test_load_agent_definition_missing_evaluators_directory(self, temp_project_dir):
+        """Test loading agent definition when evaluators directory doesn't exist."""
+        # Create agent.json
+        agent_data = {
+            "id": "test-agent-5",
+            "name": "Agent without Evaluators Dir",
+            "version": "1.0.0",
+            "messages": [
+                {"role": "system", "content": "You are helpful."},
+            ],
+            "inputSchema": {"type": "object", "properties": {}},
+            "outputSchema": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            "settings": {
+                "model": "gpt-4o",
+                "maxTokens": 2048,
+                "temperature": 0.7,
+                "engine": "basic-v1",
+            },
+        }
+
+        with open(temp_project_dir / "agent.json", "w") as f:
+            json.dump(agent_data, f)
+
+        # Don't create evaluators or eval-sets directories
+
+        # Load and validate - should handle missing directories gracefully
+        result = load_agent_definition(temp_project_dir)
+
+        assert isinstance(result, AgentEvalsDefinition)
+        assert result.id == "test-agent-5"
+        assert result.evaluators is None or len(result.evaluators or []) == 0
+        assert result.evaluation_sets is None or len(result.evaluation_sets or []) == 0
diff --git a/packages/uipath/tests/agent/utils/test_text_tokens.py b/packages/uipath/tests/agent/utils/test_text_tokens.py
new file mode 100644
index 000000000..6b71f8ece
--- /dev/null
+++ b/packages/uipath/tests/agent/utils/test_text_tokens.py
@@ -0,0 +1,290 @@
+"""Tests for text_tokens.py utils."""
+
+from enum import Enum
+
+import pytest
+
+from uipath.agent.models.agent import TextToken, TextTokenType
+from uipath.agent.utils.text_tokens import (
+    build_string_from_tokens,
+    safe_get_nested,
+    serialize_argument,
+)
+
+
+class TestBuildStringFromTokens:
+    """Test building strings from text tokens."""
+
+    def test_simple_text_tokens(self):
+        """Test simple text tokens are joined correctly."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Hello "),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="World"),
+        ]
+        result = build_string_from_tokens(tokens, {})
+        assert result == "Hello World"
+
+    def test_with_input_variable_replacement(self):
+        """Test input.* variable tokens are replaced with input values."""
+        tokens = [
+            TextToken(
+                type=TextTokenType.SIMPLE_TEXT,
+                raw_string="What is the weather like in ",
+            ),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input.city"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="?"),
+        ]
+        result = build_string_from_tokens(tokens, {"city": "London"})
+        assert result == "What is the weather like in London?"
+
+    def test_with_output_variable(self):
+        """Test output.* variable tokens return the path."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Put the results in "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="output.weather"),
+        ]
+        result = build_string_from_tokens(tokens, {})
+        assert result == "Put the results in weather"
+
+    def test_spec_example_without_tool_names(self):
+        """Test the spec example without tool names (tools.weather remains unresolved)."""
+        tokens = [
+            TextToken(
+                type=TextTokenType.SIMPLE_TEXT,
+                raw_string="What is the weather like in ",
+            ),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input.city"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="?\nUse the "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.weather"),
+            TextToken(
+                type=TextTokenType.SIMPLE_TEXT,
+                raw_string=" tool and put the results in ",
+            ),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="output.weather"),
+        ]
+        result = build_string_from_tokens(tokens, {"city": "London"})
+        # tools.weather is not resolved (returns raw string), output.weather returns "weather"
+        assert (
+            result
+            == "What is the weather like in London?\nUse the tools.weather tool and put the results in weather"
+        )
+
+    def test_spec_example_with_tool_names(self):
+        """Test the spec example with tool names resolves correctly."""
+        tokens = [
+            TextToken(
+                type=TextTokenType.SIMPLE_TEXT,
+                raw_string="What is the weather like in ",
+            ),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input.city"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="?\nUse the "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.weather"),
+            TextToken(
+                type=TextTokenType.SIMPLE_TEXT,
+                raw_string=" tool and put the results in ",
+            ),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="output.weather"),
+        ]
+        result = build_string_from_tokens(
+            tokens, {"city": "London"}, tool_names=["weather"]
+        )
+        assert (
+            result
+            == "What is the weather like in London?\nUse the weather tool and put the results in weather"
+        )
+
+    def test_with_nested_input_object(self):
+        """Test nested input objects are replaced correctly."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="The person is "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input.person.age"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string=" years old"),
+        ]
+        result = build_string_from_tokens(
+            tokens, {"person": {"age": 25, "name": "John"}}
+        )
+        assert result == "The person is 25 years old"
+
+    def test_expression_token_copies_raw_string(self):
+        """Test expression tokens are copied as-is."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Result: "),
+            TextToken(type=TextTokenType.EXPRESSION, raw_string="{{some.expression}}"),
+        ]
+        result = build_string_from_tokens(tokens, {})
+        assert result == "Result: {{some.expression}}"
+
+    def test_input_variable_returns_entire_input_as_json(self):
+        """Test 'input' variable returns entire input as JSON."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Input: "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input"),
+        ]
+        result = build_string_from_tokens(tokens, {"city": "London", "temp": 20})
+        assert result == 'Input: {"city": "London", "temp": 20}'
+
+    @pytest.mark.parametrize(
+        "raw_string,expected",
+        [
+            ("", ""),
+            ("   ", "   "),
+            ("unknown", "unknown"),
+            ("unknown.path", "unknown.path"),
+        ],
+    )
+    def test_unknown_variable_patterns_return_raw_string(self, raw_string, expected):
+        """Test unknown variable patterns return the raw string."""
+        tokens = [TextToken(type=TextTokenType.VARIABLE, raw_string=raw_string)]
+        result = build_string_from_tokens(tokens, {"some": "value"})
+        assert result == expected
+
+    def test_missing_input_value_returns_raw_string(self):
+        """Test missing input values return the raw variable string."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Value: "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="input.missing"),
+        ]
+        result = build_string_from_tokens(tokens, {"other": "value"})
+        assert result == "Value: input.missing"
+
+    def test_tool_reference_resolves_to_tool_name(self):
+        """Test tools.* variable resolves to tool name."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Use the "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.weather"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string=" tool"),
+        ]
+        result = build_string_from_tokens(
+            tokens, {}, tool_names=["weather", "calculator"]
+        )
+        assert result == "Use the weather tool"
+
+    def test_tool_reference_case_insensitive(self):
+        """Test tools.* variable resolution is case-insensitive."""
+        tokens = [
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.WEATHER"),
+        ]
+        result = build_string_from_tokens(tokens, {}, tool_names=["weather"])
+        assert result == "weather"
+
+    def test_tool_reference_not_found_returns_raw_string(self):
+        """Test unknown tool reference returns raw string."""
+        tokens = [
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.unknown"),
+        ]
+        result = build_string_from_tokens(tokens, {}, tool_names=["weather"])
+        assert result == "tools.unknown"
+
+    def test_escalation_reference_resolves_to_escalation_name(self):
+        """Test escalations.* variable resolves to escalation name."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Escalate to "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="escalations.support"),
+        ]
+        result = build_string_from_tokens(tokens, {}, escalation_names=["support"])
+        assert result == "Escalate to support"
+
+    def test_context_reference_resolves_to_context_name(self):
+        """Test contexts.* variable resolves to context name."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Search in "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="contexts.docs"),
+        ]
+        result = build_string_from_tokens(tokens, {}, context_names=["docs"])
+        assert result == "Search in docs"
+
+    def test_multiple_resource_types_together(self):
+        """Test using multiple resource types in one prompt."""
+        tokens = [
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string="Use "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="tools.weather"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string=" with "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="contexts.docs"),
+            TextToken(type=TextTokenType.SIMPLE_TEXT, raw_string=" or escalate to "),
+            TextToken(type=TextTokenType.VARIABLE, raw_string="escalations.support"),
+        ]
+        result = build_string_from_tokens(
+            tokens,
+            {},
+            tool_names=["weather"],
+            escalation_names=["support"],
+            context_names=["docs"],
+        )
+        assert result == "Use weather with docs or escalate to support"
+
+
+class TestSafeGetNested:
+    """Test nested dictionary access."""
+
+    def test_simple_key(self):
+        """Test accessing simple top-level key."""
+        data = {"name": "Alice"}
+        assert safe_get_nested(data, "name") == "Alice"
+
+    def test_nested_key(self):
+        """Test accessing nested keys with dot notation."""
+        data = {"user": {"name": "Alice", "age": 30}}
+        assert safe_get_nested(data, "user.name") == "Alice"
+        assert safe_get_nested(data, "user.age") == 30
+
+    def test_missing_key(self):
+        """Test accessing missing keys returns None."""
+        data = {"user": {"name": "Alice"}}
+        assert safe_get_nested(data, "user.missing") is None
+        assert safe_get_nested(data, "missing.key") is None
+
+    def test_array_value(self):
+        """Test accessing array values."""
+        data = {"items": [1, 2, 3]}
+        assert safe_get_nested(data, "items") == [1, 2, 3]
+
+    def test_deeply_nested(self):
+        """Test deeply nested access."""
+        data = {"level1": {"level2": {"level3": {"value": "deep"}}}}
+        assert safe_get_nested(data, "level1.level2.level3.value") == "deep"
+
+    def test_null_intermediate_value(self):
+        """Test access through null intermediate value."""
+        data = {"user": None}
+        assert safe_get_nested(data, "user.name") is None
+
+
+class TestSerializeValue:
+    """Test value serialization."""
+
+    class RiskTolerance(str, Enum):
+        """Test enum mirroring dynamic string enums in input schemas."""
+
+        LOW = "low"
+
+    def test_string(self):
+        """Test serializing strings."""
+        assert serialize_argument("hello") == "hello"
+
+    def test_number(self):
+        """Test serializing numbers."""
+        assert serialize_argument(42) == "42"
+        assert serialize_argument(3.14) == "3.14"
+
+    def test_list(self):
+        """Test serializing lists."""
+        assert serialize_argument([1, 2, 3]) == "[1, 2, 3]"
+
+    def test_dict(self):
+        """Test serializing dictionaries."""
+        result = serialize_argument({"key": "value"})
+        assert '"key"' in result
+        assert '"value"' in result
+
+    def test_none(self):
+        """Test serializing None returns empty string."""
+        assert serialize_argument(None) == ""
+
+    def test_boolean(self):
+        """Test serializing booleans (JSON-style lowercase)."""
+        assert serialize_argument(True) == "true"
+        assert serialize_argument(False) == "false"
+
+    def test_string_enum_uses_underlying_value(self):
+        """Test string enums serialize to their values for prompt interpolation."""
+        assert serialize_argument(self.RiskTolerance.LOW) == "low"
diff --git a/packages/uipath/tests/cli/chat/__init__.py b/packages/uipath/tests/cli/chat/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/tests/cli/chat/test_bridge.py b/packages/uipath/tests/cli/chat/test_bridge.py
new file mode 100644
index 000000000..2c18640f3
--- /dev/null
+++ b/packages/uipath/tests/cli/chat/test_bridge.py
@@ -0,0 +1,738 @@
+"""Tests for SocketIOChatBridge and get_chat_bridge."""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import Any, cast
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from uipath._cli._chat._bridge import SocketIOChatBridge, get_chat_bridge
+from uipath._cli._debug._bridge import SignalRDebugBridge
+from uipath.core.triggers import UiPathApiTrigger, UiPathResumeTrigger
+
+
+class MockRuntimeContext:
+    """Mock UiPathRuntimeContext for testing."""
+
+    def __init__(
+        self,
+        conversation_id: str = "test-conversation-id",
+        exchange_id: str = "test-exchange-id",
+        tenant_id: str = "test-tenant-id",
+        org_id: str = "test-org-id",
+        end_exchange: bool = True,
+    ):
+        self.conversation_id = conversation_id
+        self.exchange_id = exchange_id
+        self.tenant_id = tenant_id
+        self.org_id = org_id
+        self.end_exchange = end_exchange
+
+
+class TestSocketIOChatBridgeDebugMode:
+    """Tests for SocketIOChatBridge debug mode (CAS_WEBSOCKET_DISABLED)."""
+
+    def test_websocket_disabled_flag_set_from_env(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """CAS_WEBSOCKET_DISABLED=true sets _websocket_disabled flag."""
+        monkeypatch.setenv("CAS_WEBSOCKET_DISABLED", "true")
+
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        assert bridge._websocket_disabled is True
+
+    def test_websocket_disabled_flag_false_by_default(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """_websocket_disabled is False when env var not set."""
+        monkeypatch.delenv("CAS_WEBSOCKET_DISABLED", raising=False)
+
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        assert bridge._websocket_disabled is False
+
+    def test_websocket_disabled_flag_false_when_not_true(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """_websocket_disabled is False when env var is not 'true'."""
+        monkeypatch.setenv("CAS_WEBSOCKET_DISABLED", "false")
+
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        assert bridge._websocket_disabled is False
+
+    @pytest.mark.anyio
+    async def test_websocket_disabled_connect_logs_warning(
+        self, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """With CAS_WEBSOCKET_DISABLED=true, connect() logs warning but doesn't connect."""
+        monkeypatch.setenv("CAS_WEBSOCKET_DISABLED", "true")
+
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        with caplog.at_level(logging.WARNING):
+            await bridge.connect()
+
+        assert "debug mode" in caplog.text.lower()
+        assert "not connecting" in caplog.text.lower()
+        # Client should be created but not connected
+        assert bridge._client is not None
+        assert not bridge._connected_event.is_set()
+
+
+class TestGetChatBridgeCustomHost:
+    """Tests for get_chat_bridge with CAS_WEBSOCKET_HOST environment variable."""
+
+    def test_custom_websocket_host_env_var(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """CAS_WEBSOCKET_HOST overrides websocket URL to ws:// scheme."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.setenv("CAS_WEBSOCKET_HOST", "localhost:8080")
+
+        context = MockRuntimeContext()
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert "ws://localhost:8080" in bridge.websocket_url
+        assert "wss://" not in bridge.websocket_url
+
+    def test_custom_websocket_host_uses_simple_path(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Custom host uses /socket.io path instead of full path."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.setenv("CAS_WEBSOCKET_HOST", "localhost:8080")
+
+        context = MockRuntimeContext()
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.websocket_path == "/socket.io"
+
+    def test_default_websocket_url_without_custom_host(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Default URL construction without CAS_WEBSOCKET_HOST."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.delenv("CAS_WEBSOCKET_HOST", raising=False)
+
+        context = MockRuntimeContext(conversation_id="conv-abc")
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert "wss://cloud.uipath.com" in bridge.websocket_url
+        assert "conversationId=conv-abc" in bridge.websocket_url
+        assert bridge.websocket_path == "autopilotforeveryone_/websocket_/socket.io"
+
+    def test_get_chat_bridge_includes_conversation_id_in_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Conversation ID is included in websocket URL."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.delenv("CAS_WEBSOCKET_HOST", raising=False)
+
+        context = MockRuntimeContext(conversation_id="my-conversation-id")
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert "conversationId=my-conversation-id" in bridge.websocket_url
+
+
+class TestGetChatBridge:
+    """Tests for get_chat_bridge factory function."""
+
+    def test_get_chat_bridge_returns_socket_io_bridge(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Returns SocketIOChatBridge instance."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+
+        context = MockRuntimeContext()
+
+        bridge = get_chat_bridge(cast(Any, context))
+
+        assert isinstance(bridge, SocketIOChatBridge)
+
+    def test_get_chat_bridge_constructs_correct_headers(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Headers include Authorization and other required fields."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "my-access-token")
+
+        context = MockRuntimeContext(
+            tenant_id="tenant-123",
+            org_id="org-456",
+            conversation_id="conv-789",
+        )
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert "Authorization" in bridge.headers
+        assert "Bearer my-access-token" in bridge.headers["Authorization"]
+        assert "X-UiPath-Internal-TenantId" in bridge.headers
+        assert "X-UiPath-Internal-AccountId" in bridge.headers
+        assert "X-UiPath-ConversationId" in bridge.headers
+        assert bridge.headers["X-UiPath-ConversationId"] == "conv-789"
+
+    def test_get_chat_bridge_falls_back_to_env_when_tenant_and_org_absent(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Tenant/account headers fall back to env vars when context values are None."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "my-access-token")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "env-tenant")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "env-org")
+
+        context = MockRuntimeContext(
+            tenant_id=None,  # type: ignore[arg-type]
+            org_id=None,  # type: ignore[arg-type]
+            conversation_id="conv-789",
+        )
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.headers["X-UiPath-Internal-TenantId"] == "env-tenant"
+        assert bridge.headers["X-UiPath-Internal-AccountId"] == "env-org"
+
+    def test_get_chat_bridge_includes_conversational_user_id_header_when_set(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Conversation owner id (from FpsProperties) is sent on the handshake for CAS to validate."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "my-access-token")
+
+        context = MockRuntimeContext(conversation_id="conv-789")
+        context.conversational_user_id = "owner-guid"  # type: ignore[attr-defined]
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.headers["X-UiPath-Internal-ConversationalUserId"] == "owner-guid"
+
+    def test_get_chat_bridge_omits_conversational_user_id_header_when_absent(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """No header is sent when the runtime has no owner id (backward compatible)."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "my-access-token")
+
+        context = MockRuntimeContext(conversation_id="conv-789")
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert "X-UiPath-Internal-ConversationalUserId" not in bridge.headers
+
+    def test_get_chat_bridge_raises_without_uipath_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Raises RuntimeError if UIPATH_URL is not set."""
+        monkeypatch.delenv("UIPATH_URL", raising=False)
+
+        context = MockRuntimeContext()
+
+        with pytest.raises(RuntimeError) as exc_info:
+            get_chat_bridge(cast(Any, context))
+
+        assert "UIPATH_URL" in str(exc_info.value)
+
+    def test_get_chat_bridge_raises_with_invalid_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Raises RuntimeError if UIPATH_URL is invalid."""
+        monkeypatch.setenv("UIPATH_URL", "not-a-valid-url")
+
+        context = MockRuntimeContext()
+
+        with pytest.raises(RuntimeError) as exc_info:
+            get_chat_bridge(cast(Any, context))
+
+        assert "Invalid UIPATH_URL" in str(exc_info.value)
+
+    def test_get_chat_bridge_sets_exchange_id(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Exchange ID from context is set on bridge."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+
+        context = MockRuntimeContext(exchange_id="my-exchange-id")
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.exchange_id == "my-exchange-id"
+
+    def test_get_chat_bridge_sets_conversation_id(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Conversation ID from context is set on bridge."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+
+        context = MockRuntimeContext(conversation_id="my-conversation-id")
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.conversation_id == "my-conversation-id"
+
+
+class TestSocketIOChatBridgeConnectionStates:
+    """Tests for SocketIOChatBridge connection state handling."""
+
+    def test_is_connected_false_initially(self) -> None:
+        """is_connected is False before connecting."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        assert bridge.is_connected is False
+
+    @pytest.mark.anyio
+    async def test_emit_message_raises_without_client(self) -> None:
+        """emit_message_event raises RuntimeError if client not initialized."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        mock_message_event = MagicMock()
+        mock_message_event.message_id = "msg-123"
+
+        with pytest.raises(RuntimeError) as exc_info:
+            await bridge.emit_message_event(mock_message_event)
+
+        assert "not connected" in str(exc_info.value).lower()
+
+    @pytest.mark.anyio
+    async def test_emit_exchange_end_raises_without_client(self) -> None:
+        """emit_exchange_end_event raises RuntimeError if client not initialized."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        with pytest.raises(RuntimeError) as exc_info:
+            await bridge.emit_exchange_end_event()
+
+        assert "not connected" in str(exc_info.value).lower()
+
+
+class TestSocketIOChatBridgeEndExchange:
+    """The bridge owns whether to honor the exchange-end event (CAS-specific)."""
+
+    def _make_connected_bridge(self, end_exchange: bool) -> SocketIOChatBridge:
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+            end_exchange=end_exchange,
+        )
+        bridge._websocket_disabled = False
+        bridge._client = AsyncMock()
+        bridge._connected_event.set()
+        return bridge
+
+    def test_end_exchange_defaults_true(self) -> None:
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+        assert bridge.end_exchange is True
+
+    @pytest.mark.anyio
+    async def test_emit_exchange_end_sends_when_end_exchange_true(self) -> None:
+        bridge = self._make_connected_bridge(end_exchange=True)
+
+        await bridge.emit_exchange_end_event()
+
+        cast(AsyncMock, bridge._client).emit.assert_awaited_once()
+        assert (
+            cast(AsyncMock, bridge._client).emit.await_args.args[0]
+            == "ConversationEvent"
+        )
+
+    @pytest.mark.anyio
+    async def test_emit_exchange_end_suppressed_when_end_exchange_false(self) -> None:
+        bridge = self._make_connected_bridge(end_exchange=False)
+
+        await bridge.emit_exchange_end_event()
+
+        cast(AsyncMock, bridge._client).emit.assert_not_awaited()
+
+    @pytest.mark.anyio
+    async def test_emit_exchange_end_false_does_not_require_client(self) -> None:
+        """With the exchange kept open, suppression happens before the connection check."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+            end_exchange=False,
+        )
+
+        # Should not raise even though _client is None.
+        await bridge.emit_exchange_end_event()
+
+    def test_get_chat_bridge_propagates_end_exchange_false(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+        context = MockRuntimeContext(end_exchange=False)
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.end_exchange is False
+
+    def test_get_chat_bridge_defaults_end_exchange_true(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+        context = MockRuntimeContext()
+
+        bridge = cast(SocketIOChatBridge, get_chat_bridge(cast(Any, context)))
+
+        assert bridge.end_exchange is True
+
+
+class TestSignalRDebugBridgeSendMethod:
+    """Tests for SignalRDebugBridge."""
+
+    @pytest.mark.anyio
+    async def test_send_with_datetime_does_not_raise(self) -> None:
+        """_send method handles datetime objects without raising exceptions."""
+        bridge = SignalRDebugBridge(
+            hub_url="wss://test.example.com/signalr",
+            access_token="test-token",
+            headers={},
+        )
+
+        mock_client = MagicMock()
+        mock_client.send = AsyncMock()
+        bridge._client = mock_client
+
+        test_data = {
+            "timestamp": datetime(2024, 1, 15, 10, 30, 45),
+            "message": "test message",
+            "nested": {
+                "created_at": datetime(2024, 1, 15, 11, 0, 0),
+            },
+        }
+
+        await bridge._send("TestEvent", test_data)
+
+        assert mock_client.send.called
+        call_args = mock_client.send.call_args
+
+        assert call_args.kwargs["method"] == "SendCommand"
+
+        arguments = call_args.kwargs["arguments"]
+        assert len(arguments) == 2
+        assert arguments[0] == "TestEvent"
+
+        import json
+
+        parsed_data = json.loads(arguments[1])
+        assert "timestamp" in parsed_data
+        assert "message" in parsed_data
+        assert parsed_data["message"] == "test message"
+        assert isinstance(parsed_data["timestamp"], str)
+        assert isinstance(parsed_data["nested"]["created_at"], str)
+
+
+class TestEmitInterruptEvent:
+    """Tests for emit_interrupt_event (now a no-op for executingToolCall)."""
+
+    def _make_bridge(self) -> SocketIOChatBridge:
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+        bridge._current_message_id = "msg-100"
+        return bridge
+
+    @pytest.mark.anyio
+    async def test_emit_interrupt_event_is_noop(self) -> None:
+        """emit_interrupt_event no longer emits executingToolCall."""
+        bridge = self._make_bridge()
+
+        emitted_events: list[Any] = []
+
+        async def capture_emit(event: Any) -> None:
+            emitted_events.append(event)
+
+        bridge.emit_message_event = capture_emit  # type: ignore[assignment]
+
+        trigger = UiPathResumeTrigger(
+            api_resume=UiPathApiTrigger(
+                request={
+                    "tool_call_id": "tc-42",
+                    "tool_name": "my_tool",
+                    "input": {"key": "value"},
+                }
+            )
+        )
+
+        await bridge.emit_interrupt_event(trigger)
+
+        assert len(emitted_events) == 0
+
+
+class TestEmitExecutingToolCall:
+    """Tests for emit_executing_tool_call_event (post-confirmation executingToolCall emission)."""
+
+    def _make_bridge(self) -> SocketIOChatBridge:
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+        bridge._current_message_id = "msg-100"
+        return bridge
+
+    @pytest.mark.anyio
+    async def test_emits_executing_tool_call_event(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Should emit executingToolCall with tool_call_id and input."""
+        monkeypatch.setenv("CAS_WEBSOCKET_DISABLED", "true")
+        bridge = self._make_bridge()
+        await bridge.connect()
+
+        emitted_events: list[Any] = []
+        original_emit = bridge.emit_message_event
+
+        async def capture_emit(event: Any) -> None:
+            emitted_events.append(event)
+            await original_emit(event)
+
+        bridge.emit_message_event = capture_emit  # type: ignore[assignment]
+
+        await bridge.emit_executing_tool_call_event(
+            tool_call_id="tc-42",
+            tool_input={"key": "value"},
+        )
+
+        assert len(emitted_events) == 1
+        event = emitted_events[0]
+        assert event.message_id == "msg-100"
+        assert event.tool_call is not None
+        assert event.tool_call.tool_call_id == "tc-42"
+        assert event.tool_call.executing is not None
+        assert event.tool_call.executing.input == {"key": "value"}
+
+    @pytest.mark.anyio
+    async def test_no_message_id_does_not_emit(self) -> None:
+        """Should not emit if no current message ID is set."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+        # _current_message_id is not set
+
+        emitted_events: list[Any] = []
+
+        async def capture_emit(event: Any) -> None:
+            emitted_events.append(event)
+
+        bridge.emit_message_event = capture_emit  # type: ignore[assignment]
+
+        await bridge.emit_executing_tool_call_event(tool_call_id="tc-42")
+
+        assert len(emitted_events) == 0
+
+    @pytest.mark.anyio
+    async def test_none_input_emits_with_none(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Should emit with None input when no input provided."""
+        monkeypatch.setenv("CAS_WEBSOCKET_DISABLED", "true")
+        bridge = self._make_bridge()
+        await bridge.connect()
+
+        emitted_events: list[Any] = []
+        original_emit = bridge.emit_message_event
+
+        async def capture_emit(event: Any) -> None:
+            emitted_events.append(event)
+            await original_emit(event)
+
+        bridge.emit_message_event = capture_emit  # type: ignore[assignment]
+
+        await bridge.emit_executing_tool_call_event(tool_call_id="tc-42")
+
+        assert len(emitted_events) == 1
+        assert emitted_events[0].tool_call.executing.input is None
+
+
+class TestWaitForResumeEndToolCall:
+    """Tests for wait_for_resume unblocking on endToolCall events."""
+
+    @pytest.mark.anyio
+    async def test_end_tool_call_unblocks_wait_for_resume(self) -> None:
+        """Receiving an endToolCall event unblocks wait_for_resume and returns parsed payload."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        end_event = {
+            "conversationId": "conv-123",
+            "exchange": {
+                "exchangeId": "exch-456",
+                "message": {
+                    "messageId": "msg-200",
+                    "toolCall": {
+                        "toolCallId": "tc-99",
+                        "endToolCall": {
+                            "output": {"result": "ok"},
+                            "isError": False,
+                        },
+                    },
+                },
+            },
+        }
+
+        async def simulate_end_event() -> None:
+            await asyncio.sleep(0.05)
+            await bridge._handle_conversation_event(end_event, "sid-1")
+
+        task = asyncio.create_task(simulate_end_event())
+        result = await bridge.wait_for_resume()
+        await task
+
+        assert result["output"] == {"result": "ok"}
+        assert result["is_error"] is False
+
+    @pytest.mark.anyio
+    async def test_confirm_tool_call_unblocks_wait_for_resume(self) -> None:
+        """Receiving a confirmToolCall event also unblocks wait_for_resume."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        confirm_event = {
+            "conversationId": "conv-123",
+            "exchange": {
+                "exchangeId": "exch-456",
+                "message": {
+                    "messageId": "msg-200",
+                    "toolCall": {
+                        "toolCallId": "tc-99",
+                        "confirmToolCall": {
+                            "approved": True,
+                            "input": {"edited": "data"},
+                        },
+                    },
+                },
+            },
+        }
+
+        async def simulate_confirm_event() -> None:
+            await asyncio.sleep(0.05)
+            await bridge._handle_conversation_event(confirm_event, "sid-1")
+
+        task = asyncio.create_task(simulate_confirm_event())
+        result = await bridge.wait_for_resume()
+        await task
+
+        assert result["approved"] is True
+        assert result["input"] == {"edited": "data"}
+
+    @pytest.mark.anyio
+    async def test_early_end_tool_call_is_not_lost(self) -> None:
+        """An endToolCall that arrives before wait_for_resume is called must not be lost."""
+        bridge = SocketIOChatBridge(
+            websocket_url="wss://test.example.com",
+            websocket_path="/socket.io",
+            conversation_id="conv-123",
+            exchange_id="exch-456",
+            headers={},
+        )
+
+        end_event = {
+            "conversationId": "conv-123",
+            "exchange": {
+                "exchangeId": "exch-456",
+                "message": {
+                    "messageId": "msg-300",
+                    "toolCall": {
+                        "toolCallId": "tc-100",
+                        "endToolCall": {
+                            "output": {"early": True},
+                            "isError": False,
+                        },
+                    },
+                },
+            },
+        }
+
+        # Simulate the event arriving BEFORE wait_for_resume is called
+        await bridge._handle_conversation_event(end_event, "sid-1")
+
+        result = await bridge.wait_for_resume()
+
+        assert result["output"] == {"early": True}
+        assert result["is_error"] is False
diff --git a/packages/uipath/tests/cli/chat/test_voice_bridge.py b/packages/uipath/tests/cli/chat/test_voice_bridge.py
new file mode 100644
index 000000000..39e094bfa
--- /dev/null
+++ b/packages/uipath/tests/cli/chat/test_voice_bridge.py
@@ -0,0 +1,169 @@
+"""Tests for VoiceToolCallSession and get_voice_bridge."""
+
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from uipath._cli._chat._voice_bridge import (
+    VoiceSessionEndReason,
+    VoiceToolCallSession,
+    get_voice_bridge,
+)
+from uipath.core.chat import (
+    UiPathVoiceToolCallRequest,
+    UiPathVoiceToolCallResult,
+)
+
+
+def _make_session(tool_handler: Any = None) -> VoiceToolCallSession:
+    session = VoiceToolCallSession(
+        url="wss://example/test",
+        socketio_path="/socket.io",
+        headers={},
+        tool_handler=tool_handler or AsyncMock(),
+    )
+    session._client = MagicMock()
+    session._client.emit = AsyncMock()
+    return session
+
+
+class TestEndSession:
+    def test_first_writer_wins(self) -> None:
+        """A late DISCONNECTED must not overwrite COMPLETED."""
+        session = _make_session()
+        session._end_session(VoiceSessionEndReason.COMPLETED)
+        session._end_session(VoiceSessionEndReason.DISCONNECTED)
+        assert session._end_reason == VoiceSessionEndReason.COMPLETED
+        assert session._done.is_set()
+
+    async def test_session_ended_sets_completed(self) -> None:
+        session = _make_session()
+        await session._handle_session_ended(None)
+        assert session._end_reason == VoiceSessionEndReason.COMPLETED
+
+    async def test_disconnect_sets_disconnected(self) -> None:
+        session = _make_session()
+        await session._handle_disconnect()
+        assert session._end_reason == VoiceSessionEndReason.DISCONNECTED
+
+
+class TestHandleToolCall:
+    async def test_dispatches_handler_and_emits_result(self) -> None:
+        handler = AsyncMock(
+            return_value=UiPathVoiceToolCallResult(result="ok", is_error=False)
+        )
+        session = _make_session(handler)
+
+        await session._handle_tool_call(
+            {"calls": [{"callId": "c1", "toolName": "weather", "args": {"city": "SF"}}]}
+        )
+        # Drain the spawned task.
+        for task in list(session._in_flight):
+            await task
+
+        handler.assert_awaited_once()
+        assert handler.await_args is not None
+        call_arg = handler.await_args.args[0]
+        assert isinstance(call_arg, UiPathVoiceToolCallRequest)
+        assert call_arg.call_id == "c1"
+        assert call_arg.tool_name == "weather"
+
+        session._client.emit.assert_awaited_once_with(
+            "voice_tool_result",
+            {"callId": "c1", "result": "ok", "isError": False},
+        )
+
+    async def test_invalid_payload_is_skipped(self) -> None:
+        handler = AsyncMock()
+        session = _make_session(handler)
+
+        await session._handle_tool_call({"calls": []})  # min_length=1 violation
+
+        handler.assert_not_awaited()
+        session._client.emit.assert_not_awaited()
+
+    async def test_noop_after_session_ended(self) -> None:
+        handler = AsyncMock()
+        session = _make_session(handler)
+        session._done.set()
+
+        await session._handle_tool_call(
+            {"calls": [{"callId": "c1", "toolName": "x", "args": {}}]}
+        )
+
+        handler.assert_not_awaited()
+        assert not session._in_flight
+
+    async def test_handler_exception_emits_error_result(self) -> None:
+        handler = AsyncMock(side_effect=RuntimeError("boom"))
+        session = _make_session(handler)
+
+        await session._handle_tool_call(
+            {"calls": [{"callId": "c1", "toolName": "x", "args": {}}]}
+        )
+        for task in list(session._in_flight):
+            await task
+
+        session._client.emit.assert_awaited_once_with(
+            "voice_tool_result",
+            {"callId": "c1", "result": "boom", "isError": True},
+        )
+
+
+class TestGetVoiceBridge:
+    def test_raises_when_uipath_url_missing(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("UIPATH_URL", raising=False)
+        monkeypatch.delenv("CAS_WEBSOCKET_HOST", raising=False)
+        ctx = MagicMock(conversation_id="conv-1", tenant_id="t", org_id="o")
+
+        with pytest.raises(RuntimeError, match="UIPATH_URL"):
+            get_voice_bridge(ctx, AsyncMock())
+
+    def test_headers_fall_back_to_env_when_context_ids_are_none(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Regression: f"{None}" is truthy ("None"), so the `or` fallback was dead."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "env-tenant")
+        monkeypatch.setenv("UIPATH_ORGANIZATION_ID", "env-org")
+        ctx = MagicMock(conversation_id="conv-1", tenant_id=None, org_id=None)
+
+        bridge = get_voice_bridge(ctx, AsyncMock())
+
+        assert bridge._headers["X-UiPath-Internal-TenantId"] == "env-tenant"
+        assert bridge._headers["X-UiPath-Internal-AccountId"] == "env-org"
+
+    def test_includes_conversational_user_id_header_when_set(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Conversation owner id (from FpsProperties) is sent on the handshake for CAS to validate."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+        ctx = MagicMock(
+            conversation_id="conv-1",
+            tenant_id="t",
+            org_id="o",
+            conversational_user_id="owner-guid",
+        )
+
+        bridge = get_voice_bridge(ctx, AsyncMock())
+
+        assert bridge._headers["X-UiPath-Internal-ConversationalUserId"] == "owner-guid"
+
+    def test_omits_conversational_user_id_header_when_none(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """No header is sent when the runtime has no owner id (backward compatible)."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+        ctx = MagicMock(
+            conversation_id="conv-1",
+            tenant_id="t",
+            org_id="o",
+            conversational_user_id=None,
+        )
+
+        bridge = get_voice_bridge(ctx, AsyncMock())
+
+        assert "X-UiPath-Internal-ConversationalUserId" not in bridge._headers
diff --git a/tests/cli/conftest.py b/packages/uipath/tests/cli/conftest.py
similarity index 52%
rename from tests/cli/conftest.py
rename to packages/uipath/tests/cli/conftest.py
index 104776428..e84bf38f2 100644
--- a/tests/cli/conftest.py
+++ b/packages/uipath/tests/cli/conftest.py
@@ -3,18 +3,21 @@
 import pytest
 
 from tests.cli.utils.project_details import ProjectDetails
-from tests.cli.utils.uipath_json import UiPathJson
 
 
 @pytest.fixture
-def mock_env_vars() -> dict[str, str]:
-    """Fixture to provide mock environment variables."""
-    return {
+def mock_env_vars(monkeypatch) -> dict[str, str]:
+    """Fixture to provide mock environment variables and set them in os.environ."""
+    env_vars = {
         "UIPATH_URL": "https://cloud.uipath.com/organization/tenant",
         "UIPATH_TENANT_ID": "e150b32b-8815-4560-8243-055ffc9b7523",
         "UIPATH_ORGANIZATION_ID": "62d19041-d1aa-454d-958d-1375329845dc",
         "UIPATH_ACCESS_TOKEN": "mock_token",
     }
+    # Actually set the environment variables using monkeypatch
+    for key, value in env_vars.items():
+        monkeypatch.setenv(key, value)
+    return env_vars
 
 
 @pytest.fixture
@@ -26,19 +29,3 @@ def project_details() -> ProjectDetails:
         with open("tests/cli/mocks/pyproject.toml", "r") as file:
             data = file.read()
     return ProjectDetails.from_toml(data)
-
-
-@pytest.fixture
-def uipath_json(request) -> UiPathJson:
-    file_name = (
-        "uipath-mock.json"
-        if not hasattr(request, "param") or request.param is None
-        else request.param
-    )
-    if os.path.isfile(f"mocks/{file_name}"):
-        with open(f"mocks/{file_name}", "r") as file:
-            data = file.read()
-    else:
-        with open(f"tests/cli/mocks/{file_name}", "r") as file:
-            data = file.read()
-    return UiPathJson.from_json(data)
diff --git a/packages/uipath/tests/cli/contract/test_sdk_cli_alignment.py b/packages/uipath/tests/cli/contract/test_sdk_cli_alignment.py
new file mode 100644
index 000000000..a690727d4
--- /dev/null
+++ b/packages/uipath/tests/cli/contract/test_sdk_cli_alignment.py
@@ -0,0 +1,402 @@
+"""Contract tests to ensure CLI stays aligned with SDK.
+
+These tests catch:
+- SDK adds new required parameter → CLI missing option
+- SDK renames parameter → CLI option mismatch
+- SDK removes parameter → CLI has orphaned option
+"""
+
+import inspect
+from typing import Any, cast
+
+import click
+import pytest
+
+# Global CLI options that don't map to SDK parameters (or are handled globally)
+CLI_GLOBALS = {"format", "output", "folder_path", "folder_key", "debug"}
+PAGINATION_OPTIONS = {"limit", "offset", "page_size", "fetch_all"}
+# CLI-only options for UX/safety (don't map to SDK params)
+CLI_ONLY_OPTIONS = {"confirm", "dry_run"}
+
+# SDK parameters that are exposed as global CLI options
+# These appear in SDK methods but are handled by common_service_options decorator
+SDK_COMMON_PARAMS = {"folder_path", "folder_key"}
+
+
+def get_cli_option_names(cmd: click.Command) -> set[str]:
+    """Extract parameter names from a Click command (options AND arguments).
+
+    Args:
+        cmd: Click command to inspect
+
+    Returns:
+        Set of parameter names (normalized with underscores)
+    """
+    return {
+        param.name.replace("-", "_")
+        for param in cmd.params
+        if isinstance(param, (click.Option, click.Argument)) and param.name is not None
+    }
+
+
+def get_sdk_param_names(method) -> set[str]:
+    """Extract parameter names from SDK method signature.
+
+    Args:
+        method: SDK method to inspect
+
+    Returns:
+        Set of parameter names
+    """
+    sig = inspect.signature(method)
+    return {
+        name for name in sig.parameters if name not in ["self", "cls", "args", "kwargs"]
+    }
+
+
+def assert_cli_sdk_alignment(
+    cli_command: click.Command,
+    sdk_method: Any,
+    *,
+    exclude_cli: set[str] | None = None,
+    exclude_sdk: set[str] | None = None,
+    param_mappings: dict[str, str] | None = None,
+) -> None:
+    """Assert that CLI command options align with SDK method parameters.
+
+    This is the core contract test that prevents drift between CLI and SDK.
+
+    Args:
+        cli_command: Click command to check
+        sdk_method: SDK method to compare against
+        exclude_cli: CLI options to ignore (beyond globals)
+        exclude_sdk: SDK parameters to ignore
+        param_mappings: Dict mapping CLI param names to SDK param names
+                       e.g., {'bucket_name': 'name', 'remote_path': 'blob_file_path'}
+
+    Raises:
+        AssertionError: If parameters don't align
+    """
+    exclude_cli = (
+        (exclude_cli or set()) | CLI_GLOBALS | PAGINATION_OPTIONS | CLI_ONLY_OPTIONS
+    )
+    exclude_sdk = (exclude_sdk or set()) | SDK_COMMON_PARAMS
+    param_mappings = param_mappings or {}
+
+    cli_params = get_cli_option_names(cli_command) - exclude_cli
+    sdk_params = get_sdk_param_names(sdk_method) - exclude_sdk
+
+    # Apply parameter name mappings (CLI → SDK)
+    # Replace CLI param names with their SDK equivalents for comparison
+    cli_params_normalized = set(cli_params)
+    for cli_name, sdk_name in param_mappings.items():
+        if cli_name in cli_params:
+            cli_params_normalized.remove(cli_name)  # Remove CLI name
+            cli_params_normalized.add(sdk_name)  # Add SDK name
+
+    # Check for missing CLI options (SDK params not in CLI)
+    missing_in_cli = sdk_params - cli_params_normalized
+    assert not missing_in_cli, (
+        f"CLI command '{cli_command.name}' missing options for SDK parameters: {missing_in_cli}\n"
+        f"  SDK method: {sdk_method.__qualname__}\n"
+        f"  SDK params: {sdk_params}\n"
+        f"  CLI params: {cli_params}\n"
+        f"  CLI params (normalized): {cli_params_normalized}"
+    )
+
+    # This catches typos or when SDK parameters are removed/renamed
+    orphaned_in_cli = cli_params_normalized - sdk_params
+    assert not orphaned_in_cli, (
+        f"CLI command '{cli_command.name}' has orphaned options not in SDK: {orphaned_in_cli}\n"
+        f"  SDK method: {sdk_method.__qualname__}\n"
+        f"  SDK params: {sdk_params}\n"
+        f"  CLI params (normalized): {cli_params_normalized}\n"
+        f"  Hint: Check for typos in CLI option names or SDK parameter removals"
+    )
+
+
+# Parameter mappings: CLI param name → SDK param name
+# Used when CLI uses more user-friendly names than SDK
+PARAM_MAPPINGS = {
+    # context-grounding: --index-name maps to SDK 'name'
+    "context-grounding_list": {},
+    "context-grounding_retrieve": {
+        "index_name": "name",
+    },
+    "context-grounding_create": {
+        "index_name": "name",
+    },
+    "context-grounding_search": {
+        "index_name": "name",
+    },
+    "context-grounding_ingest": {
+        "index_name": "name",
+    },
+    "context-grounding_delete": {
+        "index_name": "name",
+    },
+    # deep-rag/batch-transform: --task-name maps to SDK 'name'
+    "context-grounding_deep-rag_start": {
+        "task_name": "name",
+    },
+    "context-grounding_deep-rag_retrieve": {
+        "task_id": "id",
+    },
+    "context-grounding_batch-transform_start": {
+        "task_name": "name",
+        "prefix": "storage_bucket_folder_path_prefix",
+        "target_file": "target_file_name",
+        "web_search": "enable_web_search_grounding",
+    },
+    "context-grounding_batch-transform_retrieve": {
+        "task_id": "id",
+    },
+    "context-grounding_batch-transform_download": {
+        "task_id": "id",
+        "output_file": "destination_path",
+    },
+    "buckets_files_download": {
+        "bucket_name": "name",
+        "remote_path": "blob_file_path",
+        "local_path": "destination_path",
+    },
+    "buckets_files_upload": {
+        "bucket_name": "name",
+        "local_path": "source_path",
+        "remote_path": "blob_file_path",
+    },
+    "buckets_files_delete": {
+        "bucket_name": "name",
+        "file_path": "blob_file_path",
+    },
+    "buckets_files_exists": {
+        "bucket_name": "name",
+        "file_path": "blob_file_path",
+    },
+    "buckets_files_list": {
+        "bucket_name": "name",
+    },
+    "buckets_files_search": {
+        "bucket_name": "name",
+        "pattern": "file_name_glob",
+    },
+    "buckets_create": {
+        "name": "name",  # CLI argument 'name' maps to SDK 'name'
+    },
+    "buckets_exists": {
+        "name": "name",  # CLI argument 'name' maps to SDK 'name'
+    },
+}
+
+# SDK parameters to exclude for specific commands
+# Used when SDK has optional params that CLI doesn't expose
+SDK_EXCLUSIONS = {
+    "context-grounding_list": set(),
+    "context-grounding_retrieve": {"include_system_indexes"},
+    "context-grounding_create": {"source", "embeddings_enabled", "is_encrypted"},
+    "context-grounding_search": {
+        "scope",
+        "number_of_results",
+        "include_system_indexes",
+    },
+    "context-grounding_ingest": set(),
+    "context-grounding_delete": set(),
+    "context-grounding_deep-rag_start": set(),
+    "context-grounding_deep-rag_retrieve": {"index_name"},
+    "context-grounding_batch-transform_start": {"output_columns"},
+    "context-grounding_batch-transform_retrieve": {"index_name"},
+    "context-grounding_batch-transform_download": {"index_name", "validate_status"},
+    "buckets_list": {
+        "name",
+        "skip",
+        "top",
+    },  # CLI doesn't expose filtering/pagination yet
+    "buckets_retrieve": set(),  # All params exposed
+    "buckets_create": {"identifier"},  # CLI doesn't expose identifier
+    "buckets_delete": {"key"},  # CLI uses name, not key (yet)
+    "buckets_exists": {"key"},  # CLI uses name, not key
+    "buckets_files_download": {"key"},  # CLI uses name, not key
+    "buckets_files_upload": {
+        "key",
+        "content",
+        "content_type",
+    },  # CLI uses name + file path
+    "buckets_files_delete": {"key"},  # CLI uses name, not key
+    "buckets_files_exists": {"key"},  # CLI uses name, not key
+    "buckets_files_list": {
+        "key",
+        "take_hint",
+        "continuation_token",
+    },  # CLI uses name, doesn't expose pagination
+    "buckets_files_search": {
+        "key",
+        "skip",
+        "top",
+    },  # CLI uses name, doesn't expose pagination
+}
+
+
+# Parameterized test for all service commands
+@pytest.mark.parametrize(
+    "service,command,sdk_class,sdk_method",
+    [
+        # Context Grounding
+        ("context-grounding", "list", "ContextGroundingService", "list_indexes"),
+        ("context-grounding", "retrieve", "ContextGroundingService", "retrieve"),
+        ("context-grounding", "create", "ContextGroundingService", "create_index"),
+        ("context-grounding", "search", "ContextGroundingService", "unified_search"),
+        ("context-grounding", "ingest", "ContextGroundingService", "ingest_by_name"),
+        ("context-grounding", "delete", "ContextGroundingService", "delete_by_name"),
+        (
+            "context-grounding_deep-rag",
+            "start",
+            "ContextGroundingService",
+            "start_deep_rag",
+        ),
+        (
+            "context-grounding_deep-rag",
+            "retrieve",
+            "ContextGroundingService",
+            "retrieve_deep_rag",
+        ),
+        (
+            "context-grounding_batch-transform",
+            "start",
+            "ContextGroundingService",
+            "start_batch_transform",
+        ),
+        (
+            "context-grounding_batch-transform",
+            "retrieve",
+            "ContextGroundingService",
+            "retrieve_batch_transform",
+        ),
+        (
+            "context-grounding_batch-transform",
+            "download",
+            "ContextGroundingService",
+            "download_batch_transform_result",
+        ),
+        # Buckets - bucket operations
+        ("buckets", "list", "BucketsService", "list"),
+        ("buckets", "retrieve", "BucketsService", "retrieve"),
+        ("buckets", "create", "BucketsService", "create"),
+        ("buckets", "delete", "BucketsService", "delete"),
+        ("buckets", "exists", "BucketsService", "exists"),
+        # Buckets - file operations (nested under 'files' subgroup)
+        ("buckets_files", "upload", "BucketsService", "upload"),
+        ("buckets_files", "download", "BucketsService", "download"),
+        ("buckets_files", "delete", "BucketsService", "delete_file"),
+        ("buckets_files", "exists", "BucketsService", "exists_file"),
+        ("buckets_files", "list", "BucketsService", "list_files"),
+        ("buckets_files", "search", "BucketsService", "get_files"),
+        # Phase 3 - Add as implemented
+        # ('assets', 'retrieve', 'AssetsService', 'retrieve'),
+        # ('queues', 'list_items', 'QueuesService', 'list_items'),
+    ],
+)
+def test_service_command_params_match_sdk(service, command, sdk_class, sdk_method):
+    """Verify CLI command options match SDK method parameters.
+
+    This test runs on every commit to catch SDK/CLI drift early.
+    """
+    from uipath._cli import services as cli_services
+    from uipath.platform import context_grounding as cg_module
+    from uipath.platform import orchestrator
+
+    # SDK class lookup: context-grounding lives in context_grounding, not orchestrator
+    if sdk_class == "ContextGroundingService":
+        sdk_cls = getattr(cg_module, sdk_class)
+    else:
+        sdk_cls = getattr(orchestrator, sdk_class)
+    sdk_meth = getattr(sdk_cls, sdk_method)
+
+    # Services that are nested sub-groups (e.g. "buckets_files" means
+    # cli_services.buckets.commands["files"].commands[command]).
+    # All other service keys resolve directly to a cli_services attribute
+    # (hyphens are converted to underscores: "context-grounding" → context_grounding).
+    NESTED_SERVICES = {
+        "buckets_files",
+        "context-grounding_deep-rag",
+        "context-grounding_batch-transform",
+    }
+
+    def _get_service_group(name: str) -> click.Group:
+        """Resolve a cli_services attribute, converting hyphens to underscores."""
+        return getattr(cli_services, name.replace("-", "_"))
+
+    if service in NESTED_SERVICES:
+        parent_name, sub_name = service.split("_", 1)
+        service_group = _get_service_group(parent_name)
+        subgroup = cast(click.Group, service_group.commands[sub_name])
+        cli_cmd = subgroup.commands[command.replace("_", "-")]
+    else:
+        service_group = _get_service_group(service)
+        cli_cmd = service_group.commands[command.replace("_", "-")]
+
+    # CLI-only options per command (beyond the global CLI_ONLY_OPTIONS set).
+    CLI_EXCLUSIONS: dict[str, set[str]] = {
+        # retrieve: --index-id routes to retrieve_by_id, not retrieve — exclude from alignment
+        "context-grounding_retrieve": {"index_id"},
+        # create: CLI-only options that build the source object internally
+        "context-grounding_create": {"source_file", "bucket_source", "file_type"},
+        # batch-transform start: --columns-file is CLI-only (reads JSON, builds output_columns)
+        "context-grounding_batch-transform_start": {"columns_file"},
+    }
+
+    # Get mappings and exclusions for this command
+    mapping_key = f"{service}_{command}"
+    param_mappings = PARAM_MAPPINGS.get(mapping_key, {})
+    sdk_exclusions = SDK_EXCLUSIONS.get(mapping_key, set())
+    cli_exclusions = CLI_EXCLUSIONS.get(mapping_key, set())
+
+    # Run alignment check
+    assert_cli_sdk_alignment(
+        cli_cmd,
+        sdk_meth,
+        param_mappings=param_mappings,
+        exclude_sdk=sdk_exclusions,
+        exclude_cli=cli_exclusions,
+    )
+
+
+def test_contract_test_infrastructure():
+    """Meta-test to verify contract test infrastructure works.
+
+    This ensures the contract test helpers themselves are working correctly.
+    """
+
+    # Create a simple test command
+    @click.command()
+    @click.option("--name")
+    @click.option("--value")
+    def test_cmd(name, value):
+        pass
+
+    # Create a matching method
+    def test_method(self, name, value):
+        pass
+
+    # Should not raise
+    assert_cli_sdk_alignment(test_cmd, test_method)
+
+
+def test_contract_test_detects_missing_cli_option():
+    """Meta-test to verify contract test detects missing CLI options."""
+
+    # CLI command missing 'value' option
+    @click.command()
+    @click.option("--name")
+    def test_cmd(name):
+        pass
+
+    # SDK method has both name and value
+    def test_method(self, name, value):
+        pass
+
+    # Should raise assertion error
+    with pytest.raises(AssertionError) as exc_info:
+        assert_cli_sdk_alignment(test_cmd, test_method)
+
+    assert "missing options" in str(exc_info.value).lower()
+    assert "value" in str(exc_info.value)
diff --git a/packages/uipath/tests/cli/eval/evals/eval-sets/default.json b/packages/uipath/tests/cli/eval/evals/eval-sets/default.json
new file mode 100644
index 000000000..f2136b94a
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/evals/eval-sets/default.json
@@ -0,0 +1,25 @@
+{
+  "version": "1.0",
+  "id": "default-eval-set-id",
+  "name": "Basic Evaluation Set",
+  "evaluatorRefs": [
+    "ExactMatchEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "default",
+      "name": "Default",
+      "inputs": {"foo":  "bar"},
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "foo": "bar"
+          }
+        }
+      }
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-09-04T18:54:58.379Z",
+  "updatedAt": "2025-09-04T18:55:55.416Z"
+}
diff --git a/packages/uipath/tests/cli/eval/evals/eval-sets/multiple-evals.json b/packages/uipath/tests/cli/eval/evals/eval-sets/multiple-evals.json
new file mode 100644
index 000000000..c7fee75cc
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/evals/eval-sets/multiple-evals.json
@@ -0,0 +1,37 @@
+{
+  "version": "1.0",
+  "id": "multiple-eval-set-id",
+  "name": "Multiple Evaluations Set",
+  "evaluatorRefs": [
+    "ExactMatchEvaluator"
+  ],
+  "evaluations": [
+    {
+      "id": "eval-1",
+      "name": "First Evaluation",
+      "inputs": {"foo": "bar"},
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "foo": "bar"
+          }
+        }
+      }
+    },
+    {
+      "id": "eval-2",
+      "name": "Second Evaluation",
+      "inputs": {"baz": "qux"},
+      "evaluationCriterias": {
+        "ExactMatchEvaluator": {
+          "expectedOutput": {
+            "baz": "qux"
+          }
+        }
+      }
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-09-04T18:54:58.379Z",
+  "updatedAt": "2025-09-04T18:55:55.416Z"
+}
diff --git a/packages/uipath/tests/cli/eval/evals/evaluators/exact-match.json b/packages/uipath/tests/cli/eval/evals/evaluators/exact-match.json
new file mode 100644
index 000000000..013030875
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/evals/evaluators/exact-match.json
@@ -0,0 +1,17 @@
+{
+  "version": "1.0",
+  "id": "ExactMatchEvaluator",
+  "description": "Checks if the response text exactly matches the expected value.",
+  "evaluatorTypeId": "uipath-exact-match",
+  "evaluatorConfig": {
+    "name": "ExactMatchEvaluator",
+    "targetOutputKey": "*",
+    "negated": false,
+    "ignoreCase": false,
+    "defaultEvaluationCriteria": {
+      "expectedOutput": {
+        "foo": "bar"
+      }
+    }
+  }
+}
diff --git a/packages/uipath/tests/cli/eval/mocks/test_cache_manager.py b/packages/uipath/tests/cli/eval/mocks/test_cache_manager.py
new file mode 100644
index 000000000..508d38357
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_cache_manager.py
@@ -0,0 +1,162 @@
+"""Tests for CacheManager."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from uipath.eval.mocks._cache_manager import CacheManager
+from uipath.eval.mocks._mock_context import cache_manager_context
+
+
+@pytest.fixture
+def cache_manager():
+    """Create a cache manager with a temp directory for tests."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cm = CacheManager(cache_dir=Path(tmpdir))
+        cache_manager_context.set(cm)
+        yield cm
+        cache_manager_context.set(None)
+
+
+def test_set_and_get_llm_mocker(cache_manager):
+    """Test setting and getting a cached response for LLM mocker."""
+    cache_key_data = {
+        "prompt_generation_args": {
+            "input": "test input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.7},
+    }
+
+    response = {"result": "test response"}
+
+    cache_manager.set(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data,
+        response=response,
+        function_name="test_function",
+    )
+
+    cached_response = cache_manager.get(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data,
+        function_name="test_function",
+    )
+
+    assert cached_response == response
+
+
+def test_set_and_get_input_mocker(cache_manager):
+    """Test setting and getting a cached response for input mocker."""
+    cache_key_data = {
+        "prompt_generation_args": {
+            "input": "test input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.7},
+    }
+
+    response = {"input": "test input"}
+
+    cache_manager.set(
+        mocker_type="input_mocker",
+        cache_key_data=cache_key_data,
+        response=response,
+        function_name="generate_llm_input",
+    )
+
+    cached_response = cache_manager.get(
+        mocker_type="input_mocker",
+        cache_key_data=cache_key_data,
+        function_name="generate_llm_input",
+    )
+
+    assert cached_response == response
+
+
+def test_cache_invalidation_on_prompt_args_change(cache_manager):
+    """Test that changing the prompt generation args invalidates the cache."""
+    cache_key_data1 = {
+        "prompt_generation_args": {
+            "input": "original input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.7},
+    }
+
+    cache_key_data2 = {
+        "prompt_generation_args": {
+            "input": "modified input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.7},
+    }
+
+    response1 = {"result": "response 1"}
+    response2 = {"result": "response 2"}
+
+    cache_manager.set(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data1,
+        response=response1,
+        function_name="test_function",
+    )
+
+    cache_manager.set(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data2,
+        response=response2,
+        function_name="test_function",
+    )
+
+    cached1 = cache_manager.get(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data1,
+        function_name="test_function",
+    )
+
+    cached2 = cache_manager.get(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data2,
+        function_name="test_function",
+    )
+
+    assert cached1 == response1
+    assert cached2 == response2
+
+
+def test_cache_invalidation_on_model_settings_change(cache_manager):
+    """Test that changing model settings invalidates the cache."""
+    cache_key_data1 = {
+        "prompt_generation_args": {
+            "input": "test input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.7},
+    }
+
+    cache_key_data2 = {
+        "prompt_generation_args": {
+            "input": "test input",
+        },
+        "response_format": {"type": "json"},
+        "completion_kwargs": {"temperature": 0.9},
+    }
+
+    response = {"result": "test response"}
+
+    cache_manager.set(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data1,
+        response=response,
+        function_name="test_function",
+    )
+
+    cached_response = cache_manager.get(
+        mocker_type="llm_mocker",
+        cache_key_data=cache_key_data2,
+        function_name="test_function",
+    )
+
+    assert cached_response is None
diff --git a/packages/uipath/tests/cli/eval/mocks/test_input_mocker.py b/packages/uipath/tests/cli/eval/mocks/test_input_mocker.py
new file mode 100644
index 000000000..a8a8a64ec
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_input_mocker.py
@@ -0,0 +1,121 @@
+from typing import Any
+
+import pytest
+from _pytest.monkeypatch import MonkeyPatch
+from pytest_httpx import HTTPXMock
+
+from uipath.eval.mocks._cache_manager import CacheManager
+from uipath.eval.mocks._input_mocker import generate_llm_input
+from uipath.eval.mocks._types import InputMockingStrategy, ModelSettings
+from uipath.eval.models.evaluation_set import (
+    EvaluationItem,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_generate_llm_input_with_model_settings(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    evaluation_item: dict[str, Any] = {
+        "id": "test-eval-id",
+        "name": "Test Input Generation",
+        "inputs": {},
+        "evaluationCriterias": {"Default Evaluator": {"result": 35}},
+        "expectedAgentBehavior": "Agent should multiply the numbers",
+        "inputMockingStrategy": {
+            "prompt": "Generate a multiplication query with 5 and 7",
+            "model": {
+                "model": "gpt-4o-mini-2024-07-18",
+                "temperature": 0.5,
+                "maxTokens": 150,
+            },
+        },
+        "evalSetId": "test-eval-set-id",
+        "createdAt": "2025-09-04T18:54:58.378Z",
+        "updatedAt": "2025-09-04T18:55:55.416Z",
+    }
+    eval_item = EvaluationItem(**evaluation_item)
+
+    assert isinstance(eval_item.input_mocking_strategy, InputMockingStrategy)
+    assert isinstance(eval_item.input_mocking_strategy.model, ModelSettings)
+    assert eval_item.input_mocking_strategy.model.model == "gpt-4o-mini-2024-07-18"
+    assert eval_item.input_mocking_strategy.model.temperature == 0.5
+    assert eval_item.input_mocking_strategy.model.max_tokens == 150
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+        },
+        "required": ["query"],
+        "additionalProperties": False,
+    }
+
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json={
+            "role": "assistant",
+            "id": "response-id",
+            "object": "chat.completion",
+            "created": 0,
+            "model": "gpt-4o-mini-2024-07-18",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": '{"query": "Calculate 5 times 7"}',
+                        "tool_calls": None,
+                    },
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 100,
+                "completion_tokens": 20,
+                "total_tokens": 120,
+            },
+        },
+    )
+
+    result = await generate_llm_input(
+        eval_item.input_mocking_strategy,
+        input_schema,
+        expected_behavior=eval_item.expected_agent_behavior,
+        expected_output={"result": 35},
+    )
+
+    # Verify the mocked input is correct
+    assert result == {"query": "Calculate 5 times 7"}
+
+    requests = httpx_mock.get_requests()
+    chat_completion_requests = [r for r in requests if "chat/completions" in str(r.url)]
+    assert len(chat_completion_requests) == 1, (
+        "Expected exactly one chat completion request"
+    )
+
+    # OpenAI returns content via response_format; no tool-call fallback needed.
+    import json
+
+    body = json.loads(chat_completion_requests[0].content.decode("utf-8"))
+    assert "response_format" in body
+    assert "tools" not in body
diff --git a/packages/uipath/tests/cli/eval/mocks/test_input_mocker_span.py b/packages/uipath/tests/cli/eval/mocks/test_input_mocker_span.py
new file mode 100644
index 000000000..d02c5d242
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_input_mocker_span.py
@@ -0,0 +1,269 @@
+"""Tests for Simulate Input span attributes."""
+
+import pytest
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from pytest_httpx import HTTPXMock
+
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.mocks._cache_manager import CacheManager
+from uipath.eval.mocks._input_mocker import generate_llm_input
+from uipath.eval.mocks._mocker import UiPathInputMockingError
+from uipath.eval.mocks._types import InputMockingStrategy, ModelSettings
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_simulate_input_span_attributes(httpx_mock: HTTPXMock, monkeypatch):
+    """Test that Simulate Input span has correct attributes."""
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    # Set up span exporter to capture spans
+    span_exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(span_exporter)
+
+    # Initialize trace manager with our exporter
+    trace_manager = UiPathTraceManager()
+    trace_manager.add_span_processor(span_processor)
+
+    try:
+        # Mock HTTP responses
+        httpx_mock.add_response(
+            url="https://example.com/agenthub_/llm/api/capabilities",
+            status_code=200,
+            json={},
+        )
+        httpx_mock.add_response(
+            url="https://example.com/orchestrator_/llm/api/capabilities",
+            status_code=200,
+            json={},
+        )
+        httpx_mock.add_response(
+            url="https://example.com/llm/api/chat/completions"
+            "?api-version=2024-08-01-preview",
+            status_code=200,
+            json={
+                "role": "assistant",
+                "id": "response-id",
+                "object": "chat.completion",
+                "created": 0,
+                "model": "gpt-4o-mini-2024-07-18",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": '{"name": "Alice", "greeting_style": "formal"}',
+                            "tool_calls": None,
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 100,
+                    "completion_tokens": 20,
+                    "total_tokens": 120,
+                },
+            },
+        )
+
+        # Create input mocking strategy
+        mocking_strategy = InputMockingStrategy(
+            prompt="Generate a formal greeting for Alice",
+            model=ModelSettings(
+                model="gpt-4o-mini-2024-07-18",
+                temperature=0.0,
+                maxTokens=150,
+            ),
+        )
+
+        input_schema = {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "greeting_style": {"type": "string"},
+            },
+            "required": ["name"],
+            "additionalProperties": False,
+        }
+
+        # Call generate_llm_input
+        result = await generate_llm_input(
+            mocking_strategy,
+            input_schema,
+            expected_behavior="Generate a formal greeting",
+            expected_output={"message": "Good day, Alice."},
+        )
+
+        # Verify the result
+        assert result == {"name": "Alice", "greeting_style": "formal"}
+
+        # Get captured spans
+        spans: list[ReadableSpan] = list(span_exporter.get_finished_spans())
+
+        # Find the "Simulate Input" span
+        simulate_input_spans = [s for s in spans if s.name == "Simulate Input"]
+        assert len(simulate_input_spans) == 1, (
+            f"Expected exactly one 'Simulate Input' span, "
+            f"found {len(simulate_input_spans)}"
+        )
+
+        simulate_span = simulate_input_spans[0]
+
+        # Verify span attributes match agents repo pattern
+        assert simulate_span.attributes is not None
+
+        # Check required custom attributes
+        assert simulate_span.attributes.get("span_type") == "simulatedInput", (
+            "span_type should be 'simulatedInput'"
+        )
+        assert simulate_span.attributes.get("type") == "simulatedInput", (
+            "type should be 'simulatedInput'"
+        )
+        assert simulate_span.attributes.get("uipath.custom_instrumentation") is True, (
+            "uipath.custom_instrumentation should be True"
+        )
+
+        # Check standard @traced attributes
+        assert simulate_span.attributes.get("input.mime_type") == "application/json"
+        assert "input.value" in simulate_span.attributes
+
+        # Verify input.value contains the function parameters
+        input_value = simulate_span.attributes.get("input.value")
+        assert input_value is not None
+        assert isinstance(input_value, str)
+        assert "mocking_strategy" in input_value
+        assert "input_schema" in input_value
+        assert "expected_behavior" in input_value
+        assert "expected_output" in input_value
+
+        # Check output attributes
+        assert simulate_span.attributes.get("output.mime_type") == "application/json"
+        assert "output.value" in simulate_span.attributes
+
+        # Verify output contains the generated input
+        output_value = simulate_span.attributes.get("output.value")
+        assert output_value is not None
+        assert isinstance(output_value, str)
+        assert '"name": "Alice"' in output_value
+        assert '"greeting_style": "formal"' in output_value
+
+    finally:
+        # Clean up trace manager
+        trace_manager.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_simulate_input_span_on_error(httpx_mock: HTTPXMock, monkeypatch):
+    """Test that Simulate Input span attributes are set even when function fails."""
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    # Set up span exporter
+    span_exporter = InMemorySpanExporter()
+    span_processor = SimpleSpanProcessor(span_exporter)
+    trace_manager = UiPathTraceManager()
+    trace_manager.add_span_processor(span_processor)
+
+    try:
+        # Mock HTTP responses - return invalid JSON to trigger error
+        httpx_mock.add_response(
+            url="https://example.com/agenthub_/llm/api/capabilities",
+            status_code=200,
+            json={},
+        )
+        httpx_mock.add_response(
+            url="https://example.com/orchestrator_/llm/api/capabilities",
+            status_code=200,
+            json={},
+        )
+        httpx_mock.add_response(
+            url="https://example.com/llm/api/chat/completions"
+            "?api-version=2024-08-01-preview",
+            status_code=200,
+            json={
+                "role": "assistant",
+                "id": "response-id",
+                "object": "chat.completion",
+                "created": 0,
+                "model": "gpt-4o-mini-2024-07-18",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": "invalid json{{{",  # Invalid JSON
+                            "tool_calls": None,
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 100,
+                    "completion_tokens": 20,
+                    "total_tokens": 120,
+                },
+            },
+        )
+        # The prose content above triggers the tool-call fallback; an empty
+        # response there fails the fallback too, producing the error span.
+        httpx_mock.add_response(
+            url="https://example.com/llm/api/chat/completions"
+            "?api-version=2024-08-01-preview",
+            status_code=200,
+            json={},
+        )
+
+        mocking_strategy = InputMockingStrategy(
+            prompt="Generate input",
+            model=ModelSettings(model="gpt-4o-mini-2024-07-18"),
+        )
+
+        input_schema = {
+            "type": "object",
+            "properties": {"name": {"type": "string"}},
+            "required": ["name"],
+            "additionalProperties": False,
+        }
+
+        # Call should fail due to invalid JSON
+        with pytest.raises(UiPathInputMockingError):
+            await generate_llm_input(
+                mocking_strategy,
+                input_schema,
+                expected_behavior="Test",
+                expected_output={},
+            )
+
+        # Get captured spans
+        spans: list[ReadableSpan] = list(span_exporter.get_finished_spans())
+
+        # Find the "Simulate Input" span
+        simulate_input_spans = [s for s in spans if s.name == "Simulate Input"]
+        assert len(simulate_input_spans) == 1
+
+        simulate_span = simulate_input_spans[0]
+
+        # Custom attributes should still be present (set at function start)
+        assert simulate_span.attributes is not None
+        assert simulate_span.attributes.get("span_type") == "simulatedInput"
+        assert simulate_span.attributes.get("type") == "simulatedInput"
+        assert simulate_span.attributes.get("uipath.custom_instrumentation") is True
+
+        # Input attributes should be present (set before execution)
+        assert simulate_span.attributes.get("input.mime_type") == "application/json"
+        assert "input.value" in simulate_span.attributes
+
+        # Output attributes will NOT be present (error occurred before output)
+        # The span should have error status instead
+        assert simulate_span.status.status_code.name == "ERROR"
+
+    finally:
+        trace_manager.shutdown()
diff --git a/packages/uipath/tests/cli/eval/mocks/test_mockable_arg_collision.py b/packages/uipath/tests/cli/eval/mocks/test_mockable_arg_collision.py
new file mode 100644
index 000000000..838e9d835
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_mockable_arg_collision.py
@@ -0,0 +1,107 @@
+"""Regression tests: @mockable must not collide with user args named `func`/`params`."""
+
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath.eval.mocks import mockable
+from uipath.eval.mocks._mock_runtime import (
+    clear_execution_context,
+    set_execution_context,
+)
+from uipath.eval.mocks._types import MockingContext
+from uipath.eval.models.evaluation_set import EvaluationItem
+
+_mock_span_collector = MagicMock()
+
+
+def _build_evaluation(
+    function_name: str, kwargs: dict[str, Any], value: Any
+) -> EvaluationItem:
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Test evaluation",
+        "inputs": {},
+        "evaluationCriterias": {"ExactMatchEvaluator": None},
+        "mockingStrategy": {
+            "type": "mockito",
+            "behaviors": [
+                {
+                    "function": function_name,
+                    "arguments": {"args": [], "kwargs": kwargs},
+                    "then": [{"type": "return", "value": value}],
+                }
+            ],
+        },
+    }
+    return EvaluationItem(**evaluation_item)
+
+
+class TestMockableArgCollision:
+    """Ensure `@mockable` works when the wrapped function has args named `func` or `params`."""
+
+    def test_sync_function_with_func_and_params_args(self):
+        """A sync mockable function that takes `func` and `params` kwargs should not raise."""
+
+        @mockable()
+        def test_function(func: str, params: dict[str, Any]) -> str:
+            raise NotImplementedError()
+
+        evaluation = _build_evaluation(
+            "test_function",
+            kwargs={"func": "some_func", "params": {"k": "v"}},
+            value="mocked_result",
+        )
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        try:
+            with patch("uipath.eval.mocks.mockable.UiPathSpanUtils"):
+                with patch("uipath.eval.mocks.mockable.trace"):
+                    result = test_function(func="some_func", params={"k": "v"})
+
+            assert result == "mocked_result"
+        finally:
+            clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_async_function_with_func_and_params_args(self):
+        """An async mockable function that takes `func` and `params` kwargs should not raise."""
+
+        @mockable()
+        async def test_function(func: str, params: dict[str, Any]) -> str:
+            raise NotImplementedError()
+
+        evaluation = _build_evaluation(
+            "test_function",
+            kwargs={"func": "some_func", "params": {"k": "v"}},
+            value="mocked_result",
+        )
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        try:
+            with patch("uipath.eval.mocks.mockable.UiPathSpanUtils"):
+                with patch("uipath.eval.mocks.mockable.trace"):
+                    result = await test_function(func="some_func", params={"k": "v"})
+
+            assert result == "mocked_result"
+        finally:
+            clear_execution_context()
diff --git a/packages/uipath/tests/cli/eval/mocks/test_mockable_mocked_annotation.py b/packages/uipath/tests/cli/eval/mocks/test_mockable_mocked_annotation.py
new file mode 100644
index 000000000..848ebeac1
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_mockable_mocked_annotation.py
@@ -0,0 +1,325 @@
+"""Unit tests for the mocked annotation feature in mockable decorator."""
+
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath.eval.mocks import mockable
+from uipath.eval.mocks._mock_runtime import (
+    clear_execution_context,
+    set_execution_context,
+)
+from uipath.eval.mocks._types import MockingContext
+from uipath.eval.mocks.mockable import MOCKED_ANNOTATION_KEY
+from uipath.eval.models.evaluation_set import EvaluationItem
+
+_mock_span_collector = MagicMock()
+
+
+class TestMockableMockedAnnotation:
+    """Tests for mocked annotation in mocked responses."""
+
+    def test_mocked_attribute_set_on_sync_mock_response(self):
+        """Verify mocked attribute is set to True on sync mocked function."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        def test_function() -> str:
+            raise NotImplementedError()
+
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "test_function",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": "mocked_result"}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        # Act
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result = test_function()
+
+        # Assert
+        assert result == "mocked_result"
+        mock_span_utils.get_parent_context.assert_called()
+        mock_trace.get_current_span.assert_called_with(context=mock_context)
+        mock_span.set_attribute.assert_called_with(MOCKED_ANNOTATION_KEY, True)
+
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_mocked_attribute_set_on_async_mock_response(self):
+        """Verify mocked attribute is set to True on async mocked function."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        async def test_function() -> str:
+            raise NotImplementedError()
+
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "test_function",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": "mocked_result"}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        # Act
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result = await test_function()
+
+        # Assert
+        assert result == "mocked_result"
+        mock_span_utils.get_parent_context.assert_called()
+        mock_trace.get_current_span.assert_called_with(context=mock_context)
+        mock_span.set_attribute.assert_called_with(MOCKED_ANNOTATION_KEY, True)
+
+        clear_execution_context()
+
+    def test_mocked_attribute_set_with_function_arguments(self):
+        """Verify mocked attribute is set when mock has function arguments."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        def test_function(x: int, y: int) -> int:
+            raise NotImplementedError()
+
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "test_function",
+                        "arguments": {"args": [], "kwargs": {"x": 5, "y": 3}},
+                        "then": [{"type": "return", "value": 8}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        # Act
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result = test_function(x=5, y=3)
+
+        # Assert
+        assert result == 8
+        mock_span.set_attribute.assert_called_with(MOCKED_ANNOTATION_KEY, True)
+
+        clear_execution_context()
+
+    def test_mocked_attribute_not_set_when_no_mock_found(self):
+        """Verify mocked attribute is NOT set when no mock is found."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        def test_function() -> str:
+            return "real_result"
+
+        # No execution context set - this should fall through to real implementation
+        # But we still need to mock the span calls to prevent errors
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result = test_function()
+
+        # Assert - should use real implementation
+        assert result == "real_result"
+        # set_attribute should still be called from the mock_response_generator,
+        # but the mock context path won't be taken since no execution context
+        # Actually, without execution context, no mock is found, so
+        # the decorator catches UiPathNoMockFoundError and calls the real function
+        # In this case, set_attribute might not be called or might be called
+        # Let's check the actual behavior
+
+        clear_execution_context()
+
+    def test_mocked_attribute_set_multiple_calls(self):
+        """Verify mocked attribute is set on each mock call."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        def test_function() -> str:
+            raise NotImplementedError()
+
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "test_function",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [
+                            {"type": "return", "value": "result1"},
+                            {"type": "return", "value": "result2"},
+                        ],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        # Act
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result1 = test_function()
+                result2 = test_function()
+
+        # Assert
+        assert result1 == "result1"
+        assert result2 == "result2"
+        # set_attribute should be called twice
+        assert mock_span.set_attribute.call_count == 2
+        # Both calls should set mocked to True
+        for call in mock_span.set_attribute.call_args_list:
+            assert call[0] == ("__uipath_response_mocked", True)
+
+        clear_execution_context()
+
+    def test_mocked_annotation_with_return_type_validation(self):
+        """Verify mocked attribute is set even when return type validation occurs."""
+        # Arrange
+        mock_span = MagicMock()
+        mock_context = MagicMock()
+
+        @mockable()
+        def test_function() -> int:
+            raise NotImplementedError()
+
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "test_function",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": 42}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        # Act
+        with patch("uipath.eval.mocks.mockable.UiPathSpanUtils") as mock_span_utils:
+            with patch("uipath.eval.mocks.mockable.trace") as mock_trace:
+                mock_span_utils.get_parent_context.return_value = mock_context
+                mock_trace.get_current_span.return_value = mock_span
+
+                result = test_function()
+
+        # Assert
+        assert result == 42
+        mock_span.set_attribute.assert_called_with("__uipath_response_mocked", True)
+
+        clear_execution_context()
diff --git a/packages/uipath/tests/cli/eval/mocks/test_mocks.py b/packages/uipath/tests/cli/eval/mocks/test_mocks.py
new file mode 100644
index 000000000..e59b07d2f
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_mocks.py
@@ -0,0 +1,1162 @@
+import json
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from _pytest.monkeypatch import MonkeyPatch
+from pydantic import BaseModel
+from pytest_httpx import HTTPXMock
+
+from uipath.eval.mocks import mockable
+from uipath.eval.mocks._cache_manager import CacheManager
+from uipath.eval.mocks._mock_context import (
+    _normalize_tool_name,
+    is_tool_simulated,
+)
+from uipath.eval.mocks._mock_runtime import (
+    clear_execution_context,
+    set_execution_context,
+)
+from uipath.eval.mocks._mocker import UiPathMockResponseGenerationError
+from uipath.eval.mocks._types import (
+    LLMMockingStrategy,
+    MockingContext,
+    MockitoMockingStrategy,
+    ToolSimulation,
+)
+from uipath.eval.models.evaluation_set import (
+    EvaluationItem,
+)
+
+_mock_span_collector = MagicMock()
+
+
+class TestSetExecutionContext:
+    """Tests for the set_execution_context function."""
+
+    def test_sets_mocker_to_none_when_context_is_none(self):
+        clear_execution_context()
+        set_execution_context(None, _mock_span_collector, "test-execution-id")
+        # Verify mocker context is None by checking is_tool_simulated returns False
+        assert is_tool_simulated("any_tool") is False
+        clear_execution_context()
+
+    def test_sets_mocker_to_none_when_strategy_is_none(self):
+        clear_execution_context()
+        context = MockingContext(
+            strategy=None,
+            name="test",
+            inputs={},
+        )
+        set_execution_context(context, _mock_span_collector, "test-execution-id")
+        # Verify mocker context is None by checking is_tool_simulated returns False
+        assert is_tool_simulated("any_tool") is False
+        clear_execution_context()
+
+    def test_creates_mocker_when_context_and_strategy_exist(self):
+        clear_execution_context()
+        context = MockingContext(
+            strategy=LLMMockingStrategy(
+                prompt="test prompt",
+                tools_to_simulate=[ToolSimulation(name="test_tool")],
+            ),
+            name="test",
+            inputs={},
+        )
+        set_execution_context(context, _mock_span_collector, "test-execution-id")
+        # Verify mocker context was created by checking is_tool_simulated returns True
+        assert is_tool_simulated("test_tool") is True
+        clear_execution_context()
+
+
+class TestNormalizeToolName:
+    """Tests for the _normalize_tool_name helper function."""
+
+    def test_replaces_underscores_with_spaces(self):
+        assert _normalize_tool_name("my_tool_name") == "my tool name"
+
+    def test_handles_no_underscores(self):
+        assert _normalize_tool_name("mytool") == "mytool"
+
+    def test_handles_empty_string(self):
+        assert _normalize_tool_name("") == ""
+
+    def test_handles_multiple_consecutive_underscores(self):
+        assert _normalize_tool_name("my__tool") == "my  tool"
+
+    def test_handles_leading_and_trailing_underscores(self):
+        assert _normalize_tool_name("_tool_") == " tool "
+
+
+class TestIsToolSimulated:
+    """Tests for the is_tool_simulated function."""
+
+    def test_returns_false_when_no_evaluation_context(self):
+        clear_execution_context()
+        assert is_tool_simulated("any_tool") is False
+
+    def test_returns_false_when_mocking_strategy_is_none(self):
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": None,
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("any_tool") is False
+        clear_execution_context()
+
+    def test_returns_true_for_llm_strategy_simulated_tool(self):
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "llm",
+                "prompt": "test prompt",
+                "toolsToSimulate": [{"name": "my_tool"}, {"name": "other_tool"}],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("my_tool") is True
+        assert is_tool_simulated("other_tool") is True
+        clear_execution_context()
+
+    def test_returns_false_for_llm_strategy_non_simulated_tool(self):
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "llm",
+                "prompt": "test prompt",
+                "toolsToSimulate": [{"name": "my_tool"}],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("not_simulated_tool") is False
+        clear_execution_context()
+
+    def test_returns_true_for_mockito_strategy_simulated_tool(self):
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "my_tool",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": "result"}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("my_tool") is True
+        clear_execution_context()
+
+    def test_returns_false_for_mockito_strategy_non_simulated_tool(self):
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "my_tool",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": "result"}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("not_simulated_tool") is False
+        clear_execution_context()
+
+    def test_handles_underscore_space_normalization_llm(self):
+        """Tool names with underscores should match config with spaces."""
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "llm",
+                "prompt": "test prompt",
+                "toolsToSimulate": [{"name": "my tool"}],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("my_tool") is True
+        clear_execution_context()
+
+    def test_handles_underscore_space_normalization_mockito(self):
+        """Tool names with underscores should match config with spaces."""
+        clear_execution_context()
+        evaluation_item: dict[str, Any] = {
+            "id": "evaluation-id",
+            "name": "Test evaluation",
+            "inputs": {},
+            "evaluationCriterias": {"ExactMatchEvaluator": None},
+            "mockingStrategy": {
+                "type": "mockito",
+                "behaviors": [
+                    {
+                        "function": "my tool",
+                        "arguments": {"args": [], "kwargs": {}},
+                        "then": [{"type": "return", "value": "result"}],
+                    }
+                ],
+            },
+        }
+        evaluation = EvaluationItem(**evaluation_item)
+        set_execution_context(
+            MockingContext(
+                strategy=evaluation.mocking_strategy,
+                name=evaluation.name,
+                inputs=evaluation.inputs,
+            ),
+            _mock_span_collector,
+            "test-execution-id",
+        )
+
+        assert is_tool_simulated("my_tool") is True
+        clear_execution_context()
+
+
+def test_mockito_mockable_sync():
+    # Arrange
+    @mockable()
+    def foo(*args, **kwargs):
+        raise NotImplementedError()
+
+    @mockable()
+    def foofoo(*args, **kwargs):
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "mockito",
+            "behaviors": [
+                {
+                    "function": "foo",
+                    "arguments": {"args": [], "kwargs": {}},
+                    "then": [
+                        {"type": "return", "value": "bar1"},
+                        {"type": "return", "value": "bar2"},
+                    ],
+                }
+            ],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, MockitoMockingStrategy)
+
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert foo() == "bar1"
+    assert foo() == "bar2"
+    assert foo() == "bar2"
+
+    with pytest.raises(UiPathMockResponseGenerationError):
+        assert foo(x=1)
+
+    with pytest.raises(NotImplementedError):
+        assert foofoo()
+
+    assert evaluation.mocking_strategy.behaviors[0].arguments is not None
+    evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {"x": 1}
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert foo(x=1) == "bar1"
+
+    evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {
+        "x": {"_target_": "mockito.any"}
+    }
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert foo(x=2) == "bar1"
+
+
+def test_mockito_mockable_sync_arguments_omitted():
+    """Test that omitting 'arguments' entirely matches any call"""
+
+    # Arrange
+    @mockable()
+    def bar(*args, **kwargs):
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock bar",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "mockito",
+            "behaviors": [
+                {
+                    "function": "bar",
+                    # No "arguments" field - should match any call
+                    "then": [{"type": "return", "value": "mocked"}],
+                }
+            ],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, MockitoMockingStrategy)
+    # Verify arguments is None when omitted
+    assert evaluation.mocking_strategy.behaviors[0].arguments is None
+
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    # All these should work - match any call signature
+    assert bar() == "mocked"
+    assert bar(x=1) == "mocked"
+    assert bar("positional") == "mocked"
+    assert bar(a=1, b=2, c=3) == "mocked"
+    assert bar("pos1", "pos2", key="value") == "mocked"
+
+
+@pytest.mark.asyncio
+async def test_mockito_mockable_async():
+    # Arrange
+    @mockable()
+    async def foo(*args, **kwargs):
+        raise NotImplementedError()
+
+    @mockable()
+    async def foofoo(*args, **kwargs):
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "mockito",
+            "behaviors": [
+                {
+                    "function": "foo",
+                    "arguments": {"args": [], "kwargs": {}},
+                    "then": [
+                        {"type": "return", "value": "bar1"},
+                        {"type": "return", "value": "bar2"},
+                    ],
+                }
+            ],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, MockitoMockingStrategy)
+
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert await foo() == "bar1"
+    assert await foo() == "bar2"
+    assert await foo() == "bar2"
+
+    with pytest.raises(UiPathMockResponseGenerationError):
+        assert await foo(x=1)
+
+    with pytest.raises(NotImplementedError):
+        assert await foofoo()
+
+    assert evaluation.mocking_strategy.behaviors[0].arguments is not None
+    evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {"x": 1}
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert await foo(x=1) == "bar1"
+
+    evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {
+        "x": {"_target_": "mockito.any"}
+    }
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+    assert await foo(x=2) == "bar1"
+
+
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+def test_llm_mockable_sync(httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    # Arrange
+    @mockable()
+    def foo(*args, **kwargs) -> str:
+        raise NotImplementedError()
+
+    @mockable()
+    def foofoo(*args, **kwargs):
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "llm",
+            "prompt": "response is 'bar1'",
+            "toolsToSimulate": [{"name": "foo"}],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json={
+            "id": "response-id",
+            "object": "",
+            "created": 0,
+            "model": "model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "ai",
+                        "content": '"bar1"',
+                        "tool_calls": None,
+                    },
+                    "finish_reason": "EOS",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1,
+                "completion_tokens": 1,
+                "total_tokens": 2,
+            },
+        },
+    )
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    assert foo() == "bar1"
+
+    mock_request = httpx_mock.get_request(method="POST")
+    assert mock_request
+    request = json.loads(mock_request.content.decode("utf-8"))
+    assert request["response_format"] == {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "OutputSchema",
+            "strict": False,
+            "schema": {"type": "string"},
+        },
+    }
+
+    with pytest.raises(NotImplementedError):
+        assert foofoo()
+    # Two empty responses: the response_format attempt and the tool-call fallback.
+    for _ in range(2):
+        httpx_mock.add_response(
+            url="https://example.com/llm/api/chat/completions"
+            "?api-version=2024-08-01-preview",
+            status_code=200,
+            json={},
+        )
+    with pytest.raises(UiPathMockResponseGenerationError):
+        assert foo()
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_llm_mockable_async(httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    # Arrange
+    @mockable()
+    async def foo(*args, **kwargs) -> str:
+        raise NotImplementedError()
+
+    @mockable()
+    async def foofoo(*args, **kwargs):
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "llm",
+            "prompt": "response is 'bar1'",
+            "toolsToSimulate": [{"name": "foo"}],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+
+    # Mock capability checks
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json={
+            "id": "response-id",
+            "object": "",
+            "created": 0,
+            "model": "model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "ai",
+                        "content": '"bar1"',
+                        "tool_calls": None,
+                    },
+                    "finish_reason": "EOS",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1,
+                "completion_tokens": 1,
+                "total_tokens": 2,
+            },
+        },
+    )
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    assert await foo() == "bar1"
+
+    mock_request = httpx_mock.get_request()
+    assert mock_request
+    request = json.loads(mock_request.content.decode("utf-8"))
+    assert request["response_format"] == {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "OutputSchema",
+            "strict": False,
+            "schema": {"type": "string"},
+        },
+    }
+
+    with pytest.raises(NotImplementedError):
+        assert await foofoo()
+
+    # Two empty responses: the response_format attempt and the tool-call fallback.
+    for _ in range(2):
+        httpx_mock.add_response(
+            url="https://example.com/llm/api/chat/completions"
+            "?api-version=2024-08-01-preview",
+            status_code=200,
+            json={},
+        )
+    with pytest.raises(UiPathMockResponseGenerationError):
+        assert await foo()
+
+
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+def test_llm_mockable_with_output_schema_sync(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    class ToolResponseMock(BaseModel):
+        content: str
+
+    # Arrange
+    @mockable(output_schema=ToolResponseMock.model_json_schema())
+    def foo(*args, **kwargs) -> dict[str, Any]:
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "llm",
+            "prompt": "response content is 'bar1'",
+            "toolsToSimulate": [{"name": "foo"}],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json={
+            "id": "response-id",
+            "object": "",
+            "created": 0,
+            "model": "model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "ai",
+                        "content": '{"content": "bar1"}',
+                        "tool_calls": None,
+                    },
+                    "finish_reason": "EOS",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1,
+                "completion_tokens": 1,
+                "total_tokens": 2,
+            },
+        },
+    )
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    assert foo() == {"content": "bar1"}
+    mock_request = httpx_mock.get_request()
+    assert mock_request
+    request = json.loads(mock_request.content.decode("utf-8"))
+    assert request["response_format"] == {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "OutputSchema",
+            "strict": False,
+            "schema": {
+                "required": ["content"],
+                "type": "object",
+                "additionalProperties": False,
+                "properties": {"content": {"type": "string"}},
+            },
+        },
+    }
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_llm_mockable_with_output_schema_async(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    class ToolResponseMock(BaseModel):
+        content: str
+
+    # Arrange
+    @mockable(output_schema=ToolResponseMock.model_json_schema())
+    async def foo(*args, **kwargs) -> dict[str, Any]:
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "llm",
+            "prompt": "response content is 'bar1'",
+            "toolsToSimulate": [{"name": "foo"}],
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json={
+            "id": "response-id",
+            "object": "",
+            "created": 0,
+            "model": "model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "ai",
+                        "content": '{"content": "bar1"}',
+                        "tool_calls": None,
+                    },
+                    "finish_reason": "EOS",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1,
+                "completion_tokens": 1,
+                "total_tokens": 2,
+            },
+        },
+    )
+    # Act & Assert
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    assert await foo() == {"content": "bar1"}
+    mock_request = httpx_mock.get_request()
+    assert mock_request
+    request = json.loads(mock_request.content.decode("utf-8"))
+    assert request["response_format"] == {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "OutputSchema",
+            "strict": False,
+            "schema": {
+                "required": ["content"],
+                "type": "object",
+                "additionalProperties": False,
+                "properties": {"content": {"type": "string"}},
+            },
+        },
+    }
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_llm_mockable_uses_tool_call_directly_for_non_openai(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    """Tool simulation works for non-OpenAI providers (AE-1646).
+
+    Non-OpenAI providers don't honor ``response_format`` on the normalized
+    gateway (Claude answers with prose, Gemini with empty content), so their
+    strategies go straight to a forced tool call — a single request.
+    """
+    monkeypatch.setenv("UIPATH_URL", "https://example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+    monkeypatch.setattr(CacheManager, "get", lambda *args, **kwargs: None)
+    monkeypatch.setattr(CacheManager, "set", lambda *args, **kwargs: None)
+
+    @mockable()
+    async def foo(*args, **kwargs) -> str:
+        raise NotImplementedError()
+
+    evaluation_item: dict[str, Any] = {
+        "id": "evaluation-id",
+        "name": "Mock foo",
+        "inputs": {},
+        "evaluationCriterias": {
+            "ExactMatchEvaluator": None,
+        },
+        "mockingStrategy": {
+            "type": "llm",
+            "prompt": "response is 'bar1'",
+            "toolsToSimulate": [{"name": "foo"}],
+            "model": {"model": "anthropic.claude-sonnet-4-5-20250929-v1:0"},
+        },
+    }
+    evaluation = EvaluationItem(**evaluation_item)
+    assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+    httpx_mock.add_response(
+        url="https://example.com/agenthub_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+    httpx_mock.add_response(
+        url="https://example.com/orchestrator_/llm/api/capabilities",
+        status_code=200,
+        json={},
+    )
+
+    def _completion(message: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "id": "response-id",
+            "object": "",
+            "created": 0,
+            "model": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+            "choices": [{"index": 0, "message": message, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+        }
+
+    # Claude goes straight to function calling: one request, one response.
+    httpx_mock.add_response(
+        url="https://example.com/llm/api/chat/completions"
+        "?api-version=2024-08-01-preview",
+        status_code=200,
+        json=_completion(
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {
+                        "id": "call_1",
+                        "name": "submit_tool_response",
+                        "arguments": {"response": "bar1"},
+                    }
+                ],
+            }
+        ),
+    )
+
+    set_execution_context(
+        MockingContext(
+            strategy=evaluation.mocking_strategy,
+            name=evaluation.name,
+            inputs=evaluation.inputs,
+        ),
+        _mock_span_collector,
+        "test-execution-id",
+    )
+
+    assert await foo() == "bar1"
+
+    requests = [
+        r for r in httpx_mock.get_requests() if "chat/completions" in str(r.url)
+    ]
+    assert len(requests) == 1
+    body = json.loads(requests[0].content.decode("utf-8"))
+    # Non-OpenAI providers use a forced tool call directly — no response_format.
+    assert body["tool_choice"] == {"type": "required"}
+    assert body["tools"][0]["name"] == "submit_tool_response"
+    assert "response_format" not in body
+
+
+class TestUiPathMockRuntime:
+    """Tests for UiPathMockRuntime execute/stream/get_schema paths."""
+
+    def _make_context(self) -> MockingContext:
+        return MockingContext(
+            strategy=LLMMockingStrategy(
+                prompt="test",
+                tools_to_simulate=[ToolSimulation(name="my_tool")],
+            ),
+            name="test",
+            inputs={},
+        )
+
+    async def test_execute_with_mocking_context_sets_and_clears(self):
+        from unittest.mock import AsyncMock, patch
+
+        from uipath.eval.mocks._mock_runtime import UiPathMockRuntime
+
+        delegate = MagicMock()
+        mock_result = MagicMock()
+        delegate.execute = AsyncMock(return_value=mock_result)
+
+        runtime = UiPathMockRuntime(
+            delegate=delegate,
+            mocking_context=self._make_context(),
+        )
+
+        with (
+            patch("uipath.eval.mocks._mock_runtime.set_execution_context") as mock_set,
+            patch(
+                "uipath.eval.mocks._mock_runtime.clear_execution_context"
+            ) as mock_clear,
+        ):
+            result = await runtime.execute({"key": "value"})
+
+        assert result is mock_result
+        mock_set.assert_called_once()
+        mock_clear.assert_called_once()
+
+    async def test_stream_with_mocking_context_sets_and_clears(self):
+        from unittest.mock import patch
+
+        from uipath.eval.mocks._mock_runtime import UiPathMockRuntime
+
+        sentinel = object()
+
+        async def _gen(*args, **kwargs):
+            yield sentinel
+
+        delegate = MagicMock()
+        delegate.stream = _gen
+
+        runtime = UiPathMockRuntime(
+            delegate=delegate,
+            mocking_context=self._make_context(),
+        )
+
+        with (
+            patch("uipath.eval.mocks._mock_runtime.set_execution_context") as mock_set,
+            patch(
+                "uipath.eval.mocks._mock_runtime.clear_execution_context"
+            ) as mock_clear,
+        ):
+            events = [e async for e in runtime.stream({})]
+
+        assert events == [sentinel]
+        mock_set.assert_called_once()
+        mock_clear.assert_called_once()
+
+    async def test_stream_without_mocking_context_passes_through(self):
+        from unittest.mock import patch
+
+        from uipath.eval.mocks._mock_runtime import UiPathMockRuntime
+
+        sentinel = object()
+
+        async def _gen(*args, **kwargs):
+            yield sentinel
+
+        delegate = MagicMock()
+        delegate.stream = _gen
+
+        runtime = UiPathMockRuntime(delegate=delegate, mocking_context=None)
+        with patch(
+            "uipath.eval.mocks._mock_runtime.load_simulation_config", return_value=None
+        ):
+            runtime._mocking_context = None
+            events = [e async for e in runtime.stream({})]
+
+        assert events == [sentinel]
+
+    async def test_get_schema_delegates(self):
+        from unittest.mock import AsyncMock, patch
+
+        from uipath.eval.mocks._mock_runtime import UiPathMockRuntime
+
+        schema = MagicMock()
+        delegate = MagicMock()
+        delegate.get_schema = AsyncMock(return_value=schema)
+
+        runtime = UiPathMockRuntime(delegate=delegate, mocking_context=None)
+        with patch(
+            "uipath.eval.mocks._mock_runtime.load_simulation_config", return_value=None
+        ):
+            result = await runtime.get_schema()
+
+        assert result is schema
+
+    def test_set_execution_context_handles_mocker_creation_failure(self):
+        from unittest.mock import patch
+
+        from uipath.eval._execution_context import ExecutionSpanCollector
+        from uipath.eval.mocks._mock_context import mocker_context
+        from uipath.eval.mocks._mock_runtime import set_execution_context
+
+        context = self._make_context()
+        with patch(
+            "uipath.eval.mocks._mock_runtime.MockerFactory.create",
+            side_effect=RuntimeError("boom"),
+        ):
+            set_execution_context(context, ExecutionSpanCollector(), "test-id")
+
+        # mocking_context is set, but mocker_context must be None on failure
+        assert mocker_context.get() is None
+        clear_execution_context()
diff --git a/packages/uipath/tests/cli/eval/mocks/test_simulate_component.py b/packages/uipath/tests/cli/eval/mocks/test_simulate_component.py
new file mode 100644
index 000000000..f4131cf48
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_simulate_component.py
@@ -0,0 +1,442 @@
+"""Tests for SimulateComponentMocker and SimulateComponentService."""
+
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from _pytest.monkeypatch import MonkeyPatch
+from pytest_httpx import HTTPXMock
+
+from uipath.eval.mocks._mock_context import is_tool_simulated
+from uipath.eval.mocks._mock_runtime import (
+    clear_execution_context,
+    set_execution_context,
+)
+from uipath.eval.mocks._mocker import (
+    UiPathMockResponseGenerationError,
+)
+from uipath.eval.mocks._simulate_component_mocker import SimulateComponentMocker
+from uipath.eval.mocks._simulate_component_service import (
+    SimulateComponentService,
+    _create_simulate_component_service,
+)
+from uipath.eval.mocks._types import (
+    ComponentSimulationConfig,
+    MockingContext,
+    SimulationStrategy,
+    UnknownMockingStrategy,
+)
+from uipath.eval.mocks.mockable import mockable
+
+_mock_span_collector = MagicMock()
+
+BASE_URL = "https://example.com"
+_SIMULATE_PATH = (
+    "uipath.eval.mocks._simulate_component_mocker._create_simulate_component_service"
+)
+
+
+def _make_context(
+    component_id: str = "my_tool",
+    strategy: SimulationStrategy = SimulationStrategy.LLM,
+    instruction: str = "simulate it",
+    workload_id: str = "wl-123",
+) -> MockingContext:
+    return MockingContext(
+        strategy=None,
+        name="test-run",
+        inputs={"q": "hello"},
+        workload_id=workload_id,
+        components=[
+            ComponentSimulationConfig(
+                component_id=component_id,
+                component_type="tool",
+                simulation_strategy=strategy,
+                simulation_instruction=instruction,
+            )
+        ],
+    )
+
+
+def _make_service_mock(result: dict[str, Any]) -> MagicMock:
+    svc = MagicMock()
+    svc.simulate = AsyncMock(return_value=result)
+    return svc
+
+
+# ---------------------------------------------------------------------------
+# is_tool_simulated with components format
+# ---------------------------------------------------------------------------
+
+
+class TestIsToolSimulatedWithComponents:
+    def setup_method(self):
+        clear_execution_context()
+
+    def teardown_method(self):
+        clear_execution_context()
+
+    def test_returns_true_for_listed_component(self):
+        set_execution_context(_make_context("search_tool"), _mock_span_collector, "x")
+        assert is_tool_simulated("search_tool") is True
+
+    def test_returns_false_for_unlisted_component(self):
+        set_execution_context(_make_context("search_tool"), _mock_span_collector, "x")
+        assert is_tool_simulated("other_tool") is False
+
+    def test_underscore_space_normalisation(self):
+        ctx = MockingContext(
+            strategy=None,
+            name="run",
+            inputs={},
+            components=[
+                ComponentSimulationConfig(
+                    component_id="web search",
+                    simulation_strategy=SimulationStrategy.LLM,
+                )
+            ],
+        )
+        set_execution_context(ctx, _mock_span_collector, "x")
+        assert is_tool_simulated("web_search") is True
+
+    def test_returns_false_when_components_list_is_empty(self):
+        ctx = MockingContext(strategy=None, name="run", inputs={}, components=[])
+        set_execution_context(ctx, _mock_span_collector, "x")
+        # components is set but empty — MockerFactory won't create a mocker (components is not None)
+        # is_tool_simulated: ctx.components is not None → iterates empty list → False
+        assert is_tool_simulated("any_tool") is False
+
+
+# ---------------------------------------------------------------------------
+# SimulateComponentMocker._find_component
+# ---------------------------------------------------------------------------
+
+
+class TestFindComponent:
+    def test_finds_by_exact_id(self):
+        mocker = SimulateComponentMocker(_make_context("my_tool"))
+        assert mocker._find_component("my_tool") is not None
+
+    def test_finds_by_underscore_to_space_normalisation(self):
+        ctx = MockingContext(
+            strategy=None,
+            name="run",
+            inputs={},
+            components=[
+                ComponentSimulationConfig(
+                    component_id="web search",
+                    simulation_strategy=SimulationStrategy.LLM,
+                )
+            ],
+        )
+        mocker = SimulateComponentMocker(ctx)
+        assert mocker._find_component("web_search") is not None
+
+    def test_returns_none_for_unknown_tool(self):
+        mocker = SimulateComponentMocker(_make_context("my_tool"))
+        assert mocker._find_component("unknown") is None
+
+
+# ---------------------------------------------------------------------------
+# SimulateComponentMocker.response — success path
+# ---------------------------------------------------------------------------
+
+
+class TestSimulateComponentMockerResponse:
+    @pytest.mark.asyncio
+    async def test_returns_simulated_output_on_status_1(self):
+        ctx = _make_context("my_tool")
+        svc_mock = _make_service_mock({"status": 1, "simulatedOutput": "hello"})
+
+        @mockable()
+        async def my_tool() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-1")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            result = await my_tool()
+
+        assert result == "hello"
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_raises_generation_error_on_non_1_status(self):
+        ctx = _make_context("my_tool")
+        svc_mock = _make_service_mock(
+            {"status": 2, "error": {"message": "LLM timeout"}}
+        )
+
+        @mockable()
+        async def my_tool() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-2")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            with pytest.raises(UiPathMockResponseGenerationError, match="LLM timeout"):
+                await my_tool()
+
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_raises_generic_error_when_error_message_missing(self):
+        ctx = _make_context("my_tool")
+        svc_mock = _make_service_mock({"status": 0, "error": {}})
+
+        @mockable()
+        async def my_tool() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-3")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            with pytest.raises(
+                UiPathMockResponseGenerationError, match="Simulation failed"
+            ):
+                await my_tool()
+
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_raises_generation_error_when_api_throws(self):
+        ctx = _make_context("my_tool")
+        svc_mock = MagicMock()
+        svc_mock.simulate = AsyncMock(side_effect=RuntimeError("network error"))
+
+        @mockable()
+        async def my_tool() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-4")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            with pytest.raises(
+                UiPathMockResponseGenerationError,
+                match="simulate-component API call failed",
+            ):
+                await my_tool()
+
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_raises_no_mock_found_for_unconfigured_tool(self):
+        ctx = _make_context("my_tool")
+
+        @mockable()
+        async def other_tool() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-5")
+        # other_tool is not in components → falls through to real function
+        with pytest.raises(NotImplementedError):
+            await other_tool()
+
+        clear_execution_context()
+
+
+# ---------------------------------------------------------------------------
+# Payload construction
+# ---------------------------------------------------------------------------
+
+
+class TestPayloadConstruction:
+    @pytest.mark.asyncio
+    async def test_payload_fields_sent_to_service(self):
+        ctx = _make_context("my_tool", instruction="Do something", workload_id="wl-99")
+        captured: list[dict[str, Any]] = []
+
+        async def _capture(payload, **kwargs):
+            captured.append(payload)
+            return {"status": 1, "simulatedOutput": "ok"}
+
+        svc_mock = MagicMock()
+        svc_mock.simulate = _capture
+
+        @mockable()
+        async def my_tool(x: int) -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-6")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            await my_tool(x=42)
+
+        assert len(captured) == 1
+        p = captured[0]
+        assert p["workloadId"] == "wl-99"
+        assert p["componentId"] == "my_tool"
+        assert p["componentType"] == "tool"
+        assert p["simulationInstruction"] == "Do something"
+        assert p["simulationStrategy"] == int(SimulationStrategy.LLM)
+        assert p["workloadInfo"] == {"name": "test-run", "userInput": {"q": "hello"}}
+
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_sync_mockable_also_works(self):
+        ctx = _make_context("sync_tool")
+        svc_mock = _make_service_mock({"status": 1, "simulatedOutput": 42})
+
+        @mockable()
+        def sync_tool() -> int:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-7")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            result = sync_tool()
+
+        assert result == 42
+        clear_execution_context()
+
+    @pytest.mark.asyncio
+    async def test_payload_uses_configured_component_id_not_invoked_name(self):
+        """componentId in payload must be the configured ID, not the normalised call name."""
+        ctx = MockingContext(
+            strategy=None,
+            name="run",
+            inputs={},
+            components=[
+                ComponentSimulationConfig(
+                    component_id="web search",
+                    simulation_strategy=SimulationStrategy.LLM,
+                )
+            ],
+        )
+        captured: list[dict[str, Any]] = []
+
+        async def _capture(payload, **kwargs):
+            captured.append(payload)
+            return {"status": 1, "simulatedOutput": "ok"}
+
+        svc_mock = MagicMock()
+        svc_mock.simulate = _capture
+
+        @mockable()
+        async def web_search() -> str:
+            raise NotImplementedError()
+
+        set_execution_context(ctx, _mock_span_collector, "exec-8")
+        with patch(_SIMULATE_PATH, return_value=svc_mock):
+            await web_search()
+
+        assert captured[0]["componentId"] == "web search"
+        clear_execution_context()
+
+
+# ---------------------------------------------------------------------------
+# _build_execution_history — uncovered branch (no context vars set)
+# ---------------------------------------------------------------------------
+
+
+class TestBuildExecutionHistory:
+    def test_returns_none_when_context_vars_not_set(self):
+        clear_execution_context()
+        mocker = SimulateComponentMocker(_make_context())
+        assert mocker._build_execution_history() is None
+
+    def test_returns_none_when_spans_empty(self):
+        from uipath.eval._execution_context import (
+            execution_id_context,
+            span_collector_context,
+        )
+
+        span_collector = MagicMock()
+        span_collector.get_spans = MagicMock(return_value=[])
+        span_collector_context.set(span_collector)
+        execution_id_context.set("exec-id")
+
+        mocker = SimulateComponentMocker(_make_context())
+        assert mocker._build_execution_history() is None
+
+        clear_execution_context()
+
+
+# ---------------------------------------------------------------------------
+# MockerFactory — unknown strategy raises ValueError
+# ---------------------------------------------------------------------------
+
+
+class TestMockerFactory:
+    def test_raises_for_unknown_strategy(self):
+        from uipath.eval.mocks._mocker_factory import MockerFactory
+
+        ctx = MockingContext(
+            strategy=UnknownMockingStrategy(type="future_strategy"),
+            name="test",
+            inputs={},
+            components=None,
+        )
+        with pytest.raises(ValueError, match="Unknown mocking strategy"):
+            MockerFactory.create(ctx)
+
+    def test_raises_for_none_strategy_and_no_components(self):
+        from uipath.eval.mocks._mocker_factory import MockerFactory
+
+        ctx = MockingContext(strategy=None, name="test", inputs={}, components=None)
+        with pytest.raises(ValueError, match="Unknown mocking strategy"):
+            MockerFactory.create(ctx)
+
+
+# ---------------------------------------------------------------------------
+# is_tool_simulated — unknown strategy falls through to False
+# ---------------------------------------------------------------------------
+
+
+class TestIsToolSimulatedUnknownStrategy:
+    def setup_method(self):
+        clear_execution_context()
+
+    def teardown_method(self):
+        clear_execution_context()
+
+    def test_returns_false_for_unknown_strategy(self):
+
+        ctx = MockingContext(
+            strategy=UnknownMockingStrategy(type="future_strategy"),
+            name="test",
+            inputs={},
+            components=None,
+        )
+        set_execution_context(ctx, _mock_span_collector, "x")
+        assert is_tool_simulated("any_tool") is False
+
+
+# ---------------------------------------------------------------------------
+# SimulateComponentService — actual HTTP call
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_simulate_component_service_http_call(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com/myorg/mytenant")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "token")
+
+    httpx_mock.add_response(
+        url="https://example.com/myorg/mytenant/agentsruntime_/api/execution/simulations/simulate-component",
+        method="POST",
+        json={"status": 1, "simulatedOutput": "result"},
+    )
+
+    service = _create_simulate_component_service()
+    assert isinstance(service, SimulateComponentService)
+
+    result = await service.simulate({"componentId": "my_tool"})
+    assert result == {"status": 1, "simulatedOutput": "result"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.httpx_mock(assert_all_responses_were_requested=False)
+async def test_simulate_component_service_no_headers(
+    httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch
+):
+    monkeypatch.setenv("UIPATH_URL", "https://example.com/myorg/mytenant")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "token")
+
+    httpx_mock.add_response(
+        url="https://example.com/myorg/mytenant/agentsruntime_/api/execution/simulations/simulate-component",
+        method="POST",
+        json={"status": 0, "error": {"message": "boom"}},
+    )
+
+    service = _create_simulate_component_service()
+    result = await service.simulate({"componentId": "my_tool"})
+    assert result["status"] == 0
diff --git a/packages/uipath/tests/cli/eval/mocks/test_structured_output.py b/packages/uipath/tests/cli/eval/mocks/test_structured_output.py
new file mode 100644
index 000000000..79ad31591
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/mocks/test_structured_output.py
@@ -0,0 +1,295 @@
+"""Unit tests for the provider-agnostic structured-output helpers."""
+
+import json
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from uipath.eval.mocks._structured_output import (
+    RESPONSE_KEY,
+    RESPONSE_TOOL_NAME,
+    build_response_tool,
+    extract_response,
+    generate_structured_output,
+)
+
+
+def _response(message: SimpleNamespace | None) -> SimpleNamespace:
+    choices = [] if message is None else [SimpleNamespace(message=message)]
+    return SimpleNamespace(choices=choices)
+
+
+class _FakeLLM:
+    """Records chat_completions calls and replays queued responses in order."""
+
+    def __init__(self, responses: list[Any]):
+        self._responses = list(responses)
+        self.calls: list[dict[str, Any]] = []
+
+    async def chat_completions(self, messages: Any, **kwargs: Any) -> Any:
+        self.calls.append(kwargs)
+        nxt = self._responses.pop(0)
+        if isinstance(nxt, Exception):
+            raise nxt
+        return nxt
+
+
+def test_build_response_tool_wraps_schema_under_response():
+    tool = build_response_tool({"type": "string"}, description="desc")
+    assert tool["name"] == RESPONSE_TOOL_NAME
+    assert tool["description"] == "desc"
+    assert tool["parameters"]["properties"][RESPONSE_KEY] == {"type": "string"}
+    assert tool["parameters"]["required"] == [RESPONSE_KEY]
+
+
+def test_build_response_tool_inlines_refs_into_self_contained_schema():
+    # Nested Pydantic models / enums emit $defs + $ref. The normalized gateway
+    # accepts $ref/$defs in response_format but NOT in a tool's parameters, so the
+    # schema must be inlined into a self-contained form (no $ref/$defs anywhere).
+    operator_def = {"enum": ["+", "-", "*", "/"], "type": "string"}
+    item_def = {"type": "object", "properties": {"sku": {"type": "string"}}}
+    schema = {
+        "type": "object",
+        "properties": {
+            "operator": {"$ref": "#/$defs/Operator"},
+            "items": {"type": "array", "items": {"$ref": "#/$defs/Item"}},
+        },
+        "required": ["operator"],
+        "$defs": {"Operator": operator_def, "Item": item_def},
+    }
+
+    tool = build_response_tool(schema, description="d")
+    params = tool["parameters"]
+
+    blob = json.dumps(params)
+    assert "$ref" not in blob
+    assert "$defs" not in blob
+
+    response = params["properties"][RESPONSE_KEY]
+    assert response["properties"]["operator"] == operator_def
+    assert response["properties"]["items"]["items"] == item_def
+    # caller's schema is not mutated
+    assert "$defs" in schema
+
+
+def test_build_response_tool_keeps_defs_for_cyclic_refs():
+    # Self-referential schemas can't be fully inlined; keep $defs hoisted so the
+    # remaining $ref still resolves rather than infinite-looping.
+    node_def = {
+        "type": "object",
+        "properties": {"child": {"$ref": "#/$defs/Node"}},
+    }
+    schema = {
+        "type": "object",
+        "properties": {"root": {"$ref": "#/$defs/Node"}},
+        "$defs": {"Node": node_def},
+    }
+
+    tool = build_response_tool(schema, description="d")
+    params = tool["parameters"]
+
+    assert "$defs" in params
+    assert "$ref" in json.dumps(params)
+    # the caller's schema dict is not mutated
+    assert "$defs" in schema
+
+
+def test_extract_response_returns_wrapped_value():
+    message = SimpleNamespace(
+        content=None,
+        tool_calls=[SimpleNamespace(arguments={RESPONSE_KEY: {"a": 1}})],
+    )
+    assert extract_response(_response(message)) == {"a": 1}
+
+
+def test_extract_response_raises_when_no_choices():
+    with pytest.raises(ValueError, match="no choices"):
+        extract_response(_response(None))
+
+
+def test_extract_response_raises_when_no_tool_calls():
+    # Non-OpenAI text response without a tool call: surface a clear error.
+    message = SimpleNamespace(content="not a tool call", tool_calls=None)
+    with pytest.raises(ValueError, match="no tool calls"):
+        extract_response(_response(message))
+
+
+def test_extract_response_raises_when_response_key_missing():
+    message = SimpleNamespace(
+        content=None, tool_calls=[SimpleNamespace(arguments={"other": 1})]
+    )
+    with pytest.raises(ValueError, match=RESPONSE_KEY):
+        extract_response(_response(message))
+
+
+@pytest.mark.asyncio
+async def test_generate_structured_output_prefers_response_format_content():
+    # OpenAI returns content via response_format; no fallback call is made.
+    llm = _FakeLLM([_response(SimpleNamespace(content='{"a": 1}', tool_calls=None))])
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "object"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={},
+    )
+    assert result == {"a": 1}
+    assert len(llm.calls) == 1
+    assert "response_format" in llm.calls[0]
+    assert "tools" not in llm.calls[0]
+
+
+@pytest.mark.asyncio
+async def test_generate_structured_output_falls_back_on_prose_content():
+    # Claude on the normalized gateway answers response_format requests with
+    # plain prose (e.g. "Tokyo") — truthy but not JSON. Must fall back to tools
+    # instead of raising JSONDecodeError (AE-1646).
+    llm = _FakeLLM(
+        [
+            _response(SimpleNamespace(content="Tokyo", tool_calls=None)),
+            _response(
+                SimpleNamespace(
+                    content=None,
+                    tool_calls=[SimpleNamespace(arguments={RESPONSE_KEY: {"a": 1}})],
+                )
+            ),
+        ]
+    )
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "object"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={},
+    )
+    assert result == {"a": 1}
+    assert len(llm.calls) == 2
+    assert "tools" in llm.calls[1]
+
+
+@pytest.mark.asyncio
+async def test_generate_structured_output_falls_back_on_empty_content():
+    # Non-OpenAI: response_format yields empty content -> fall back to tool call.
+    llm = _FakeLLM(
+        [
+            _response(SimpleNamespace(content=None, tool_calls=None)),
+            _response(
+                SimpleNamespace(
+                    content=None,
+                    tool_calls=[SimpleNamespace(arguments={RESPONSE_KEY: {"a": 1}})],
+                )
+            ),
+        ]
+    )
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "object"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={},
+    )
+    assert result == {"a": 1}
+    assert len(llm.calls) == 2
+    assert "response_format" in llm.calls[0]
+    assert "tools" in llm.calls[1] and "tool_choice" in llm.calls[1]
+
+
+@pytest.mark.asyncio
+async def test_generate_structured_output_falls_back_when_response_format_raises():
+    # A provider that rejects response_format outright still gets a tool fallback.
+    llm = _FakeLLM(
+        [
+            RuntimeError("response_format unsupported"),
+            _response(
+                SimpleNamespace(
+                    content=None,
+                    tool_calls=[SimpleNamespace(arguments={RESPONSE_KEY: "ok"})],
+                )
+            ),
+        ]
+    )
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "string"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={},
+    )
+    assert result == "ok"
+    assert len(llm.calls) == 2
+
+
+def test_build_response_tool_merges_ref_sibling_keys():
+    # Pydantic can emit sibling keys (e.g. description) next to $ref; they
+    # must survive inlining since they guide the LLM.
+    schema = {
+        "type": "object",
+        "properties": {
+            "op": {"$ref": "#/$defs/Op", "description": "the operator to use"}
+        },
+        "$defs": {"Op": {"type": "string", "enum": ["+", "-"]}},
+    }
+    tool = build_response_tool(schema, description="d")
+    op = tool["parameters"]["properties"][RESPONSE_KEY]["properties"]["op"]
+    assert op == {
+        "type": "string",
+        "enum": ["+", "-"],
+        "description": "the operator to use",
+    }
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "model",
+    [
+        "anthropic.claude-sonnet-4-5-20250929-v1:0",
+        "claude-haiku-4-5",
+        "gemini-2.5-pro",
+    ],
+)
+async def test_non_openai_models_use_tool_call_directly(model: str):
+    # Claude/Gemini don't honor response_format on the normalized gateway, so
+    # their strategies skip it entirely: a single forced tool call.
+    llm = _FakeLLM(
+        [
+            _response(
+                SimpleNamespace(
+                    content=None,
+                    tool_calls=[SimpleNamespace(arguments={RESPONSE_KEY: "ok"})],
+                )
+            )
+        ]
+    )
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "string"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={"model": model},
+    )
+    assert result == "ok"
+    assert len(llm.calls) == 1
+    assert "tools" in llm.calls[0] and "tool_choice" in llm.calls[0]
+    assert "response_format" not in llm.calls[0]
+
+
+@pytest.mark.asyncio
+async def test_openai_models_prefer_response_format():
+    llm = _FakeLLM([_response(SimpleNamespace(content='{"a": 1}', tool_calls=None))])
+    result = await generate_structured_output(
+        llm,
+        [{"role": "user", "content": "x"}],
+        schema={"type": "object"},
+        response_format_name="OutputSchema",
+        description="d",
+        completion_kwargs={"model": "gpt-4.1-mini-2025-04-14"},
+    )
+    assert result == {"a": 1}
+    assert len(llm.calls) == 1
+    assert "response_format" in llm.calls[0]
diff --git a/packages/uipath/tests/cli/eval/test_apply_file_overrides.py b/packages/uipath/tests/cli/eval/test_apply_file_overrides.py
new file mode 100644
index 000000000..9b6400b20
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_apply_file_overrides.py
@@ -0,0 +1,378 @@
+"""Tests for _apply_file_overrides_to_conversational_inputs in uipath.eval.helpers."""
+
+from typing import Any
+
+from uipath.eval.helpers import _apply_file_overrides_to_conversational_inputs
+from uipath.eval.models._conversational_utils import (
+    LegacyConversationalEvalInput,
+    LegacyConversationalEvalInputAgentMessage,
+    LegacyConversationalEvalJobAttachmentReference,
+    LegacyConversationalEvalUserMessage,
+)
+
+
+def _make_attachment(
+    id: str, full_name: str, mime_type: str = "application/pdf"
+) -> LegacyConversationalEvalJobAttachmentReference:
+    return LegacyConversationalEvalJobAttachmentReference(
+        ID=id, FullName=full_name, MimeType=mime_type
+    )
+
+
+def _make_conversational_inputs(
+    current_prompt_text: str = "hello",
+    current_prompt_attachments: list[LegacyConversationalEvalJobAttachmentReference]
+    | None = None,
+    conversation_history: list[list[Any]] | None = None,
+) -> LegacyConversationalEvalInput:
+    current_user_prompt = LegacyConversationalEvalUserMessage(
+        role="user",
+        text=current_prompt_text,
+        attachments=current_prompt_attachments,
+    )
+    return LegacyConversationalEvalInput(
+        conversationHistory=conversation_history or [],
+        currentUserPrompt=current_user_prompt,
+    )
+
+
+class TestApplyFileOverridesNoOp:
+    """Tests where the function should be a no-op."""
+
+    def test_empty_overrides(self) -> None:
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        _apply_file_overrides_to_conversational_inputs(inputs, {})
+        assert attachment.id == "old-id"
+
+    def test_no_overrides(self) -> None:
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        _apply_file_overrides_to_conversational_inputs(inputs, {})
+        assert attachment.id == "old-id"
+
+    def test_overrides_without_id_key_are_ignored(self) -> None:
+        """Dicts without 'ID' key should not be treated as file overrides."""
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {"someField": {"name": "not-a-file"}}
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "old-id"
+
+    def test_string_override_values_are_ignored(self) -> None:
+        """Non-dict, non-list override values should be skipped."""
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {"someField": "just a string", "anotherField": 42}
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "old-id"
+
+    def test_no_matching_attachment_by_name(self) -> None:
+        """Override with a FullName that doesn't match any attachment."""
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "other.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "old-id"
+
+    def test_no_attachments_on_current_prompt(self) -> None:
+        """No error when current_user_prompt has no attachments."""
+        inputs = _make_conversational_inputs(current_prompt_attachments=None)
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "file.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+
+    def test_empty_attachments_list(self) -> None:
+        """No error when current_user_prompt has empty attachments list."""
+        inputs = _make_conversational_inputs(current_prompt_attachments=[])
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "file.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+
+
+class TestApplyFileOverridesSingleDict:
+    """Tests for single-dict override values."""
+
+    def test_override_updates_id(self) -> None:
+        attachment = _make_attachment("old-id", "report.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "report.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "new-id"
+
+    def test_override_updates_full_name(self) -> None:
+        attachment = _make_attachment("old-id", "report.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "report.pdf",
+                "MimeType": "text/plain",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.full_name == "report.pdf"
+
+    def test_override_updates_mime_type(self) -> None:
+        attachment = _make_attachment("old-id", "report.pdf", "application/pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "report.pdf",
+                "MimeType": "text/plain",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.mime_type == "text/plain"
+
+    def test_override_without_mime_type_preserves_original(self) -> None:
+        attachment = _make_attachment("old-id", "report.pdf", "application/pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {"files": {"ID": "new-id", "FullName": "report.pdf"}}
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "new-id"
+        assert attachment.mime_type == "application/pdf"
+
+
+class TestApplyFileOverridesArrayValues:
+    """Tests for array-based override values."""
+
+    def test_override_from_array_of_files(self) -> None:
+        attachment = _make_attachment("old-id", "doc.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": [
+                {
+                    "ID": "new-id-1",
+                    "FullName": "doc.pdf",
+                    "MimeType": "application/pdf",
+                },
+                {
+                    "ID": "new-id-2",
+                    "FullName": "other.pdf",
+                    "MimeType": "application/pdf",
+                },
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "new-id-1"
+
+    def test_multiple_attachments_matched_from_array(self) -> None:
+        att1 = _make_attachment("old-1", "a.pdf")
+        att2 = _make_attachment("old-2", "b.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[att1, att2])
+        overrides = {
+            "files": [
+                {"ID": "new-1", "FullName": "a.pdf", "MimeType": "application/pdf"},
+                {"ID": "new-2", "FullName": "b.pdf", "MimeType": "text/plain"},
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert att1.id == "new-1"
+        assert att2.id == "new-2"
+        assert att2.mime_type == "text/plain"
+
+    def test_non_dict_items_in_array_are_skipped(self) -> None:
+        """Non-dict items in an override array should be safely ignored."""
+        attachment = _make_attachment("old-id", "doc.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": [
+                "not-a-dict",
+                42,
+                {"ID": "new-id", "FullName": "doc.pdf", "MimeType": "application/pdf"},
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "new-id"
+
+    def test_dicts_without_id_in_array_are_skipped(self) -> None:
+        """Dicts in array that lack 'ID' should not be treated as file overrides."""
+        attachment = _make_attachment("old-id", "doc.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": [
+                {"name": "not-a-file"},
+                {"ID": "new-id", "FullName": "doc.pdf", "MimeType": "application/pdf"},
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "new-id"
+
+
+class TestApplyFileOverridesMultipleOverrideKeys:
+    """Tests for overrides with multiple top-level keys."""
+
+    def test_file_overrides_collected_across_multiple_keys(self) -> None:
+        att1 = _make_attachment("old-1", "a.pdf")
+        att2 = _make_attachment("old-2", "b.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[att1, att2])
+        overrides = {
+            "primaryFile": {
+                "ID": "new-1",
+                "FullName": "a.pdf",
+                "MimeType": "application/pdf",
+            },
+            "secondaryFiles": [
+                {"ID": "new-2", "FullName": "b.pdf", "MimeType": "text/plain"},
+            ],
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert att1.id == "new-1"
+        assert att2.id == "new-2"
+
+
+class TestApplyFileOverridesEdgeCases:
+    """Edge cases for the override logic."""
+
+    def test_file_override_without_full_name_is_not_indexed(self) -> None:
+        """File dicts with ID but no FullName cannot match any attachment."""
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {"files": {"ID": "new-id"}}
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "old-id"
+
+    def test_duplicate_full_names_last_wins(self) -> None:
+        """When multiple overrides share the same FullName, the last one wins in the dict comprehension."""
+        attachment = _make_attachment("old-id", "file.pdf")
+        inputs = _make_conversational_inputs(current_prompt_attachments=[attachment])
+        overrides = {
+            "files": [
+                {
+                    "ID": "first-id",
+                    "FullName": "file.pdf",
+                    "MimeType": "application/pdf",
+                },
+                {"ID": "second-id", "FullName": "file.pdf", "MimeType": "text/plain"},
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert attachment.id == "second-id"
+        assert attachment.mime_type == "text/plain"
+
+
+class TestApplyFileOverridesConversationHistory:
+    """Tests for overrides applied to conversation history attachments."""
+
+    def test_override_applied_to_history_user_message(self) -> None:
+        history_attachment = _make_attachment("old-hist", "history.pdf")
+        history_msg = LegacyConversationalEvalUserMessage(
+            role="user", text="past message", attachments=[history_attachment]
+        )
+        inputs = _make_conversational_inputs(
+            conversation_history=[[history_msg]],
+        )
+        overrides = {
+            "files": {
+                "ID": "new-hist",
+                "FullName": "history.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert history_attachment.id == "new-hist"
+
+    def test_override_applied_to_both_current_and_history(self) -> None:
+        current_att = _make_attachment("old-curr", "current.pdf")
+        history_att = _make_attachment("old-hist", "history.pdf")
+        history_msg = LegacyConversationalEvalUserMessage(
+            role="user", text="past message", attachments=[history_att]
+        )
+        inputs = _make_conversational_inputs(
+            current_prompt_attachments=[current_att],
+            conversation_history=[[history_msg]],
+        )
+        overrides = {
+            "files": [
+                {
+                    "ID": "new-curr",
+                    "FullName": "current.pdf",
+                    "MimeType": "application/pdf",
+                },
+                {
+                    "ID": "new-hist",
+                    "FullName": "history.pdf",
+                    "MimeType": "application/pdf",
+                },
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert current_att.id == "new-curr"
+        assert history_att.id == "new-hist"
+
+    def test_agent_messages_without_attachments_are_skipped(self) -> None:
+        """Agent messages don't have attachments; they should be safely iterated."""
+        current_att = _make_attachment("old-id", "file.pdf")
+        agent_msg = LegacyConversationalEvalInputAgentMessage(
+            role="agent", text="agent response"
+        )
+        user_msg = LegacyConversationalEvalUserMessage(
+            role="user", text="user follow-up", attachments=None
+        )
+        inputs = _make_conversational_inputs(
+            current_prompt_attachments=[current_att],
+            conversation_history=[[user_msg, agent_msg]],
+        )
+        overrides = {
+            "files": {
+                "ID": "new-id",
+                "FullName": "file.pdf",
+                "MimeType": "application/pdf",
+            }
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert current_att.id == "new-id"
+
+    def test_multiple_exchanges_in_history(self) -> None:
+        att1 = _make_attachment("old-1", "first.pdf")
+        att2 = _make_attachment("old-2", "second.pdf")
+        exchange1 = [
+            LegacyConversationalEvalUserMessage(
+                role="user", text="msg1", attachments=[att1]
+            ),
+        ]
+        exchange2 = [
+            LegacyConversationalEvalUserMessage(
+                role="user", text="msg2", attachments=[att2]
+            ),
+        ]
+        inputs = _make_conversational_inputs(
+            conversation_history=[exchange1, exchange2],
+        )
+        overrides = {
+            "files": [
+                {"ID": "new-1", "FullName": "first.pdf", "MimeType": "application/pdf"},
+                {
+                    "ID": "new-2",
+                    "FullName": "second.pdf",
+                    "MimeType": "application/pdf",
+                },
+            ]
+        }
+        _apply_file_overrides_to_conversational_inputs(inputs, overrides)
+        assert att1.id == "new-1"
+        assert att2.id == "new-2"
diff --git a/packages/uipath/tests/cli/eval/test_conversational_utils.py b/packages/uipath/tests/cli/eval/test_conversational_utils.py
new file mode 100644
index 000000000..9a4d73a0b
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_conversational_utils.py
@@ -0,0 +1,749 @@
+"""Tests for conversational eval utilities."""
+
+from uipath.core.chat import UiPathExternalValue, UiPathInlineValue
+from uipath.eval.models._conversational_utils import (
+    LegacyConversationalEvalInput,
+    LegacyConversationalEvalInputAgentMessage,
+    LegacyConversationalEvalInputToolCall,
+    LegacyConversationalEvalInputToolCallResult,
+    LegacyConversationalEvalJobAttachmentReference,
+    LegacyConversationalEvalOutput,
+    LegacyConversationalEvalOutputAgentMessage,
+    LegacyConversationalEvalOutputToolCall,
+    LegacyConversationalEvalUserMessage,
+    UiPathLegacyEvalChatMessagesMapper,
+)
+
+
+class TestLegacyConversationalEvalInputToUiPathMessages:
+    """Tests for converting legacy eval input to UiPath messages."""
+
+    def test_converts_simple_conversation(self):
+        """Should convert simple user-agent conversation."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Hello"),
+                    LegacyConversationalEvalInputAgentMessage(text="Hi there!"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="How are you?"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        # Should have 3 messages: user, agent, user
+        assert len(result) == 3
+        assert result[0].role == "user"
+        assert isinstance(result[0].content_parts[0].data, UiPathInlineValue)
+        assert result[0].content_parts[0].data.inline == "Hello"
+        assert result[1].role == "assistant"
+        assert isinstance(result[1].content_parts[0].data, UiPathInlineValue)
+        assert result[1].content_parts[0].data.inline == "Hi there!"
+        assert result[2].role == "user"
+        assert isinstance(result[2].content_parts[0].data, UiPathInlineValue)
+        assert result[2].content_parts[0].data.inline == "How are you?"
+
+    def test_converts_user_message_with_text_plain_mime_type(self):
+        """User messages should have text/plain mime type."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Test"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        assert len(result) == 1
+        assert result[0].content_parts[0].mime_type == "text/plain"
+
+    def test_converts_agent_message_with_text_markdown_mime_type(self):
+        """Agent messages should have text/markdown mime type."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Question"),
+                    LegacyConversationalEvalInputAgentMessage(text="**Answer**"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Next"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        # Agent message is at index 1
+        assert result[1].content_parts[0].mime_type == "text/markdown"
+
+    def test_converts_agent_message_with_tool_calls(self):
+        """Should convert agent messages with tool calls and results."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Search for data"),
+                    LegacyConversationalEvalInputAgentMessage(
+                        text="Let me search",
+                        toolCalls=[
+                            LegacyConversationalEvalInputToolCall(
+                                name="search_tool",
+                                arguments={"query": "test"},
+                                result=LegacyConversationalEvalInputToolCallResult(
+                                    value={"results": ["item1", "item2"]},
+                                    isError=False,
+                                ),
+                            )
+                        ],
+                    ),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Thanks"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        agent_message = result[1]
+        assert agent_message.role == "assistant"
+        assert len(agent_message.tool_calls) == 1
+        assert agent_message.tool_calls[0].name == "search_tool"
+        assert agent_message.tool_calls[0].input == {"query": "test"}
+        assert agent_message.tool_calls[0].result is not None
+        assert agent_message.tool_calls[0].result.output == {
+            "results": ["item1", "item2"]
+        }
+        assert agent_message.tool_calls[0].result.is_error is False
+
+    def test_converts_tool_call_with_error_result(self):
+        """Should handle tool calls with error results."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Do something"),
+                    LegacyConversationalEvalInputAgentMessage(
+                        text="Trying",
+                        toolCalls=[
+                            LegacyConversationalEvalInputToolCall(
+                                name="failing_tool",
+                                arguments={},
+                                result=LegacyConversationalEvalInputToolCallResult(
+                                    value="Error occurred",
+                                    isError=True,
+                                ),
+                            )
+                        ],
+                    ),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Ok"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        tool_call = result[1].tool_calls[0]
+        assert tool_call.result is not None
+        assert tool_call.result.is_error is True
+        assert tool_call.result.output == "Error occurred"
+
+    def test_converts_multiple_exchanges(self):
+        """Should handle multiple conversation exchanges."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="First question"),
+                    LegacyConversationalEvalInputAgentMessage(text="First answer"),
+                ],
+                [
+                    LegacyConversationalEvalUserMessage(text="Second question"),
+                    LegacyConversationalEvalInputAgentMessage(text="Second answer"),
+                ],
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(
+                text="Third question"
+            ),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        assert len(result) == 5  # 2 exchanges (4 messages) + current prompt
+        assert isinstance(result[0].content_parts[0].data, UiPathInlineValue)
+        assert result[0].content_parts[0].data.inline == "First question"
+        assert isinstance(result[1].content_parts[0].data, UiPathInlineValue)
+        assert result[1].content_parts[0].data.inline == "First answer"
+        assert isinstance(result[2].content_parts[0].data, UiPathInlineValue)
+        assert result[2].content_parts[0].data.inline == "Second question"
+        assert isinstance(result[3].content_parts[0].data, UiPathInlineValue)
+        assert result[3].content_parts[0].data.inline == "Second answer"
+        assert isinstance(result[4].content_parts[0].data, UiPathInlineValue)
+        assert result[4].content_parts[0].data.inline == "Third question"
+
+    def test_converts_exchange_with_multiple_agent_messages(self):
+        """Should handle exchanges with multiple agent responses."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Question"),
+                    LegacyConversationalEvalInputAgentMessage(
+                        text="Using tool",
+                        toolCalls=[
+                            LegacyConversationalEvalInputToolCall(
+                                name="tool1",
+                                arguments={"x": 1},
+                                result=LegacyConversationalEvalInputToolCallResult(
+                                    value="result1",
+                                    isError=False,
+                                ),
+                            )
+                        ],
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="Final answer"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Next"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        assert len(result) == 4  # user, agent with tool, agent final, current user
+        assert result[0].role == "user"
+        assert result[1].role == "assistant"
+        assert len(result[1].tool_calls) == 1
+        assert result[2].role == "assistant"
+        assert len(result[2].tool_calls) == 0
+        assert result[3].role == "user"
+
+    def test_generates_unique_ids_for_messages(self):
+        """Should generate unique message IDs."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Q1"),
+                    LegacyConversationalEvalInputAgentMessage(text="A1"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Q2"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        message_ids = [msg.message_id for msg in result]
+        assert len(message_ids) == len(set(message_ids))  # All unique
+
+    def test_generates_unique_content_part_ids(self):
+        """Should generate unique content part IDs."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Q"),
+                    LegacyConversationalEvalInputAgentMessage(text="A"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Q2"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        content_part_ids = [
+            part.content_part_id for msg in result for part in msg.content_parts
+        ]
+        assert len(content_part_ids) == len(set(content_part_ids))
+
+    def test_empty_conversation_history(self):
+        """Should handle empty conversation history."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="First message"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        assert len(result) == 1
+        assert result[0].role == "user"
+        assert isinstance(result[0].content_parts[0].data, UiPathInlineValue)
+        assert result[0].content_parts[0].data.inline == "First message"
+
+    def test_blank_text_in_message_creates_empty_content_parts(self):
+        """Should create empty content_parts when user message has blank text."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text=""),
+                    LegacyConversationalEvalInputAgentMessage(text=""),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text=""),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        # Empty text content should result in no text content-parts
+        assert len(result[0].content_parts) == 0
+        assert len(result[1].content_parts) == 0
+        assert len(result[2].content_parts) == 0
+
+    def test_blank_text_with_tool_calls_creates_empty_content_parts(self):
+        """Should create empty content_parts when agent message with tool calls has blank text."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(text="Search for data"),
+                    LegacyConversationalEvalInputAgentMessage(
+                        text="",
+                        toolCalls=[
+                            LegacyConversationalEvalInputToolCall(
+                                name="search_tool",
+                                arguments={"query": "test"},
+                                result=LegacyConversationalEvalInputToolCallResult(
+                                    value={"results": ["item1"]},
+                                    isError=False,
+                                ),
+                            )
+                        ],
+                    ),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Thanks"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        agent_message = result[1]
+        assert agent_message.role == "assistant"
+        # Empty content should result in no text content-parts
+        assert len(agent_message.content_parts) == 0
+        # Tool calls should still be present
+        assert len(agent_message.tool_calls) == 1
+
+    def test_converts_user_message_with_single_attachment(self):
+        """Should convert user message with a single attachment to UiPathExternalValue content part."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(
+                        text="See attached",
+                        attachments=[
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="abc-123",
+                                FullName="report.pdf",
+                                MimeType="application/pdf",
+                            )
+                        ],
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="Got it"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Next"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        user_msg = result[0]
+        assert len(user_msg.content_parts) == 2
+        # First part is text
+        assert isinstance(user_msg.content_parts[0].data, UiPathInlineValue)
+        assert user_msg.content_parts[0].data.inline == "See attached"
+        # Second part is attachment
+        assert isinstance(user_msg.content_parts[1].data, UiPathExternalValue)
+        assert (
+            user_msg.content_parts[1].data.uri
+            == "urn:uipath:cas:file:orchestrator:abc-123"
+        )
+        assert user_msg.content_parts[1].name == "report.pdf"
+        assert user_msg.content_parts[1].mime_type == "application/pdf"
+
+    def test_converts_user_message_with_multiple_attachments(self):
+        """Should convert user message with multiple attachments."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(
+                        text="Here are the files",
+                        attachments=[
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="id-1",
+                                FullName="file1.csv",
+                                MimeType="text/csv",
+                            ),
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="id-2",
+                                FullName="file2.xlsx",
+                                MimeType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                            ),
+                        ],
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="Received"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Analyze"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        user_msg = result[0]
+        assert len(user_msg.content_parts) == 3  # 1 text + 2 attachments
+        assert isinstance(user_msg.content_parts[1].data, UiPathExternalValue)
+        assert (
+            user_msg.content_parts[1].data.uri
+            == "urn:uipath:cas:file:orchestrator:id-1"
+        )
+        assert user_msg.content_parts[1].name == "file1.csv"
+        assert isinstance(user_msg.content_parts[2].data, UiPathExternalValue)
+        assert (
+            user_msg.content_parts[2].data.uri
+            == "urn:uipath:cas:file:orchestrator:id-2"
+        )
+        assert user_msg.content_parts[2].name == "file2.xlsx"
+
+    def test_converts_current_user_prompt_with_attachment(self):
+        """Should convert current user prompt attachments."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(
+                text="Process this",
+                attachments=[
+                    LegacyConversationalEvalJobAttachmentReference(
+                        ID="prompt-att-1",
+                        FullName="data.json",
+                        MimeType="application/json",
+                    )
+                ],
+            ),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        assert len(result) == 1
+        prompt_msg = result[0]
+        assert len(prompt_msg.content_parts) == 2
+        assert isinstance(prompt_msg.content_parts[1].data, UiPathExternalValue)
+        assert (
+            prompt_msg.content_parts[1].data.uri
+            == "urn:uipath:cas:file:orchestrator:prompt-att-1"
+        )
+        assert prompt_msg.content_parts[1].name == "data.json"
+        assert prompt_msg.content_parts[1].mime_type == "application/json"
+
+    def test_user_message_with_no_attachments_unchanged(self):
+        """Should not add attachment content parts when attachments is None."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(
+                        text="No attachments here", attachments=None
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="Ok"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Done"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        user_msg = result[0]
+        assert len(user_msg.content_parts) == 1
+        assert isinstance(user_msg.content_parts[0].data, UiPathInlineValue)
+
+    def test_user_message_with_empty_text_and_attachment(self):
+        """Should create only attachment content part when text is empty."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(
+                        text="",
+                        attachments=[
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="att-only",
+                                FullName="image.png",
+                                MimeType="image/png",
+                            )
+                        ],
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="I see the image"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(text="Thanks"),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        user_msg = result[0]
+        # No text part (empty text), only attachment
+        assert len(user_msg.content_parts) == 1
+        assert isinstance(user_msg.content_parts[0].data, UiPathExternalValue)
+        assert (
+            user_msg.content_parts[0].data.uri
+            == "urn:uipath:cas:file:orchestrator:att-only"
+        )
+        assert user_msg.content_parts[0].name == "image.png"
+
+    def test_attachment_content_parts_have_unique_ids(self):
+        """Should generate unique content part IDs for attachment parts."""
+        eval_input = LegacyConversationalEvalInput(
+            conversationHistory=[
+                [
+                    LegacyConversationalEvalUserMessage(
+                        text="Files",
+                        attachments=[
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="a1",
+                                FullName="f1.txt",
+                                MimeType="text/plain",
+                            ),
+                            LegacyConversationalEvalJobAttachmentReference(
+                                ID="a2",
+                                FullName="f2.txt",
+                                MimeType="text/plain",
+                            ),
+                        ],
+                    ),
+                    LegacyConversationalEvalInputAgentMessage(text="Ok"),
+                ]
+            ],
+            currentUserPrompt=LegacyConversationalEvalUserMessage(
+                text="More",
+                attachments=[
+                    LegacyConversationalEvalJobAttachmentReference(
+                        ID="a3",
+                        FullName="f3.txt",
+                        MimeType="text/plain",
+                    )
+                ],
+            ),
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_input_to_uipath_message_list(
+            eval_input
+        )
+
+        all_ids = [part.content_part_id for msg in result for part in msg.content_parts]
+        assert len(all_ids) == len(set(all_ids))
+
+
+class TestLegacyConversationalEvalOutputToUiPathMessageData:
+    """Tests for converting legacy eval output to UiPath message data."""
+
+    def test_converts_simple_agent_response(self):
+        """Should convert simple agent response."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(text="Here is the answer")
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        assert result[0].role == "assistant"
+        assert len(result[0].content_parts) == 1
+        assert isinstance(result[0].content_parts[0].data, UiPathInlineValue)
+        assert result[0].content_parts[0].data.inline == "Here is the answer"
+        assert result[0].content_parts[0].mime_type == "text/markdown"
+
+    def test_converts_agent_response_with_tool_calls(self):
+        """Should convert agent responses with tool calls."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(
+                    text="Using tool",
+                    toolCalls=[
+                        LegacyConversationalEvalOutputToolCall(
+                            name="search",
+                            arguments={"query": "test"},
+                        )
+                    ],
+                )
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        assert len(result[0].tool_calls) == 1
+        assert result[0].tool_calls[0].name == "search"
+        assert result[0].tool_calls[0].input == {"query": "test"}
+        # Output tool calls should not have result field
+        assert result[0].tool_calls[0].result is None
+
+    def test_converts_multiple_agent_messages(self):
+        """Should convert multiple agent messages in sequence."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(
+                    text="First response",
+                    toolCalls=[
+                        LegacyConversationalEvalOutputToolCall(
+                            name="tool1",
+                            arguments={},
+                        )
+                    ],
+                ),
+                LegacyConversationalEvalOutputAgentMessage(text="Final response"),
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 2
+        assert isinstance(result[0].content_parts[0].data, UiPathInlineValue)
+        assert result[0].content_parts[0].data.inline == "First response"
+        assert len(result[0].tool_calls) == 1
+        assert isinstance(result[1].content_parts[0].data, UiPathInlineValue)
+        assert result[1].content_parts[0].data.inline == "Final response"
+        assert len(result[1].tool_calls) == 0
+
+    def test_converts_multiple_tool_calls_in_message(self):
+        """Should handle multiple tool calls in a single message."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(
+                    text="Using multiple tools",
+                    toolCalls=[
+                        LegacyConversationalEvalOutputToolCall(
+                            name="tool1",
+                            arguments={"a": 1},
+                        ),
+                        LegacyConversationalEvalOutputToolCall(
+                            name="tool2",
+                            arguments={"b": 2},
+                        ),
+                    ],
+                )
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        assert len(result[0].tool_calls) == 2
+        assert result[0].tool_calls[0].name == "tool1"
+        assert result[0].tool_calls[0].input == {"a": 1}
+        assert result[0].tool_calls[1].name == "tool2"
+        assert result[0].tool_calls[1].input == {"b": 2}
+
+    def test_agent_message_without_tool_calls(self):
+        """Should handle agent messages without tool calls."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(text="Simple response")
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        assert len(result[0].tool_calls) == 0
+
+    def test_empty_agent_response(self):
+        """Should handle empty agent response list."""
+        eval_output = LegacyConversationalEvalOutput(agentResponse=[])
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert result == []
+
+    def test_preserves_empty_tool_arguments(self):
+        """Should preserve empty tool arguments dict."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(
+                    text="Using tool",
+                    toolCalls=[
+                        LegacyConversationalEvalOutputToolCall(
+                            name="no_arg_tool",
+                            arguments={},
+                        )
+                    ],
+                )
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert result[0].tool_calls[0].input == {}
+
+    def test_blank_text_in_agent_response_creates_empty_content_parts(self):
+        """Should create empty content_parts when agent response has blank text."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[LegacyConversationalEvalOutputAgentMessage(text="")]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        assert result[0].role == "assistant"
+        # Empty text should result in no text content-parts
+        assert len(result[0].content_parts) == 0
+
+    def test_blank_text_with_tool_calls_in_agent_response_creates_empty_content_parts(
+        self,
+    ):
+        """Should create empty content_parts when agent response with tool calls has blank text."""
+        eval_output = LegacyConversationalEvalOutput(
+            agentResponse=[
+                LegacyConversationalEvalOutputAgentMessage(
+                    text="",
+                    toolCalls=[
+                        LegacyConversationalEvalOutputToolCall(
+                            name="search",
+                            arguments={"query": "test"},
+                        )
+                    ],
+                )
+            ]
+        )
+
+        result = UiPathLegacyEvalChatMessagesMapper.legacy_conversational_eval_output_to_uipath_message_data_list(
+            eval_output
+        )
+
+        assert len(result) == 1
+        # Empty text should result in no text content-parts
+        assert len(result[0].content_parts) == 0
+        # Tool calls should still be present
+        assert len(result[0].tool_calls) == 1
diff --git a/packages/uipath/tests/cli/eval/test_eval_discovery.py b/packages/uipath/tests/cli/eval/test_eval_discovery.py
new file mode 100644
index 000000000..bce44f86c
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_discovery.py
@@ -0,0 +1,355 @@
+"""Tests for eval CLI auto-discovery of entrypoints and eval sets."""
+
+import json
+import os
+from unittest.mock import AsyncMock, Mock, patch
+
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.middlewares import MiddlewareResult
+
+
+def _middleware_continue():
+    return MiddlewareResult(
+        should_continue=True,
+        error_message=None,
+        should_include_stacktrace=False,
+    )
+
+
+def _make_mock_factory(entrypoints: list[str]):
+    """Create a mock runtime factory with given entrypoints."""
+    mock_factory = Mock()
+    mock_factory.discover_entrypoints.return_value = entrypoints
+    mock_factory.get_settings = AsyncMock(return_value=None)
+    mock_factory.dispose = AsyncMock()
+
+    mock_runtime = Mock()
+    mock_runtime.get_schema = AsyncMock(
+        return_value=Mock(metadata=None, input_schema=None, output_schema=None)
+    )
+    mock_runtime.dispose = AsyncMock()
+    mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+    return mock_factory
+
+
+class TestEvalDiscoveryMultipleEntrypoints:
+    """Tests for when multiple entrypoints exist and none is specified."""
+
+    def test_multiple_entrypoints_shows_usage_help(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """When multiple entrypoints exist, show available entrypoints and eval sets."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create uipath.json with multiple functions
+            uipath_config = {
+                "functions": {
+                    "agent_a": "src/agent_a.py:main",
+                    "agent_b": "src/agent_b.py:main",
+                }
+            }
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            # Create eval sets directory with one eval set
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            eval_set = {
+                "version": 1.0,
+                "id": "test-set",
+                "name": "Test Set",
+                "evaluatorRefs": [],
+                "evaluations": [],
+            }
+            with open("evaluations/eval-sets/test-set.json", "w") as f:
+                json.dump(eval_set, f)
+
+            mock_factory = _make_mock_factory(["agent_a", "agent_b"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            assert result.exit_code == 0
+            assert "Available entrypoints:" in result.output
+            assert "agent_a" in result.output
+            assert "agent_b" in result.output
+            assert "Available eval sets:" in result.output
+            assert "evaluations" in result.output and "test-set.json" in result.output
+            assert "Usage: uipath eval <entrypoint> <eval_set>" in result.output
+            assert "Example:" in result.output
+
+    def test_multiple_entrypoints_no_eval_sets(self, runner: CliRunner, temp_dir: str):
+        """When multiple entrypoints exist and no eval sets, show both sections."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"a": "a.py:main", "b": "b.py:main"}}, f)
+
+            mock_factory = _make_mock_factory(["a", "b"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            assert result.exit_code == 0
+            assert "Available entrypoints:" in result.output
+            assert "a" in result.output
+            assert "b" in result.output
+            assert "No eval sets found" in result.output
+
+
+class TestEvalDiscoveryMultipleEvalSets:
+    """Tests for when multiple eval sets exist and none is specified."""
+
+    def test_multiple_eval_sets_shows_usage_help(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """When one entrypoint but multiple eval sets, show available eval sets."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"my_agent": "src/main.py:main"}}, f)
+
+            # Create two eval sets
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            for name in ["set-a.json", "set-b.json"]:
+                eval_set = {
+                    "version": 1.0,
+                    "id": name,
+                    "name": name,
+                    "evaluatorRefs": [],
+                    "evaluations": [],
+                }
+                with open(f"evaluations/eval-sets/{name}", "w") as f:
+                    json.dump(eval_set, f)
+
+            mock_factory = _make_mock_factory(["my_agent"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            assert result.exit_code == 0
+            assert "Available entrypoints:" in result.output
+            assert "my_agent" in result.output
+            assert "Available eval sets:" in result.output
+            assert "set-a.json" in result.output
+            assert "set-b.json" in result.output
+            assert "Usage: uipath eval <entrypoint> <eval_set>" in result.output
+            assert "Example: uipath eval my_agent" in result.output
+
+    def test_eval_sets_show_full_relative_path(self, runner: CliRunner, temp_dir: str):
+        """Eval sets in the help message should show the full relative path."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"agent": "main.py:main"}}, f)
+
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            for name in ["alpha.json", "beta.json"]:
+                with open(f"evaluations/eval-sets/{name}", "w") as f:
+                    json.dump(
+                        {
+                            "version": 1.0,
+                            "id": name,
+                            "name": name,
+                            "evaluatorRefs": [],
+                            "evaluations": [],
+                        },
+                        f,
+                    )
+
+            mock_factory = _make_mock_factory(["agent"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            # Should contain full relative paths, not just filenames
+            output = result.output.replace("\\", "/")
+            assert "evaluations/eval-sets/alpha.json" in output
+            assert "evaluations/eval-sets/beta.json" in output
+
+
+class TestEvalDiscoverySingleEntrypointAndEvalSet:
+    """Tests for auto-discovery when exactly one entrypoint and one eval set exist."""
+
+    def test_single_entrypoint_and_eval_set_does_not_show_help(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """When exactly one entrypoint and one eval set, discovery succeeds (no help shown)."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"my_agent": "main.py:main"}}, f)
+
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            eval_set = {
+                "version": 1.0,
+                "id": "test-set",
+                "name": "Test Set",
+                "evaluatorRefs": [],
+                "evaluations": [],
+            }
+            with open("evaluations/eval-sets/test-set.json", "w") as f:
+                json.dump(eval_set, f)
+
+            mock_factory = _make_mock_factory(["my_agent"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            # Should NOT show usage help (discovery succeeded)
+            assert "Available entrypoints:" not in result.output
+            assert "Usage: uipath eval" not in result.output
+
+
+class TestEvalDiscoveryNoEntrypoints:
+    """Tests for when no entrypoints are found."""
+
+    def test_no_entrypoints_shows_helpful_message(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """When no entrypoints found, show a helpful message."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            with open("evaluations/eval-sets/test.json", "w") as f:
+                json.dump(
+                    {
+                        "version": 1.0,
+                        "id": "t",
+                        "name": "t",
+                        "evaluatorRefs": [],
+                        "evaluations": [],
+                    },
+                    f,
+                )
+
+            mock_factory = _make_mock_factory([])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                result = runner.invoke(cli, ["eval"])
+
+            assert result.exit_code == 0
+            assert "No entrypoints found" in result.output
+            assert "Usage: uipath eval <entrypoint> <eval_set>" in result.output
+
+
+class TestEvalDiscoveryExplicitArgs:
+    """Tests for when entrypoint and/or eval set are explicitly provided."""
+
+    def test_explicit_entrypoint_skips_entrypoint_discovery(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """When entrypoint is provided, skip entrypoint discovery but still discover eval sets."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs("evaluations/eval-sets", exist_ok=True)
+            for name in ["set-a.json", "set-b.json"]:
+                with open(f"evaluations/eval-sets/{name}", "w") as f:
+                    json.dump(
+                        {
+                            "version": 1.0,
+                            "id": name,
+                            "name": name,
+                            "evaluatorRefs": [],
+                            "evaluations": [],
+                        },
+                        f,
+                    )
+
+            mock_factory = _make_mock_factory(["agent_a", "agent_b"])
+
+            with (
+                patch(
+                    "uipath._cli.cli_eval.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_eval.UiPathRuntimeFactoryRegistry.get",
+                    return_value=mock_factory,
+                ),
+                patch(
+                    "uipath._cli.cli_eval.setup_reporting_prereq",
+                    return_value=False,
+                ),
+            ):
+                # Pass entrypoint explicitly, but no eval set
+                result = runner.invoke(cli, ["eval", "agent_a"])
+
+            # Should still show usage help because multiple eval sets
+            assert result.exit_code == 0
+            assert "Available eval sets:" in result.output
+            assert "set-a.json" in result.output
+            assert "set-b.json" in result.output
diff --git a/packages/uipath/tests/cli/eval/test_eval_id_casing.py b/packages/uipath/tests/cli/eval/test_eval_id_casing.py
new file mode 100644
index 000000000..e14a88a68
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_id_casing.py
@@ -0,0 +1,69 @@
+"""Tests for case-insensitive eval id handling (PC-4688).
+
+Eval sets exported by some tools emit uppercase GUID ids. The backend
+canonicalizes GUIDs to lowercase, so any case-sensitive correlation on the
+runtime side (selection, span/cache keying) silently fails to match. These
+tests pin the fix: GUID ids are normalized to lowercase at ingestion and
+selection is casing-agnostic.
+"""
+
+from typing import Any
+
+from uipath.eval.models.evaluation_set import (
+    EvaluationItem,
+    EvaluationSet,
+    LegacyEvaluationItem,
+)
+
+UPPER_GUID = "B063907C-76AB-4B0A-88A3-EC0FB40698B8"
+LOWER_GUID = "b063907c-76ab-4b0a-88a3-ec0fb40698b8"
+
+
+def _make_item(eval_id: str) -> dict[str, Any]:
+    return {
+        "id": eval_id,
+        "name": "item",
+        "inputs": {"x": 1},
+        "evaluationCriterias": {},
+    }
+
+
+def test_evaluation_item_normalizes_uppercase_guid_id():
+    """An uppercase GUID id is stored in canonical lowercase form."""
+    item = EvaluationItem.model_validate(_make_item(UPPER_GUID))
+    assert item.id == LOWER_GUID
+
+
+def test_legacy_evaluation_item_normalizes_uppercase_guid_id():
+    """LegacyEvaluationItem also normalizes uppercase GUID ids."""
+    item = LegacyEvaluationItem.model_validate(
+        {
+            "id": UPPER_GUID,
+            "name": "item",
+            "inputs": {"x": 1},
+            "expectedOutput": {},
+            "evalSetId": "set-1",
+            "createdAt": "2025-01-01T00:00:00.000Z",
+            "updatedAt": "2025-01-01T00:00:00.000Z",
+        }
+    )
+    assert item.id == LOWER_GUID
+
+
+def test_non_guid_id_is_left_unchanged():
+    """Non-GUID ids (e.g. slugs) keep their original value and casing."""
+    item = EvaluationItem.model_validate(_make_item("Test-Eval-1"))
+    assert item.id == "Test-Eval-1"
+
+
+def test_extract_selected_evals_matches_regardless_of_caller_casing():
+    """Selecting by an uppercase GUID matches a normalized stored id."""
+    eval_set = EvaluationSet.model_validate(
+        {
+            "id": "set-1",
+            "name": "set",
+            "evaluations": [_make_item(LOWER_GUID), _make_item("other-id")],
+        }
+    )
+    eval_set.extract_selected_evals([UPPER_GUID])
+    assert [e.id for e in eval_set.evaluations] == [LOWER_GUID]
diff --git a/packages/uipath/tests/cli/eval/test_eval_resume_flow.py b/packages/uipath/tests/cli/eval/test_eval_resume_flow.py
new file mode 100644
index 000000000..8197d4aa7
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_resume_flow.py
@@ -0,0 +1,249 @@
+"""Unit tests for eval resume flow to ensure UiPathExecuteOptions is passed correctly."""
+
+import uuid
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.helpers import EvalHelpers
+from uipath.eval.runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+
+# ============================================================================
+# Direct unit tests using mocks to verify the specific code path we changed
+# ============================================================================
+#
+# These tests directly verify that UiPathExecuteOptions is being passed correctly
+# in the execute_runtime method, which is the specific code path we modified.
+#
+
+
+@pytest.mark.asyncio
+async def test_execute_runtime_method_passes_options_with_resume_false():
+    """Test that execute_runtime respects resume=False setting."""
+    # Arrange
+    from uipath.eval.models.evaluation_set import EvaluationItem
+
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    # Load evaluation set
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create a mock runtime to get schema
+    mock_runtime = AsyncMock(spec=UiPathRuntimeProtocol)
+    mock_runtime.execute = AsyncMock(
+        return_value=UiPathRuntimeResult(
+            output={"result": "success"}, status=UiPathRuntimeStatus.SUCCESSFUL
+        )
+    )
+    mock_runtime.get_schema = AsyncMock()
+
+    runtime_schema = await mock_runtime.get_schema()
+    runtime_schema.input = {"type": "object", "properties": {}}
+    runtime_schema.output = {"type": "object", "properties": {}}
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+    context.resume = False  # Test resume=False
+
+    # Create a mock factory
+    mock_factory = AsyncMock(spec=UiPathRuntimeFactoryProtocol)
+    mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+    eval_runtime = UiPathEvalRuntime(context, mock_factory, trace_manager, event_bus)
+
+    eval_item = EvaluationItem(
+        id="test-eval",
+        name="Test Evaluation",
+        inputs={"foo": "bar"},
+        evaluation_criterias={},
+    )
+
+    #  Act - Call execute_runtime directly
+    with patch(
+        "uipath.eval.runtime.runtime.UiPathExecutionRuntime"
+    ) as mock_execution_runtime_class:
+        # Set up the mock to capture the execute call
+        mock_execution_runtime_instance = AsyncMock()
+        mock_execution_runtime_instance.execute = AsyncMock(
+            return_value=UiPathRuntimeResult(
+                output={"result": "success"}, status=UiPathRuntimeStatus.SUCCESSFUL
+            )
+        )
+        mock_execution_runtime_class.return_value = mock_execution_runtime_instance
+
+        await eval_runtime.execute_runtime(
+            eval_item=eval_item, execution_id="test-exec-id"
+        )
+
+        # Assert - Verify that execute was called with UiPathExecuteOptions(resume=False)
+        assert mock_execution_runtime_instance.execute.called
+        call_args = mock_execution_runtime_instance.execute.call_args
+
+        # Extract the options argument
+        options = call_args.kwargs.get("options") or (
+            call_args.args[1] if len(call_args.args) > 1 else None
+        )
+
+        # Assert that options were passed and resume=False
+        assert options is not None, "UiPathExecuteOptions should be passed explicitly"
+        assert isinstance(options, UiPathExecuteOptions)
+        assert options.resume is False, (
+            "resume should be False when context.resume=False"
+        )
+
+
+@pytest.mark.asyncio
+async def test_execute_runtime_method_passes_options_with_resume_true():
+    """Test that execute_runtime respects resume=True setting."""
+    # Arrange
+    from uipath.eval.models.evaluation_set import EvaluationItem
+
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    # Load evaluation set
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create a mock runtime
+    mock_runtime = AsyncMock(spec=UiPathRuntimeProtocol)
+    mock_runtime.execute = AsyncMock(
+        return_value=UiPathRuntimeResult(
+            output={"result": "success"}, status=UiPathRuntimeStatus.SUCCESSFUL
+        )
+    )
+    mock_runtime.get_schema = AsyncMock()
+
+    runtime_schema = await mock_runtime.get_schema()
+    runtime_schema.input = {"type": "object", "properties": {}}
+    runtime_schema.output = {"type": "object", "properties": {}}
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+    context.resume = True  # Test resume=True
+
+    # Create a mock factory
+    mock_factory = AsyncMock(spec=UiPathRuntimeFactoryProtocol)
+    mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+    eval_runtime = UiPathEvalRuntime(context, mock_factory, trace_manager, event_bus)
+
+    eval_item = EvaluationItem(
+        id="test-eval",
+        name="Test Evaluation",
+        inputs={"foo": "bar"},
+        evaluation_criterias={},
+    )
+
+    # Act - Call execute_runtime directly
+    with patch(
+        "uipath.eval.runtime.runtime.UiPathExecutionRuntime"
+    ) as mock_execution_runtime_class:
+        # Set up the mock to capture the execute call
+        mock_execution_runtime_instance = AsyncMock()
+        mock_execution_runtime_instance.execute = AsyncMock(
+            return_value=UiPathRuntimeResult(
+                output={"result": "success"}, status=UiPathRuntimeStatus.SUCCESSFUL
+            )
+        )
+        mock_execution_runtime_class.return_value = mock_execution_runtime_instance
+
+        await eval_runtime.execute_runtime(
+            eval_item=eval_item, execution_id="test-exec-id"
+        )
+
+        # Assert - Verify that execute was called with UiPathExecuteOptions(resume=True)
+        assert mock_execution_runtime_instance.execute.called
+        call_args = mock_execution_runtime_instance.execute.call_args
+
+        # Extract the options argument
+        options = call_args.kwargs.get("options") or (
+            call_args.args[1] if len(call_args.args) > 1 else None
+        )
+
+        # Assert that options were passed and resume=True
+        assert options is not None, "UiPathExecuteOptions should be passed explicitly"
+        assert isinstance(options, UiPathExecuteOptions)
+        assert options.resume is True, "resume should be True when context.resume=True"
+
+
+@pytest.mark.asyncio
+async def test_resume_with_multiple_evaluations_raises_error():
+    """Test that resume mode with multiple evaluations raises a ValueError."""
+    # Arrange
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    # Load evaluation set with multiple evals
+    eval_set_path = str(
+        Path(__file__).parent / "evals" / "eval-sets" / "multiple-evals.json"
+    )
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create a mock runtime
+    mock_runtime = AsyncMock(spec=UiPathRuntimeProtocol)
+    mock_runtime.get_schema = AsyncMock()
+    runtime_schema = await mock_runtime.get_schema()
+    runtime_schema.input = {"type": "object", "properties": {}}
+    runtime_schema.output = {"type": "object", "properties": {}}
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+    context.resume = True  # Enable resume mode
+
+    # Create a mock factory
+    mock_factory = AsyncMock(spec=UiPathRuntimeFactoryProtocol)
+    mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+    eval_runtime = UiPathEvalRuntime(
+        context=context,
+        factory=mock_factory,
+        event_bus=event_bus,
+        trace_manager=trace_manager,
+    )
+
+    # Act & Assert
+    with pytest.raises(
+        ValueError,
+        match=r"Resume mode is not supported with multiple evaluations.*Found 2 evaluations",
+    ):
+        await eval_runtime.initiate_evaluation()
diff --git a/packages/uipath/tests/cli/eval/test_eval_runtime_metadata.py b/packages/uipath/tests/cli/eval/test_eval_runtime_metadata.py
new file mode 100644
index 000000000..07042cc12
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_runtime_metadata.py
@@ -0,0 +1,211 @@
+"""Tests for UiPathEvalRuntime metadata loading functionality.
+
+This module tests:
+- get_agent_model() - cached agent model retrieval
+- get_schema() - cached schema retrieval
+"""
+
+import uuid
+from typing import Any, AsyncGenerator
+
+import pytest
+
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.helpers import get_agent_model
+from uipath.eval.runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeEvent,
+    UiPathRuntimeFactorySettings,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+    UiPathRuntimeStorageProtocol,
+    UiPathStreamOptions,
+)
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+
+class MockRuntimeSchema(UiPathRuntimeSchema):
+    """Mock schema for testing."""
+
+    def __init__(self):
+        super().__init__(
+            filePath="test.py",
+            uniqueId="test",
+            type="workflow",
+            input={"type": "object", "properties": {}},
+            output={"type": "object", "properties": {}},
+        )
+
+
+class BaseTestRuntime:
+    """Base test runtime without agent model support."""
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        return UiPathRuntimeResult(
+            output={},
+            status=UiPathRuntimeStatus.SUCCESSFUL,
+        )
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathStreamOptions | None = None,
+    ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        yield UiPathRuntimeResult(
+            output={},
+            status=UiPathRuntimeStatus.SUCCESSFUL,
+        )
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return MockRuntimeSchema()
+
+    async def dispose(self) -> None:
+        pass
+
+
+class WrapperRuntime(BaseTestRuntime):
+    """Test runtime that wraps another runtime (like UiPathResumableRuntime)."""
+
+    def __init__(self, delegate: Any):
+        self.delegate = delegate
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return await self.delegate.get_schema()
+
+
+class PrivateDelegateRuntime(BaseTestRuntime):
+    """Test runtime with private _delegate attribute."""
+
+    def __init__(self, delegate: Any):
+        self._delegate = delegate
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return await self._delegate.get_schema()
+
+
+class MockFactory:
+    """Mock factory for creating test runtimes."""
+
+    def __init__(self, runtime_creator):
+        self.runtime_creator = runtime_creator
+        self.new_runtime_call_count = 0
+
+    def discover_entrypoints(self) -> list[str]:
+        return ["test"]
+
+    async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+        return None
+
+    async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+        return None
+
+    async def new_runtime(
+        self, entrypoint: str, runtime_id: str, **kwargs
+    ) -> UiPathRuntimeProtocol:
+        self.new_runtime_call_count += 1
+        return await self.runtime_creator()
+
+    async def dispose(self) -> None:
+        pass
+
+
+class TestGetAgentModel:
+    """Tests for get_agent_model function."""
+
+    @pytest.mark.asyncio
+    async def test_returns_agent_model(self):
+        """Test that get_agent_model returns the correct model from schema."""
+        schema = MockRuntimeSchema()
+        schema.metadata = {"settings": {"model": "gpt-4o-2024-11-20"}}
+
+        model = get_agent_model(schema)
+        assert model == "gpt-4o-2024-11-20"
+
+    @pytest.mark.asyncio
+    async def test_returns_none_when_no_model(self):
+        """Test that get_agent_model returns None when runtime has no model."""
+        schema = MockRuntimeSchema()
+
+        model = get_agent_model(schema)
+        assert model is None
+
+    @pytest.mark.asyncio
+    async def test_returns_model_consistently(self):
+        """Test that get_agent_model returns consistent results."""
+        schema = MockRuntimeSchema()
+        schema.metadata = {"settings": {"model": "consistent-model"}}
+
+        # Multiple calls should return the same value
+        model1 = get_agent_model(schema)
+        model2 = get_agent_model(schema)
+
+        assert model1 == model2 == "consistent-model"
+
+
+class TestGetSchema:
+    """Tests for get_schema method."""
+
+    @pytest.mark.asyncio
+    async def test_returns_schema(self):
+        """Test that get_schema returns the schema from context."""
+        schema = MockRuntimeSchema()
+        context = UiPathEvalContext()
+        context.execution_id = str(uuid.uuid4())
+        context.evaluation_set = None  # type: ignore
+        context.runtime_schema = schema
+        context.evaluators = []
+
+        async def create_runtime():
+            return BaseTestRuntime()
+
+        factory = MockFactory(create_runtime)
+        event_bus = EventBus()
+        trace_manager = UiPathTraceManager()
+        eval_runtime = UiPathEvalRuntime(
+            context,
+            factory,
+            trace_manager,
+            event_bus,
+        )
+
+        retrieved_schema = await eval_runtime.get_schema()
+        assert retrieved_schema is not None
+        assert retrieved_schema.file_path == "test.py"
+
+    @pytest.mark.asyncio
+    async def test_returns_schema_consistently(self):
+        """Test that get_schema returns the same schema from context."""
+        schema = MockRuntimeSchema()
+        context = UiPathEvalContext()
+        context.execution_id = str(uuid.uuid4())
+        context.evaluation_set = None  # type: ignore
+        context.runtime_schema = schema
+        context.evaluators = []
+
+        async def create_runtime():
+            return BaseTestRuntime()
+
+        factory = MockFactory(create_runtime)
+        event_bus = EventBus()
+        trace_manager = UiPathTraceManager()
+        eval_runtime = UiPathEvalRuntime(
+            context,
+            factory,
+            trace_manager,
+            event_bus,
+        )
+
+        # Multiple calls should return the same schema from context
+        schema1 = await eval_runtime.get_schema()
+        schema2 = await eval_runtime.get_schema()
+
+        # Should be the same object
+        assert schema1 is schema2
+        assert schema1.file_path == schema2.file_path == "test.py"
diff --git a/packages/uipath/tests/cli/eval/test_eval_runtime_spans.py b/packages/uipath/tests/cli/eval/test_eval_runtime_spans.py
new file mode 100644
index 000000000..e8c1b0810
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_runtime_spans.py
@@ -0,0 +1,842 @@
+"""Tests for eval runtime span creation in _runtime.py.
+
+Tests the spans added for eval tracing:
+1. "Evaluation Set Run" - span_type: "eval_set_run"
+2. "Evaluation" - span_type: "evaluation"
+3. "Evaluator: {name}" - span_type: "evaluator"
+4. "Evaluation output" - span_type: "evalOutput"
+"""
+
+import uuid
+from typing import Any, Dict, List
+from unittest.mock import MagicMock
+
+import pytest
+from opentelemetry.sdk.trace import Span
+
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.models.evaluation_set import EvaluationItem
+from uipath.eval.runtime.context import UiPathEvalContext
+
+
+class MockSpanContext:
+    """Mock span context manager for testing span creation."""
+
+    def __init__(self, name: str, attributes: dict[str, Any] | None):
+        self.name = name
+        self.attributes = attributes or {}
+        self.span = MagicMock(spec=Span)
+        self.span.attributes = self.attributes
+
+    def __enter__(self):
+        return self.span
+
+    def __exit__(self, *args):
+        pass
+
+
+class SpanCapturingTracer:
+    """A tracer that captures span creations for testing."""
+
+    def __init__(self):
+        self.created_spans: List[Dict[str, Any]] = []
+
+    def start_as_current_span(
+        self, name: str, attributes: dict[str, Any] | None = None
+    ):
+        """Capture span creation and return a mock context manager."""
+        span_info = {"name": name, "attributes": attributes or {}}
+        self.created_spans.append(span_info)
+        return MockSpanContext(name, attributes)
+
+
+class TestEvalSetRunSpan:
+    """Tests for the 'Evaluation Set Run' span."""
+
+    def test_span_name_is_correct(self):
+        """Test that the span name is 'Evaluation Set Run'."""
+        # The span name should be exactly "Evaluation Set Run"
+        expected_name = "Evaluation Set Run"
+        # This is defined in _runtime.py:316
+        assert expected_name == "Evaluation Set Run"
+
+    def test_span_has_eval_set_run_span_type(self):
+        """Test that span_type attribute is 'eval_set_run'."""
+        span_attributes = {"span_type": "eval_set_run"}
+        assert span_attributes["span_type"] == "eval_set_run"
+
+    def test_span_has_output_attribute(self):
+        """Test that span has output attribute with score."""
+        import json
+
+        # Simulate the output attribute set by configure_eval_set_run_span
+        output_data = {"score": 85}
+        output_json = json.dumps(output_data)
+
+        span_attributes = {
+            "span_type": "eval_set_run",
+            "output": output_json,
+        }
+
+        assert "output" in span_attributes
+        parsed_output = json.loads(span_attributes["output"])
+        assert parsed_output["score"] == 85
+        assert isinstance(parsed_output["score"], int)
+
+    def test_span_has_agent_id(self):
+        """Test that span has agentId metadata attribute."""
+        execution_id = "exec-123"
+        span_attributes = {
+            "span_type": "eval_set_run",
+            "agentId": execution_id,
+        }
+        assert "agentId" in span_attributes
+        assert span_attributes["agentId"] == "exec-123"
+
+    def test_span_has_agent_name(self):
+        """Test that span has agentName metadata attribute."""
+        span_attributes = {
+            "span_type": "eval_set_run",
+            "agentName": "N/A",
+        }
+        assert "agentName" in span_attributes
+        assert span_attributes["agentName"] == "N/A"
+
+    def test_span_has_input_schema(self):
+        """Test that span has inputSchema metadata attribute."""
+        import json
+
+        input_schema = {"type": "object", "properties": {"x": {"type": "number"}}}
+        span_attributes = {
+            "span_type": "eval_set_run",
+            "inputSchema": json.dumps(input_schema),
+        }
+        assert "inputSchema" in span_attributes
+        parsed_schema = json.loads(span_attributes["inputSchema"])
+        assert parsed_schema["type"] == "object"
+
+    def test_span_has_output_schema(self):
+        """Test that span has outputSchema metadata attribute."""
+        import json
+
+        output_schema = {"type": "string"}
+        span_attributes = {
+            "span_type": "eval_set_run",
+            "outputSchema": json.dumps(output_schema),
+        }
+        assert "outputSchema" in span_attributes
+        parsed_schema = json.loads(span_attributes["outputSchema"])
+        assert parsed_schema["type"] == "string"
+
+    def test_span_includes_eval_set_run_id_when_present(self):
+        """Test that eval_set_run_id is included when context has it."""
+        eval_set_run_id = str(uuid.uuid4())
+        span_attributes: Dict[str, str] = {"span_type": "eval_set_run"}
+        if eval_set_run_id:
+            span_attributes["eval_set_run_id"] = eval_set_run_id
+
+        assert "eval_set_run_id" in span_attributes
+        assert span_attributes["eval_set_run_id"] == eval_set_run_id
+
+    def test_span_excludes_eval_set_run_id_when_not_present(self):
+        """Test that eval_set_run_id is not included when context doesn't have it."""
+        eval_set_run_id = None
+        span_attributes: Dict[str, str] = {"span_type": "eval_set_run"}
+        if eval_set_run_id:
+            span_attributes["eval_set_run_id"] = eval_set_run_id
+
+        assert "eval_set_run_id" not in span_attributes
+
+
+class TestEvaluationSpan:
+    """Tests for the 'Evaluation' span."""
+
+    def test_span_name_is_correct(self):
+        """Test that the span name is 'Evaluation'."""
+        expected_name = "Evaluation"
+        assert expected_name == "Evaluation"
+
+    def test_span_has_evaluation_span_type(self):
+        """Test that span_type attribute is 'evaluation'."""
+        span_attributes = {"span_type": "evaluation"}
+        assert span_attributes["span_type"] == "evaluation"
+
+    def test_span_includes_execution_id(self):
+        """Test that execution.id is included in the span attributes."""
+        execution_id = str(uuid.uuid4())
+        span_attributes = {
+            "execution.id": execution_id,
+            "span_type": "evaluation",
+        }
+        assert "execution.id" in span_attributes
+        assert span_attributes["execution.id"] == execution_id
+
+    def test_span_includes_eval_item_id(self):
+        """Test that eval_item_id is included in the span attributes."""
+        eval_item_id = "test-eval-item-123"
+        span_attributes = {
+            "span_type": "evaluation",
+            "eval_item_id": eval_item_id,
+        }
+        assert "eval_item_id" in span_attributes
+        assert span_attributes["eval_item_id"] == eval_item_id
+
+    def test_span_includes_eval_item_name(self):
+        """Test that eval_item_name is included in the span attributes."""
+        eval_item_name = "Test Evaluation Item"
+        span_attributes = {
+            "span_type": "evaluation",
+            "eval_item_name": eval_item_name,
+        }
+        assert "eval_item_name" in span_attributes
+        assert span_attributes["eval_item_name"] == eval_item_name
+
+    def test_span_has_all_required_attributes(self):
+        """Test that all required attributes are present in the span."""
+        execution_id = str(uuid.uuid4())
+        eval_item_id = "eval-item-456"
+        eval_item_name = "My Eval Item"
+
+        span_attributes = {
+            "execution.id": execution_id,
+            "span_type": "evaluation",
+            "eval_item_id": eval_item_id,
+            "eval_item_name": eval_item_name,
+        }
+
+        # Verify all required attributes
+        required_attrs = ["execution.id", "span_type", "eval_item_id", "eval_item_name"]
+        for attr in required_attrs:
+            assert attr in span_attributes, f"Missing required attribute: {attr}"
+
+    def test_span_has_output_attribute(self):
+        """Test that span has output attribute with score."""
+        import json
+
+        # Simulate the output attribute set by configure_evaluation_span
+        output_data = {"score": 90}
+        output_json = json.dumps(output_data)
+
+        span_attributes = {
+            "span_type": "evaluation",
+            "output": output_json,
+        }
+
+        assert "output" in span_attributes
+        parsed_output = json.loads(span_attributes["output"])
+        assert parsed_output["score"] == 90
+        assert isinstance(parsed_output["score"], int)
+
+    def test_span_has_agent_id(self):
+        """Test that span has agentId metadata attribute."""
+        execution_id = "eval-exec-456"
+        span_attributes = {
+            "span_type": "evaluation",
+            "agentId": execution_id,
+        }
+        assert "agentId" in span_attributes
+        assert span_attributes["agentId"] == "eval-exec-456"
+
+    def test_span_has_agent_name(self):
+        """Test that span has agentName metadata attribute."""
+        span_attributes = {
+            "span_type": "evaluation",
+            "agentName": "N/A",
+        }
+        assert "agentName" in span_attributes
+        assert span_attributes["agentName"] == "N/A"
+
+    def test_span_has_input_schema(self):
+        """Test that span has inputSchema metadata attribute."""
+        import json
+
+        input_schema = {"type": "object"}
+        span_attributes = {
+            "span_type": "evaluation",
+            "inputSchema": json.dumps(input_schema),
+        }
+        assert "inputSchema" in span_attributes
+        parsed_schema = json.loads(span_attributes["inputSchema"])
+        assert parsed_schema["type"] == "object"
+
+    def test_span_has_output_schema(self):
+        """Test that span has outputSchema metadata attribute."""
+        import json
+
+        output_schema = {"type": "object"}
+        span_attributes = {
+            "span_type": "evaluation",
+            "outputSchema": json.dumps(output_schema),
+        }
+        assert "outputSchema" in span_attributes
+        parsed_schema = json.loads(span_attributes["outputSchema"])
+        assert parsed_schema["type"] == "object"
+
+
+class TestEvaluatorSpan:
+    """Tests for the 'Evaluator: {name}' span."""
+
+    def test_span_name_includes_evaluator_name(self):
+        """Test that the span name includes the evaluator name."""
+        evaluator_name = "MyEvaluator"
+        expected_name = f"Evaluator: {evaluator_name}"
+        assert expected_name == "Evaluator: MyEvaluator"
+
+    def test_span_has_evaluator_span_type(self):
+        """Test that span_type attribute is 'evaluator'."""
+        span_attributes = {"span_type": "evaluator"}
+        assert span_attributes["span_type"] == "evaluator"
+
+    def test_span_includes_evaluator_id(self):
+        """Test that evaluator_id is included in the span attributes."""
+        evaluator_id = "evaluator-789"
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_id": evaluator_id,
+        }
+        assert "evaluator_id" in span_attributes
+        assert span_attributes["evaluator_id"] == evaluator_id
+
+    def test_span_includes_evaluator_name(self):
+        """Test that evaluator_name is included in the span attributes."""
+        evaluator_name = "AccuracyEvaluator"
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_name": evaluator_name,
+        }
+        assert "evaluator_name" in span_attributes
+        assert span_attributes["evaluator_name"] == evaluator_name
+
+    def test_span_includes_eval_item_id(self):
+        """Test that eval_item_id is included in the evaluator span."""
+        eval_item_id = "eval-item-123"
+        span_attributes = {
+            "span_type": "evaluator",
+            "eval_item_id": eval_item_id,
+        }
+        assert "eval_item_id" in span_attributes
+        assert span_attributes["eval_item_id"] == eval_item_id
+
+    def test_span_has_all_required_attributes(self):
+        """Test that all required attributes are present in the evaluator span."""
+        evaluator_id = "eval-id-123"
+        evaluator_name = "TestEvaluator"
+        eval_item_id = "item-456"
+
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_id": evaluator_id,
+            "evaluator_name": evaluator_name,
+            "eval_item_id": eval_item_id,
+        }
+
+        # Verify all required attributes
+        required_attrs = ["span_type", "evaluator_id", "evaluator_name", "eval_item_id"]
+        for attr in required_attrs:
+            assert attr in span_attributes, f"Missing required attribute: {attr}"
+
+
+class TestSpanHierarchy:
+    """Tests verifying the span hierarchy structure."""
+
+    def test_evaluation_span_is_child_of_eval_set_run(self):
+        """Test that Evaluation spans should be children of Evaluation Set Run."""
+        # This is a conceptual test - in the actual code, the Evaluation span
+        # is created inside the context of the Evaluation Set Run span
+        parent_span_type = "eval_set_run"
+        child_span_type = "evaluation"
+
+        # The parent-child relationship is enforced by span context nesting
+        assert parent_span_type == "eval_set_run"
+        assert child_span_type == "evaluation"
+
+    def test_evaluator_span_is_child_of_evaluation(self):
+        """Test that Evaluator spans should be children of Evaluation."""
+        # This is a conceptual test - in the actual code, the Evaluator span
+        # is created inside the context of the Evaluation span
+        parent_span_type = "evaluation"
+        child_span_type = "evaluator"
+
+        assert parent_span_type == "evaluation"
+        assert child_span_type == "evaluator"
+
+
+class TestSpanAttributeValues:
+    """Tests for span attribute value formatting."""
+
+    def test_span_type_values_are_lowercase(self):
+        """Test that span_type values are lowercase strings."""
+        span_types = ["eval_set_run", "evaluation", "evaluator"]
+
+        for span_type in span_types:
+            assert span_type == span_type.lower()
+            # All span types should be lowercase without hyphens
+            assert "-" not in span_type
+
+    def test_execution_id_is_valid_uuid(self):
+        """Test that execution.id is a valid UUID string."""
+        execution_id = str(uuid.uuid4())
+
+        # Verify it can be parsed back as a UUID
+        parsed_uuid = uuid.UUID(execution_id)
+        assert str(parsed_uuid) == execution_id
+
+    def test_evaluator_span_name_format(self):
+        """Test the evaluator span name format."""
+        evaluator_names = [
+            "Accuracy",
+            "Relevance",
+            "Fluency",
+            "Custom Evaluator",
+        ]
+
+        for name in evaluator_names:
+            span_name = f"Evaluator: {name}"
+            assert span_name.startswith("Evaluator: ")
+            assert name in span_name
+
+
+class TestEvalContextIntegration:
+    """Tests for UiPathEvalContext integration with spans."""
+
+    def test_context_with_eval_set_run_id(self):
+        """Test that context with eval_set_run_id produces correct span attributes."""
+        context = UiPathEvalContext()
+        context.eval_set_run_id = "run-123"
+
+        span_attributes: Dict[str, str] = {"span_type": "eval_set_run"}
+        if context.eval_set_run_id:
+            span_attributes["eval_set_run_id"] = context.eval_set_run_id
+
+        assert span_attributes["eval_set_run_id"] == "run-123"
+
+    def test_context_without_eval_set_run_id(self):
+        """Test that context without eval_set_run_id produces correct span attributes."""
+        context = UiPathEvalContext()
+        context.eval_set_run_id = None
+
+        span_attributes: Dict[str, str] = {"span_type": "eval_set_run"}
+        if context.eval_set_run_id:
+            span_attributes["eval_set_run_id"] = context.eval_set_run_id
+
+        assert "eval_set_run_id" not in span_attributes
+
+
+class TestSpanCreationLogic:
+    """Tests for the span creation logic in runtime methods."""
+
+    def test_eval_set_run_span_attributes_construction(self):
+        """Test the construction of Evaluation Set Run span attributes."""
+        eval_set_run_id = "test-run-id"
+
+        span_attributes: Dict[str, str] = {"span_type": "eval_set_run"}
+        if eval_set_run_id:
+            span_attributes["eval_set_run_id"] = eval_set_run_id
+
+        assert span_attributes == {
+            "span_type": "eval_set_run",
+            "eval_set_run_id": "test-run-id",
+        }
+
+    def test_evaluation_span_attributes_construction(self):
+        """Test the construction of Evaluation span attributes."""
+        execution_id = "exec-123"
+        eval_item_id = "item-456"
+        eval_item_name = "Test Item"
+
+        span_attributes = {
+            "execution.id": execution_id,
+            "span_type": "evaluation",
+            "eval_item_id": eval_item_id,
+            "eval_item_name": eval_item_name,
+        }
+
+        assert span_attributes["execution.id"] == "exec-123"
+        assert span_attributes["span_type"] == "evaluation"
+        assert span_attributes["eval_item_id"] == "item-456"
+        assert span_attributes["eval_item_name"] == "Test Item"
+
+    def test_evaluator_span_attributes_construction(self):
+        """Test the construction of Evaluator span attributes."""
+        evaluator_id = "eval-123"
+        evaluator_name = "AccuracyEvaluator"
+        eval_item_id = "item-789"
+
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_id": evaluator_id,
+            "evaluator_name": evaluator_name,
+            "eval_item_id": eval_item_id,
+        }
+
+        assert span_attributes["span_type"] == "evaluator"
+        assert span_attributes["evaluator_id"] == "eval-123"
+        assert span_attributes["evaluator_name"] == "AccuracyEvaluator"
+        assert span_attributes["eval_item_id"] == "item-789"
+
+    def test_evaluator_span_name_construction(self):
+        """Test the construction of Evaluator span name."""
+        evaluator_name = "RelevanceEvaluator"
+        span_name = f"Evaluator: {evaluator_name}"
+
+        assert span_name == "Evaluator: RelevanceEvaluator"
+
+
+class TestEvalItemSpanAttributes:
+    """Tests for eval item attributes in spans."""
+
+    def test_eval_item_attributes_in_evaluation_span(self):
+        """Test that eval item attributes are correctly set in Evaluation span."""
+        eval_item = MagicMock(spec=EvaluationItem)
+        eval_item.id = "item-id-123"
+        eval_item.name = "Test Evaluation"
+
+        span_attributes = {
+            "execution.id": str(uuid.uuid4()),
+            "span_type": "evaluation",
+            "eval_item_id": eval_item.id,
+            "eval_item_name": eval_item.name,
+        }
+
+        assert span_attributes["eval_item_id"] == "item-id-123"
+        assert span_attributes["eval_item_name"] == "Test Evaluation"
+
+    def test_eval_item_id_in_evaluator_span(self):
+        """Test that eval_item_id is included in Evaluator span."""
+        eval_item = MagicMock(spec=EvaluationItem)
+        eval_item.id = "item-id-456"
+
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_id": "evaluator-123",
+            "evaluator_name": "TestEvaluator",
+            "eval_item_id": eval_item.id,
+        }
+
+        assert span_attributes["eval_item_id"] == "item-id-456"
+
+
+class TestSpanTypeConsistency:
+    """Tests for span type value consistency."""
+
+    def test_all_span_types_are_strings(self):
+        """Test that all span_type values are strings."""
+        span_types = ["eval_set_run", "evaluation", "evaluator"]
+
+        for span_type in span_types:
+            assert isinstance(span_type, str)
+
+    def test_span_types_use_snake_case(self):
+        """Test that span_type values use snake_case naming."""
+        span_types = ["eval_set_run", "evaluation", "evaluator"]
+
+        for span_type in span_types:
+            # No uppercase letters
+            assert span_type == span_type.lower()
+            # No hyphens
+            assert "-" not in span_type
+
+    def test_span_type_values_match_expected(self):
+        """Test that span_type values match expected values from _runtime.py."""
+        expected_span_types = {
+            "Evaluation Set Run": "eval_set_run",
+            "Evaluation": "evaluation",
+            "Evaluator": "evaluator",
+        }
+
+        for _, span_type in expected_span_types.items():
+            assert isinstance(span_type, str)
+            assert span_type.islower() or "_" in span_type
+
+
+class TestRunEvaluatorSpan:
+    """Tests specifically for the run_evaluator span creation."""
+
+    @pytest.fixture
+    def mock_evaluator(self):
+        """Create a mock evaluator for testing."""
+        evaluator = MagicMock(spec=BaseEvaluator)
+        evaluator.id = "test-evaluator-id"
+        evaluator.name = "TestEvaluator"
+        return evaluator
+
+    @pytest.fixture
+    def mock_eval_item(self):
+        """Create a mock eval item for testing."""
+        eval_item = MagicMock(spec=EvaluationItem)
+        eval_item.id = "test-item-id"
+        eval_item.name = "Test Item"
+        eval_item.inputs = {"query": "test query"}
+        eval_item.expected_agent_behavior = "Expected behavior"
+        return eval_item
+
+    def test_evaluator_span_name_uses_evaluator_name(self, mock_evaluator):
+        """Test that evaluator span name uses the evaluator's name."""
+        span_name = f"Evaluator: {mock_evaluator.name}"
+        assert span_name == "Evaluator: TestEvaluator"
+
+    def test_evaluator_span_includes_evaluator_details(
+        self, mock_evaluator, mock_eval_item
+    ):
+        """Test that evaluator span includes all evaluator details."""
+        span_attributes = {
+            "span_type": "evaluator",
+            "evaluator_id": mock_evaluator.id,
+            "evaluator_name": mock_evaluator.name,
+            "eval_item_id": mock_eval_item.id,
+        }
+
+        assert span_attributes["evaluator_id"] == "test-evaluator-id"
+        assert span_attributes["evaluator_name"] == "TestEvaluator"
+        assert span_attributes["eval_item_id"] == "test-item-id"
+
+
+class TestExecutionIdPropagation:
+    """Tests for execution.id propagation in spans."""
+
+    def test_execution_id_format(self):
+        """Test that execution.id is in valid UUID format."""
+        execution_id = str(uuid.uuid4())
+
+        # Verify it's a valid UUID
+        try:
+            uuid.UUID(execution_id)
+            valid = True
+        except ValueError:
+            valid = False
+
+        assert valid
+
+    def test_execution_id_is_unique_per_eval(self):
+        """Test that each eval gets a unique execution_id."""
+        execution_ids = [str(uuid.uuid4()) for _ in range(5)]
+
+        # All should be unique
+        assert len(set(execution_ids)) == 5
+
+    def test_evaluation_span_has_execution_id(self):
+        """Test that Evaluation span includes execution.id."""
+        execution_id = str(uuid.uuid4())
+
+        span_attributes = {
+            "execution.id": execution_id,
+            "span_type": "evaluation",
+            "eval_item_id": "item-123",
+            "eval_item_name": "Test Item",
+        }
+
+        assert "execution.id" in span_attributes
+        assert span_attributes["execution.id"] == execution_id
+
+
+class TestEvaluationOutputSpan:
+    """Tests for the 'Evaluation output' span."""
+
+    def test_span_name_is_correct(self):
+        """Test that the span name is 'Evaluation output'."""
+        expected_name = "Evaluation output"
+        assert expected_name == "Evaluation output"
+
+    def test_span_has_eval_output_span_type(self):
+        """Test that span_type attribute is 'evalOutput'."""
+        span_attributes = {"span.type": "evalOutput"}
+        assert span_attributes["span.type"] == "evalOutput"
+
+    def test_span_includes_value(self):
+        """Test that value (score) is included in the span attributes."""
+        score = 0.95
+        span_attributes = {
+            "span.type": "evalOutput",
+            "value": score,
+        }
+        assert "value" in span_attributes
+        assert span_attributes["value"] == 0.95
+
+    def test_span_includes_evaluator_id(self):
+        """Test that evaluatorId is included in the span attributes."""
+        evaluator_id = "evaluator-123"
+        span_attributes = {
+            "span.type": "evalOutput",
+            "evaluatorId": evaluator_id,
+        }
+        assert "evaluatorId" in span_attributes
+        assert span_attributes["evaluatorId"] == evaluator_id
+
+    def test_span_includes_justification(self):
+        """Test that justification is included in the span attributes."""
+        justification = "The output matches expected behavior."
+        span_attributes = {
+            "span.type": "evalOutput",
+            "justification": justification,
+        }
+        assert "justification" in span_attributes
+        assert span_attributes["justification"] == justification
+
+    def test_span_has_all_required_attributes(self):
+        """Test that all required attributes are present in the span."""
+        evaluator_id = "eval-id-123"
+        score = 100
+        justification = "Perfect match"
+
+        span_attributes = {
+            "span.type": "evalOutput",
+            "value": score,
+            "evaluatorId": evaluator_id,
+            "justification": justification,
+        }
+
+        # Verify all required attributes
+        required_attrs = ["span.type", "value", "evaluatorId", "justification"]
+        for attr in required_attrs:
+            assert attr in span_attributes, f"Missing required attribute: {attr}"
+
+    def test_span_has_openinference_kind(self):
+        """Test that openinference.span.kind is set to CHAIN."""
+        span_attributes = {
+            "openinference.span.kind": "CHAIN",
+            "span.type": "evalOutput",
+        }
+        assert span_attributes["openinference.span.kind"] == "CHAIN"
+
+    def test_span_has_output_attribute_with_type_value_justification(self):
+        """Test that span has output attribute with type, value, and justification."""
+        import json
+
+        # Simulate the output attribute set by set_evaluation_output_span_output
+        output_data = {
+            "type": 1,
+            "value": 0.92,
+            "justification": "The outputs are semantically equivalent",
+        }
+        output_json = json.dumps(output_data)
+
+        span_attributes = {
+            "span.type": "evalOutput",
+            "output": output_json,
+        }
+
+        assert "output" in span_attributes
+        parsed_output = json.loads(span_attributes["output"])
+        assert parsed_output["type"] == 1
+        assert parsed_output["value"] == 0.92
+        assert (
+            parsed_output["justification"] == "The outputs are semantically equivalent"
+        )
+
+    def test_span_output_type_is_always_one(self):
+        """Test that output type field is always 1."""
+        import json
+
+        output_data = {"type": 1, "value": 0.5}
+        output_json = json.dumps(output_data)
+
+        span_attributes = {
+            "span.type": "evalOutput",
+            "output": output_json,
+        }
+
+        parsed_output = json.loads(span_attributes["output"])
+        assert parsed_output["type"] == 1
+
+    def test_span_output_without_justification(self):
+        """Test that output can be set without justification field."""
+        import json
+
+        # When justification is None, it should be excluded from output
+        output_data = {"type": 1, "value": 0.75}
+        output_json = json.dumps(output_data)
+
+        span_attributes = {
+            "span.type": "evalOutput",
+            "output": output_json,
+        }
+
+        parsed_output = json.loads(span_attributes["output"])
+        assert parsed_output["type"] == 1
+        assert parsed_output["value"] == 0.75
+        assert "justification" not in parsed_output
+
+
+class TestEvaluationOutputSpanHierarchy:
+    """Tests verifying the Evaluation output span hierarchy."""
+
+    def test_eval_output_is_child_of_evaluator(self):
+        """Test that Evaluation output spans should be children of Evaluator spans."""
+        parent_span_type = "evaluator"
+        child_span_type = "evalOutput"
+
+        # The parent-child relationship is enforced by span context nesting
+        assert parent_span_type == "evaluator"
+        assert child_span_type == "evalOutput"
+
+    def test_eval_output_span_attributes_construction(self):
+        """Test the construction of Evaluation output span attributes."""
+        evaluator_id = "eval-123"
+        score = 0.85
+        justification = "Good accuracy"
+
+        span_attributes = {
+            "openinference.span.kind": "CHAIN",
+            "span.type": "evalOutput",
+            "value": score,
+            "evaluatorId": evaluator_id,
+            "justification": justification,
+        }
+
+        assert span_attributes["openinference.span.kind"] == "CHAIN"
+        assert span_attributes["span.type"] == "evalOutput"
+        assert span_attributes["value"] == 0.85
+        assert span_attributes["evaluatorId"] == "eval-123"
+        assert span_attributes["justification"] == "Good accuracy"
+
+
+class TestEvaluationOutputSpanCreation:
+    """Tests for Evaluation output span creation in progress reporter."""
+
+    def test_eval_output_span_name_is_evaluation_output(self):
+        """Test that the span name is exactly 'Evaluation output'."""
+        span_name = "Evaluation output"
+        assert span_name == "Evaluation output"
+
+    def test_eval_output_span_type_is_camel_case(self):
+        """Test that span.type uses camelCase: evalOutput."""
+        span_type = "evalOutput"
+        assert span_type == "evalOutput"
+        # First letter lowercase, second word capitalized
+        assert span_type[0].islower()
+        assert "Output" in span_type
+
+    def test_eval_output_with_pydantic_details(self):
+        """Test that justification is extracted from Pydantic model details."""
+        # Simulate Pydantic model details with justification field
+        details_dict = {
+            "justification": "The semantic similarity is perfect.",
+            "other_field": "some value",
+        }
+
+        # Extract justification like the code does
+        justification = details_dict.get("justification", str(details_dict))
+        assert justification == "The semantic similarity is perfect."
+
+    def test_eval_output_with_string_details(self):
+        """Test that string details are used as justification directly."""
+        details = "Good accuracy on all test cases"
+
+        # String details are used directly
+        justification = str(details)
+        assert justification == "Good accuracy on all test cases"
+
+    def test_eval_output_without_justification_field(self):
+        """Test fallback when details dict has no justification field."""
+        import json
+
+        details_dict: dict[str, float] = {
+            "accuracy": 0.95,
+            "precision": 0.92,
+        }
+
+        # Should fall back to JSON dump of entire details
+        # Since there's no "justification" key, we get the default JSON string
+        justification = json.dumps(details_dict)
+        assert "accuracy" in justification
+        assert "0.95" in justification
diff --git a/packages/uipath/tests/cli/eval/test_eval_runtime_suspend_resume.py b/packages/uipath/tests/cli/eval/test_eval_runtime_suspend_resume.py
new file mode 100644
index 000000000..c9558af03
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_runtime_suspend_resume.py
@@ -0,0 +1,389 @@
+"""Tests for UiPathEvalRuntime suspend/resume event publishing.
+
+This module tests:
+- Normal flow: CREATE_EVAL_RUN event is published, eval_run_id saved to disk
+- Resume flow: CREATE_EVAL_RUN event is NOT published, eval_run_id loaded from disk
+- UPDATE_EVAL_RUN works correctly after evaluators complete
+- Ensures no duplicate eval run entries in StudioWeb
+"""
+
+import uuid
+from pathlib import Path
+from typing import Any, AsyncGenerator
+from unittest.mock import AsyncMock
+
+import pytest
+
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.helpers import EvalHelpers
+from uipath.eval.runtime import UiPathEvalContext, evaluate
+from uipath.eval.runtime.events import EvaluationEvents
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeEvent,
+    UiPathRuntimeFactorySettings,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+    UiPathRuntimeStorageProtocol,
+    UiPathStreamOptions,
+)
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+
+class MockRuntimeSchema(UiPathRuntimeSchema):
+    """Mock schema for testing."""
+
+    def __init__(self):
+        super().__init__(
+            filePath="test.py",
+            uniqueId="test",
+            type="agent",
+            input={"type": "object", "properties": {}},
+            output={"type": "object", "properties": {}},
+        )
+
+
+class SuspendingRuntime:
+    """Test runtime that returns SUSPENDED status."""
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        # Simulate an agent that suspends
+        # Returning SUSPENDED status is sufficient for our test
+        return UiPathRuntimeResult(
+            output={},
+            status=UiPathRuntimeStatus.SUSPENDED,
+        )
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathStreamOptions | None = None,
+    ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        yield UiPathRuntimeResult(
+            output={},
+            status=UiPathRuntimeStatus.SUSPENDED,
+        )
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return MockRuntimeSchema()
+
+    async def dispose(self) -> None:
+        pass
+
+
+class SuccessfulRuntime:
+    """Test runtime that returns SUCCESSFUL status."""
+
+    async def execute(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathExecuteOptions | None = None,
+    ) -> UiPathRuntimeResult:
+        return UiPathRuntimeResult(
+            output={"result": "success"},
+            status=UiPathRuntimeStatus.SUCCESSFUL,
+        )
+
+    async def stream(
+        self,
+        input: dict[str, Any] | None = None,
+        options: UiPathStreamOptions | None = None,
+    ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+        yield UiPathRuntimeResult(
+            output={"result": "success"},
+            status=UiPathRuntimeStatus.SUCCESSFUL,
+        )
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return MockRuntimeSchema()
+
+    async def dispose(self) -> None:
+        pass
+
+
+class MockFactory:
+    """Mock factory for creating test runtimes."""
+
+    def __init__(self, runtime_creator):
+        self.runtime_creator = runtime_creator
+
+    def discover_entrypoints(self) -> list[str]:
+        return ["test"]
+
+    async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+        return None
+
+    async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+        return None
+
+    async def new_runtime(
+        self, entrypoint: str, runtime_id: str, **kwargs
+    ) -> UiPathRuntimeProtocol:
+        return await self.runtime_creator()
+
+    async def dispose(self) -> None:
+        pass
+
+
+@pytest.fixture
+async def context():
+    """Create eval context."""
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+
+    # Load evaluation set
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create a mock runtime to get schema
+    runtime = SuccessfulRuntime()
+    runtime_schema = await runtime.get_schema()
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+
+    return context
+
+
+@pytest.fixture
+def event_bus():
+    """Create event bus with mocked publish method."""
+    bus = EventBus()
+    bus.publish = AsyncMock()  # type: ignore[method-assign]
+    return bus
+
+
+@pytest.fixture
+def trace_manager():
+    """Create trace manager."""
+    return UiPathTraceManager()
+
+
+class TestNormalFlowCreateEvalRun:
+    """Tests for normal execution flow - CREATE_EVAL_RUN should be published."""
+
+    async def test_publishes_create_eval_run_on_successful_execution(
+        self, context, event_bus, trace_manager
+    ):
+        """Test that CREATE_EVAL_RUN is published during normal successful execution."""
+
+        # Arrange
+        async def create_runtime():
+            return SuccessfulRuntime()
+
+        factory = MockFactory(create_runtime)
+
+        # Act
+        await evaluate(factory, trace_manager, context, event_bus)
+
+        # Assert
+        # Check that CREATE_EVAL_RUN was published
+        create_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        assert len(create_calls) > 0, (
+            "CREATE_EVAL_RUN should be published in normal flow"
+        )
+
+    async def test_publishes_create_eval_run_on_suspend(
+        self, context, event_bus, trace_manager
+    ):
+        """Test that CREATE_EVAL_RUN is published when agent suspends."""
+
+        # Arrange
+        async def create_runtime():
+            return SuspendingRuntime()
+
+        factory = MockFactory(create_runtime)
+
+        # Act
+        await evaluate(factory, trace_manager, context, event_bus)
+
+        # Assert
+        # Check that CREATE_EVAL_RUN was published
+        create_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        assert len(create_calls) > 0, (
+            "CREATE_EVAL_RUN should be published on suspend (initial execution)"
+        )
+
+
+class TestResumeFlowSkipsCreateEvalRun:
+    """Tests for resume flow - CREATE_EVAL_RUN should NOT be published, eval_run_id loaded from disk."""
+
+    async def test_skips_create_eval_run_on_resume(
+        self, context, event_bus, trace_manager
+    ):
+        """Test that CREATE_EVAL_RUN is NOT published when resuming from checkpoint.
+
+        During resume, the eval_run_id mapping is loaded from the persisted file
+        (__uipath/eval_run_ids.json) instead of making a new CREATE_EVAL_RUN API call.
+        This prevents duplicate entries in StudioWeb.
+        """
+        # Arrange
+        context.resume = True  # Set resume flag
+
+        async def create_runtime():
+            return SuccessfulRuntime()
+
+        factory = MockFactory(create_runtime)
+
+        # Act
+        await evaluate(factory, trace_manager, context, event_bus)
+
+        # Assert
+        # Check that CREATE_EVAL_RUN was NOT published
+        create_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        assert len(create_calls) == 0, (
+            "CREATE_EVAL_RUN should NOT be published on resume (loaded from disk instead)"
+        )
+
+    async def test_publishes_update_eval_run_on_resume(
+        self, context, event_bus, trace_manager
+    ):
+        """Test that UPDATE_EVAL_RUN is still published when resuming."""
+        # Arrange
+        context.resume = True  # Set resume flag
+
+        async def create_runtime():
+            return SuccessfulRuntime()
+
+        factory = MockFactory(create_runtime)
+
+        # Act
+        await evaluate(factory, trace_manager, context, event_bus)
+
+        # Assert
+        # Check that UPDATE_EVAL_RUN was published
+        update_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.UPDATE_EVAL_RUN
+        ]
+        assert len(update_calls) > 0, (
+            "UPDATE_EVAL_RUN should still be published on resume"
+        )
+
+    async def test_resume_flag_false_by_default(self, context):
+        """Test that resume flag is False by default in context."""
+        assert context.resume is False, "resume should default to False"
+
+    async def test_no_duplicate_entries_on_resume(
+        self, context, event_bus, trace_manager
+    ):
+        """Test that resuming doesn't create duplicate entries (integration test concept).
+
+        This test verifies that when resume=True:
+        1. CREATE_EVAL_RUN is NOT called (prevents duplicate backend entries)
+        2. Only UPDATE_EVAL_RUN is called (updates existing entry)
+
+        The eval_run_id mapping is loaded from persisted state on disk.
+        """
+        # Arrange
+        context.resume = True
+
+        async def create_runtime():
+            return SuccessfulRuntime()
+
+        factory = MockFactory(create_runtime)
+
+        # Act
+        await evaluate(factory, trace_manager, context, event_bus)
+
+        # Assert
+        create_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        update_calls = [
+            call
+            for call in event_bus.publish.call_args_list
+            if call[0][0] == EvaluationEvents.UPDATE_EVAL_RUN
+        ]
+
+        assert len(create_calls) == 0, "Should NOT create new entry on resume"
+        assert len(update_calls) > 0, "Should update existing entry on resume"
+
+
+class TestSuspendResumeLifecycle:
+    """Tests for complete suspend/resume lifecycle."""
+
+    async def test_suspend_then_resume_lifecycle(self, context, trace_manager):
+        """Test complete lifecycle: suspend (creates entry) then resume (updates entry)."""
+        # Phase 1: Suspend
+        event_bus_suspend = EventBus()
+        event_bus_suspend.publish = AsyncMock()  # type: ignore[method-assign]
+
+        async def create_suspending_runtime():
+            return SuspendingRuntime()
+
+        factory_suspend = MockFactory(create_suspending_runtime)
+
+        await evaluate(factory_suspend, trace_manager, context, event_bus_suspend)
+
+        # Assert suspend phase
+        suspend_create_calls = [
+            call
+            for call in event_bus_suspend.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        suspend_update_calls = [
+            call
+            for call in event_bus_suspend.publish.call_args_list
+            if call[0][0] == EvaluationEvents.UPDATE_EVAL_RUN
+        ]
+
+        assert len(suspend_create_calls) > 0, "Suspend phase should CREATE entry"
+        assert len(suspend_update_calls) == 0, (
+            "Suspend phase should NOT UPDATE - evalRun stays IN_PROGRESS until resume"
+        )
+
+        # Phase 2: Resume
+        context.resume = True
+        event_bus_resume = EventBus()
+        event_bus_resume.publish = AsyncMock()  # type: ignore[method-assign]
+
+        async def create_successful_runtime():
+            return SuccessfulRuntime()
+
+        factory_resume = MockFactory(create_successful_runtime)
+
+        await evaluate(factory_resume, trace_manager, context, event_bus_resume)
+
+        # Assert resume phase
+        resume_create_calls = [
+            call
+            for call in event_bus_resume.publish.call_args_list
+            if call[0][0] == EvaluationEvents.CREATE_EVAL_RUN
+        ]
+        resume_update_calls = [
+            call
+            for call in event_bus_resume.publish.call_args_list
+            if call[0][0] == EvaluationEvents.UPDATE_EVAL_RUN
+        ]
+
+        assert len(resume_create_calls) == 0, "Resume phase should NOT CREATE new entry"
+        assert len(resume_update_calls) > 0, "Resume phase should UPDATE existing entry"
diff --git a/packages/uipath/tests/cli/eval/test_eval_set.py b/packages/uipath/tests/cli/eval/test_eval_set.py
new file mode 100644
index 000000000..fdc049316
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_set.py
@@ -0,0 +1,221 @@
+"""Tests for evaluation set loading and migration functions."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from uipath.eval.helpers import EvalHelpers
+from uipath.eval.mocks._types import LLMMockingStrategy
+from uipath.eval.models.evaluation_set import (
+    EvaluationSet,
+)
+
+
+@pytest.mark.asyncio
+async def test_migrate_evaluation_item_with_empty_simulation_instructions():
+    """Test that migration supports empty simulation_instructions.
+
+    This test verifies the fix that allows LLMMockingStrategy to be created
+    even when simulation_instructions is None or empty, as long as
+    simulate_tools is True.
+    """
+    # Create a legacy evaluation set with simulate_tools=True but
+    # simulation_instructions is None (empty)
+    legacy_eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": ["evaluator1"],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test Empty Simulation Instructions",
+                "inputs": {"test": "value"},
+                "expectedOutput": {"result": "success"},
+                "expectedAgentBehavior": "Should handle empty simulation",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-01-26T00:00:00.000Z",
+                "updatedAt": "2025-01-26T00:00:00.000Z",
+                "simulateTools": True,
+                "simulationInstructions": None,  # Empty instructions
+                "toolsToSimulate": [],
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-01-26T00:00:00.000Z",
+        "updatedAt": "2025-01-26T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(legacy_eval_set, f)
+
+        # Load the evaluation set
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+
+        # Verify it was migrated to EvaluationSet (not LegacyEvaluationSet)
+        assert isinstance(loaded_eval_set, EvaluationSet)
+        assert len(loaded_eval_set.evaluations) == 1
+
+        evaluation = loaded_eval_set.evaluations[0]
+
+        # The key assertion: mocking_strategy should be created despite
+        # empty simulation_instructions
+        assert evaluation.mocking_strategy is not None
+        assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+
+        # Verify the strategy has an empty prompt (not None)
+        assert evaluation.mocking_strategy.prompt == ""
+        assert evaluation.mocking_strategy.tools_to_simulate == []
+
+
+@pytest.mark.asyncio
+async def test_migrate_evaluation_item_with_simulation_instructions():
+    """Test migration with non-empty simulation instructions."""
+    legacy_eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": ["evaluator1"],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test With Simulation Instructions",
+                "inputs": {"test": "value"},
+                "expectedOutput": {"result": "success"},
+                "expectedAgentBehavior": "Should use provided instructions",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-01-26T00:00:00.000Z",
+                "updatedAt": "2025-01-26T00:00:00.000Z",
+                "simulateTools": True,
+                "simulationInstructions": "Mock the API calls",
+                "toolsToSimulate": [{"name": "api_call"}],
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-01-26T00:00:00.000Z",
+        "updatedAt": "2025-01-26T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(legacy_eval_set, f)
+
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+
+        assert isinstance(loaded_eval_set, EvaluationSet)
+        assert len(loaded_eval_set.evaluations) == 1
+
+        evaluation = loaded_eval_set.evaluations[0]
+
+        # Verify the strategy was created with the provided instructions
+        assert evaluation.mocking_strategy is not None
+        assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+        assert evaluation.mocking_strategy.prompt == "Mock the API calls"
+        assert len(evaluation.mocking_strategy.tools_to_simulate) == 1
+        assert evaluation.mocking_strategy.tools_to_simulate[0].name == "api_call"
+
+
+@pytest.mark.asyncio
+async def test_migrate_evaluation_item_without_simulate_tools():
+    """Test that no mocking_strategy is created when simulate_tools is False/None."""
+    legacy_eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": ["evaluator1"],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test Without Tool Simulation",
+                "inputs": {"test": "value"},
+                "expectedOutput": {"result": "success"},
+                "expectedAgentBehavior": "No tool simulation",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-01-26T00:00:00.000Z",
+                "updatedAt": "2025-01-26T00:00:00.000Z",
+                "simulateTools": False,
+                "simulationInstructions": "Mock the API calls",
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-01-26T00:00:00.000Z",
+        "updatedAt": "2025-01-26T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(legacy_eval_set, f)
+
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+
+        assert isinstance(loaded_eval_set, EvaluationSet)
+        assert len(loaded_eval_set.evaluations) == 1
+
+        evaluation = loaded_eval_set.evaluations[0]
+
+        # When simulate_tools is False, no mocking_strategy should be created
+        assert evaluation.mocking_strategy is None
+
+
+@pytest.mark.asyncio
+async def test_migrate_evaluation_item_with_input_mocking():
+    """Test migration with input mocking strategy."""
+    legacy_eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": ["evaluator1"],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test With Input Mocking",
+                "inputs": {"test": "value"},
+                "expectedOutput": {"result": "success"},
+                "expectedAgentBehavior": "Should have input mocking",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-01-26T00:00:00.000Z",
+                "updatedAt": "2025-01-26T00:00:00.000Z",
+                "simulateInput": True,
+                "inputGenerationInstructions": "Generate test inputs",
+                "simulateTools": True,
+                "simulationInstructions": None,
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-01-26T00:00:00.000Z",
+        "updatedAt": "2025-01-26T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(legacy_eval_set, f)
+
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+
+        assert isinstance(loaded_eval_set, EvaluationSet)
+        assert len(loaded_eval_set.evaluations) == 1
+
+        evaluation = loaded_eval_set.evaluations[0]
+
+        # Both strategies should be present
+        assert evaluation.input_mocking_strategy is not None
+        assert evaluation.input_mocking_strategy.prompt == "Generate test inputs"
+
+        assert evaluation.mocking_strategy is not None
+        assert isinstance(evaluation.mocking_strategy, LLMMockingStrategy)
+        assert evaluation.mocking_strategy.prompt == ""
diff --git a/packages/uipath/tests/cli/eval/test_eval_span_utils.py b/packages/uipath/tests/cli/eval/test_eval_span_utils.py
new file mode 100644
index 000000000..c6b48b0b6
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_span_utils.py
@@ -0,0 +1,517 @@
+"""Unit tests for evaluation span utility functions."""
+
+import json
+from typing import Any, Dict, Optional
+from unittest.mock import MagicMock
+
+import pytest
+from opentelemetry.trace import Status, StatusCode
+
+from uipath.eval.runtime._spans import (
+    EvalSetRunOutput,
+    EvaluationOutput,
+    EvaluationOutputSpanOutput,
+    configure_eval_set_run_span,
+    configure_evaluation_span,
+    extract_evaluator_scores,
+    normalize_score_to_100,
+    set_eval_set_run_output_and_metadata,
+    set_evaluation_output_and_metadata,
+    set_evaluation_output_span_output,
+)
+
+
+class MockSpan:
+    """Mock span for testing."""
+
+    def __init__(self) -> None:
+        self.attributes: Dict[str, Any] = {}
+        self._status: Optional[Status] = None
+
+    def set_attribute(self, key: str, value: Any) -> None:
+        self.attributes[key] = value
+
+    def set_status(self, status: Status) -> None:
+        self._status = status
+
+
+class TestPydanticModels:
+    """Test the Pydantic models for span outputs."""
+
+    def test_eval_set_run_output_model(self):
+        """Test EvalSetRunOutput model serialization."""
+        output = EvalSetRunOutput(scores={"eval1": 85.5, "eval2": 92.3})
+        json_str = output.model_dump_json(by_alias=True)
+        data = json.loads(json_str)
+
+        assert data == {"scores": {"eval1": 85.5, "eval2": 92.3}}
+        assert isinstance(data["scores"], dict)
+        assert isinstance(data["scores"]["eval1"], float)
+
+    def test_evaluation_output_model(self):
+        """Test EvaluationOutput model serialization."""
+        output = EvaluationOutput(scores={"eval1": 90.5, "eval2": 88.0})
+        json_str = output.model_dump_json(by_alias=True)
+        data = json.loads(json_str)
+
+        assert data == {"scores": {"eval1": 90.5, "eval2": 88.0}}
+        assert isinstance(data["scores"], dict)
+
+    def test_evaluation_output_span_output_model_with_justification(self):
+        """Test EvaluationOutputSpanOutput model with justification."""
+        output = EvaluationOutputSpanOutput(
+            score=75.5,
+            evaluator_id="eval-123",
+            justification="The output is semantically similar",
+        )
+        json_str = output.model_dump_json(by_alias=True, exclude_none=True)
+        data = json.loads(json_str)
+
+        assert data["type"] == 1
+        assert data["score"] == 75.5
+        assert data["evaluatorId"] == "eval-123"
+        assert data["justification"] == "The output is semantically similar"
+
+    def test_evaluation_output_span_output_model_without_justification(self):
+        """Test EvaluationOutputSpanOutput model without justification."""
+        output = EvaluationOutputSpanOutput(score=75.5, evaluator_id="eval-456")
+        json_str = output.model_dump_json(by_alias=True, exclude_none=True)
+        data = json.loads(json_str)
+
+        assert data["type"] == 1
+        assert data["score"] == 75.5
+        assert data["evaluatorId"] == "eval-456"
+        assert "justification" not in data
+
+
+class TestNormalizationFunctions:
+    """Test the score normalization functions."""
+
+    def test_normalize_score_0_to_1_range(self):
+        """Test normalizing scores in 0-1 range to 0-100."""
+        assert normalize_score_to_100(0.0) == 0.0
+        assert normalize_score_to_100(0.5) == 50.0
+        assert normalize_score_to_100(1.0) == 100.0
+        assert normalize_score_to_100(0.857142) == 85.71
+
+    def test_normalize_score_0_to_100_range(self):
+        """Test that scores in 0-100 range stay the same."""
+        assert normalize_score_to_100(0.0) == 0.0
+        assert normalize_score_to_100(50.0) == 50.0
+        assert normalize_score_to_100(100.0) == 100.0
+        assert normalize_score_to_100(85.71) == 85.71
+
+    def test_normalize_score_clamps_out_of_range(self):
+        """Test that out-of-range scores are clamped."""
+        assert normalize_score_to_100(-10.0) == 0.0
+        assert normalize_score_to_100(150.0) == 100.0
+
+    def test_extract_evaluator_scores(self):
+        """Test extracting evaluator scores from results."""
+        mock_result1 = MagicMock()
+        mock_result1.evaluator_name = "eval1"
+        mock_result1.result.score = 0.8
+
+        mock_result2 = MagicMock()
+        mock_result2.evaluator_name = "eval2"
+        mock_result2.result.score = 90.0
+
+        mock_evaluation_run_results = MagicMock()
+        mock_evaluation_run_results.evaluation_run_results = [
+            mock_result1,
+            mock_result2,
+        ]
+
+        scores = extract_evaluator_scores(mock_evaluation_run_results)
+
+        assert scores == {"eval1": 80.0, "eval2": 90.0}
+
+    def test_extract_evaluator_scores_empty(self):
+        """Test extracting scores from empty results."""
+        mock_evaluation_run_results = MagicMock()
+        mock_evaluation_run_results.evaluation_run_results = []
+
+        scores = extract_evaluator_scores(mock_evaluation_run_results)
+
+        assert scores == {}
+
+
+class TestSetSpanAttributeFunctions:
+    """Test the low-level span attribute setting functions."""
+
+    def test_set_eval_set_run_output_and_metadata(self):
+        """Test setting evaluation set run span attributes."""
+        span = MockSpan()
+
+        set_eval_set_run_output_and_metadata(
+            span=span,  # type: ignore[arg-type]
+            evaluator_scores={"eval1": 82.5, "eval2": 90.0},
+            execution_id="exec-123",
+            input_schema={"type": "object"},
+            output_schema={"type": "string"},
+            success=True,
+        )
+
+        # Check output
+        assert "output" in span.attributes
+        output_data = json.loads(span.attributes["output"])
+        assert output_data == {"scores": {"eval1": 82.5, "eval2": 90.0}}
+
+        # Check metadata
+        assert span.attributes["agentId"] == "exec-123"
+        assert span.attributes["agentName"] == "N/A"
+
+        # Check schemas
+        input_schema_data = json.loads(span.attributes["inputSchema"])
+        assert input_schema_data == {"type": "object"}
+
+        output_schema_data = json.loads(span.attributes["outputSchema"])
+        assert output_schema_data == {"type": "string"}
+
+        # Check status
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.OK
+
+    def test_set_evaluation_output_and_metadata(self):
+        """Test setting evaluation span attributes."""
+        span = MockSpan()
+
+        set_evaluation_output_and_metadata(
+            span=span,  # type: ignore[arg-type]
+            evaluator_scores={"eval1": 88.3, "eval2": 92.0},
+            execution_id="eval-789",
+            has_error=False,
+            error_message=None,
+        )
+
+        # Check output
+        assert "output" in span.attributes
+        output_data = json.loads(span.attributes["output"])
+        assert output_data == {"scores": {"eval1": 88.3, "eval2": 92.0}}
+
+        # Check metadata
+        assert span.attributes["agentId"] == "eval-789"
+        assert span.attributes["agentName"] == "N/A"
+
+        # Check status is OK
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.OK
+
+    def test_set_evaluation_output_span_output_with_justification(self):
+        """Test setting evaluation output span attributes with justification."""
+        span = MockSpan()
+
+        set_evaluation_output_span_output(
+            span=span,  # type: ignore[arg-type]
+            score=92.7,
+            evaluator_id="evaluator-xyz",
+            justification="The answer is correct and well-formatted",
+        )
+
+        # Check output
+        assert "output" in span.attributes
+        output_data = json.loads(span.attributes["output"])
+
+        assert output_data["type"] == 1
+        assert output_data["score"] == 92.7
+        assert output_data["evaluatorId"] == "evaluator-xyz"
+        assert (
+            output_data["justification"] == "The answer is correct and well-formatted"
+        )
+
+    def test_set_evaluation_output_span_output_normalizes_0_to_1_score(self):
+        """Test that 0-1 scores are normalized to 0-100."""
+        span = MockSpan()
+
+        set_evaluation_output_span_output(
+            span=span,  # type: ignore[arg-type]
+            score=0.857,
+            evaluator_id="evaluator-abc",
+        )
+
+        # Check output
+        assert "output" in span.attributes
+        output_data = json.loads(span.attributes["output"])
+
+        assert output_data["score"] == 85.7  # 0.857 * 100
+
+    def test_set_evaluation_output_span_output_without_justification(self):
+        """Test setting evaluation output span attributes without justification."""
+        span = MockSpan()
+
+        set_evaluation_output_span_output(
+            span=span,  # type: ignore[arg-type]
+            score=85.0,
+            evaluator_id="evaluator-abc",
+        )
+
+        # Check output
+        assert "output" in span.attributes
+        output_data = json.loads(span.attributes["output"])
+
+        assert output_data["type"] == 1
+        assert output_data["score"] == 85.0
+        assert output_data["evaluatorId"] == "evaluator-abc"
+        assert "justification" not in output_data
+
+    def test_set_evaluation_output_and_metadata_with_error(self):
+        """Test setting evaluation span attributes with error."""
+        span = MockSpan()
+
+        set_evaluation_output_and_metadata(
+            span=span,  # type: ignore[arg-type]
+            evaluator_scores={"eval1": 0.0},
+            execution_id="eval-error",
+            has_error=True,
+            error_message="Runtime error occurred",
+        )
+
+        # Check status is ERROR
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.ERROR
+        assert span._status.description is not None
+        assert "Runtime error occurred" in span._status.description
+
+    def test_set_evaluation_output_and_metadata_with_input_data(self):
+        """Test setting evaluation span attributes with input data."""
+        span = MockSpan()
+
+        input_data = {"query": "test", "context": "example"}
+
+        set_evaluation_output_and_metadata(
+            span=span,  # type: ignore[arg-type]
+            evaluator_scores={"eval1": 92.0},
+            execution_id="eval-input-test",
+            input_data=input_data,
+            has_error=False,
+        )
+
+        # Verify input is set
+        assert "input" in span.attributes
+        input_parsed = json.loads(span.attributes["input"])
+        assert input_parsed == {"query": "test", "context": "example"}
+
+        # Verify output is set with scores
+        output_data = json.loads(span.attributes["output"])
+        assert output_data["scores"] == {"eval1": 92.0}
+
+        # Verify other attributes
+        assert span.attributes["agentId"] == "eval-input-test"
+
+
+class TestHighLevelConfigurationFunctions:
+    """Test the high-level span configuration functions."""
+
+    @pytest.mark.asyncio
+    async def test_configure_eval_set_run_span(self):
+        """Test configuring evaluation set run span with scores dictionary."""
+        span = MockSpan()
+
+        evaluator_averages = {
+            "TrajectoryEvaluator": 80.0,
+            "JsonSimilarityEvaluator": 90.0,
+        }
+
+        # Mock schema
+        mock_schema = MagicMock()
+        mock_schema.input = {
+            "type": "object",
+            "properties": {"x": {"type": "number"}},
+        }
+        mock_schema.output = {"type": "string"}
+
+        await configure_eval_set_run_span(
+            span=span,  # type: ignore[arg-type]
+            evaluator_averages=evaluator_averages,
+            execution_id="exec-complete",
+            schema=mock_schema,
+            success=True,
+        )
+
+        # Verify scores dictionary
+        output_data = json.loads(span.attributes["output"])
+        assert "scores" in output_data
+        assert output_data["scores"]["TrajectoryEvaluator"] == 80.0
+        assert output_data["scores"]["JsonSimilarityEvaluator"] == 90.0
+
+        # Verify metadata
+        assert span.attributes["agentId"] == "exec-complete"
+        assert span.attributes["agentName"] == "N/A"
+
+        # Verify input schema
+        input_schema_data = json.loads(span.attributes["inputSchema"])
+        assert "properties" in input_schema_data
+        assert input_schema_data["properties"]["x"]["type"] == "number"
+
+        # Verify output schema
+        output_schema_data = json.loads(span.attributes["outputSchema"])
+        assert output_schema_data == {"type": "string"}
+
+        # Verify status
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.OK
+
+    @pytest.mark.asyncio
+    async def test_configure_eval_set_run_span_schema_error(self):
+        """Test configuring evaluation set run span when schema fails."""
+        span = MockSpan()
+
+        evaluator_averages = {"ContainsEvaluator": 75.0}
+
+        # Mock schema with missing fields
+        mock_schema = MagicMock()
+        mock_schema.input = None
+        mock_schema.output = None
+
+        await configure_eval_set_run_span(
+            span=span,  # type: ignore[arg-type]
+            evaluator_averages=evaluator_averages,
+            execution_id="exec-error",
+            schema=mock_schema,
+            success=True,
+        )
+
+        # Verify scores still set
+        output_data = json.loads(span.attributes["output"])
+        assert output_data["scores"]["ContainsEvaluator"] == 75.0
+
+        # Verify metadata still set
+        assert span.attributes["agentId"] == "exec-error"
+
+        # Verify schemas are empty objects when schema extraction fails
+        assert span.attributes["inputSchema"] == "{}"
+        assert span.attributes["outputSchema"] == "{}"
+
+    @pytest.mark.asyncio
+    async def test_configure_eval_set_run_span_normalizes_scores(self):
+        """Test that scores are normalized to 0-100 range."""
+        span = MockSpan()
+
+        # Provide scores in 0-1 range
+        evaluator_averages = {
+            "eval1": 0.75,
+            "eval2": 0.92,
+        }
+
+        mock_schema = MagicMock()
+        mock_schema.input = {}
+        mock_schema.output = {}
+
+        await configure_eval_set_run_span(
+            span=span,  # type: ignore[arg-type]
+            evaluator_averages=evaluator_averages,
+            execution_id="exec-normalize",
+            schema=mock_schema,
+            success=True,
+        )
+
+        # Verify scores are normalized to 0-100
+        output_data = json.loads(span.attributes["output"])
+        assert output_data["scores"]["eval1"] == 75.0
+        assert output_data["scores"]["eval2"] == 92.0
+
+    @pytest.mark.asyncio
+    async def test_configure_evaluation_span(self):
+        """Test configuring evaluation span with scores dictionary."""
+        span = MockSpan()
+
+        # Mock evaluation run results
+        mock_result1 = MagicMock()
+        mock_result1.evaluator_name = "TrajectoryEvaluator"
+        mock_result1.result.score = 85.0
+
+        mock_result2 = MagicMock()
+        mock_result2.evaluator_name = "JsonSimilarityEvaluator"
+        mock_result2.result.score = 92.5
+
+        mock_evaluation_run_results = MagicMock()
+        mock_evaluation_run_results.evaluation_run_results = [
+            mock_result1,
+            mock_result2,
+        ]
+
+        input_data = {"a": 1, "b": 2, "operator": "+"}
+
+        await configure_evaluation_span(
+            span=span,  # type: ignore[arg-type]
+            evaluation_run_results=mock_evaluation_run_results,
+            execution_id="eval-123",
+            input_data=input_data,
+            agent_execution_output=None,
+        )
+
+        # Verify scores dictionary
+        output_data = json.loads(span.attributes["output"])
+        assert "scores" in output_data
+        assert output_data["scores"]["TrajectoryEvaluator"] == 85.0
+        assert output_data["scores"]["JsonSimilarityEvaluator"] == 92.5
+
+        # Verify input data
+        input_attr = json.loads(span.attributes["input"])
+        assert input_attr == {"a": 1, "b": 2, "operator": "+"}
+
+        # Verify metadata
+        assert span.attributes["agentId"] == "eval-123"
+        assert span.attributes["agentName"] == "N/A"
+
+        # Verify status (no error)
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.OK
+
+    @pytest.mark.asyncio
+    async def test_configure_evaluation_span_with_error(self):
+        """Test configuring evaluation span when agent execution has error."""
+        span = MockSpan()
+
+        # Mock evaluation run results (empty since agent failed)
+        mock_evaluation_run_results = MagicMock()
+        mock_evaluation_run_results.evaluation_run_results = []
+
+        # Mock agent execution output with error
+        mock_agent_output = MagicMock()
+        mock_agent_output.result.error = "Agent execution failed"
+
+        await configure_evaluation_span(
+            span=span,  # type: ignore[arg-type]
+            evaluation_run_results=mock_evaluation_run_results,
+            execution_id="eval-error",
+            input_data=None,
+            agent_execution_output=mock_agent_output,
+        )
+
+        # Verify empty scores dictionary
+        output_data = json.loads(span.attributes["output"])
+        assert output_data["scores"] == {}
+
+        # Verify error status
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.ERROR
+        assert span._status.description is not None
+        assert "Agent execution failed" in span._status.description
+
+    @pytest.mark.asyncio
+    async def test_configure_evaluation_span_without_agent_output(self):
+        """Test configuring evaluation span without agent execution output."""
+        span = MockSpan()
+
+        mock_result = MagicMock()
+        mock_result.evaluator_name = "TrajectoryEvaluator"
+        mock_result.result.score = 85.0
+
+        mock_evaluation_run_results = MagicMock()
+        mock_evaluation_run_results.evaluation_run_results = [mock_result]
+
+        await configure_evaluation_span(
+            span=span,  # type: ignore[arg-type]
+            evaluation_run_results=mock_evaluation_run_results,
+            execution_id="eval-no-output",
+            agent_execution_output=None,
+        )
+
+        # Verify it doesn't crash and sets OK status
+        assert span._status is not None
+        assert span._status.status_code == StatusCode.OK
+
+        # Verify scores are set
+        output_data = json.loads(span.attributes["output"])
+        assert output_data["scores"]["TrajectoryEvaluator"] == 85.0
diff --git a/packages/uipath/tests/cli/eval/test_eval_telemetry.py b/packages/uipath/tests/cli/eval/test_eval_telemetry.py
new file mode 100644
index 000000000..49a71bc2f
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_telemetry.py
@@ -0,0 +1,563 @@
+"""Tests for EvalTelemetrySubscriber functionality."""
+
+import os
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from uipath._cli._evals._telemetry import (
+    EVAL_RUN_COMPLETED,
+    EVAL_RUN_FAILED,
+    EVAL_RUN_STARTED,
+    EVAL_SET_RUN_COMPLETED,
+    EVAL_SET_RUN_FAILED,
+    EVAL_SET_RUN_STARTED,
+    EvalTelemetrySubscriber,
+)
+from uipath.core.events import EventBus
+from uipath.eval.models import EvalItemResult, NumericEvaluationResult
+from uipath.eval.models.evaluation_set import EvaluationItem
+from uipath.eval.runtime.events import (
+    EvalItemExceptionDetails,
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+)
+from uipath.platform.common.constants import ENV_UIPATH_AGENT_ID
+
+
+class TestEventNameConstants:
+    """Test telemetry event name constants."""
+
+    def test_eval_set_run_event_names(self):
+        """Test eval set run event name constants."""
+        assert EVAL_SET_RUN_STARTED == "EvalSetRun.Start"
+        assert EVAL_SET_RUN_COMPLETED == "EvalSetRun.End"
+        assert EVAL_SET_RUN_FAILED == "EvalSetRun.Failed"
+
+    def test_eval_run_event_names(self):
+        """Test eval run event name constants."""
+        assert EVAL_RUN_STARTED == "EvalRun.Start"
+        assert EVAL_RUN_COMPLETED == "EvalRun.End"
+        assert EVAL_RUN_FAILED == "EvalRun.Failed"
+
+
+class TestEvalTelemetrySubscriberInit:
+    """Test EvalTelemetrySubscriber initialization."""
+
+    def test_init_creates_empty_tracking_dicts(self):
+        """Test that initialization creates empty tracking dictionaries."""
+        subscriber = EvalTelemetrySubscriber()
+
+        assert subscriber._eval_set_start_times == {}
+        assert subscriber._eval_run_start_times == {}
+        assert subscriber._eval_set_info == {}
+        assert subscriber._eval_run_info == {}
+
+
+class TestEvalTelemetrySubscriberSubscription:
+    """Test subscription to event bus."""
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.is_telemetry_enabled", return_value=True)
+    async def test_subscribe_when_telemetry_enabled(self, mock_is_enabled):
+        """Test that subscriber registers handlers when telemetry is enabled."""
+        subscriber = EvalTelemetrySubscriber()
+        event_bus = EventBus()
+
+        await subscriber.subscribe_to_eval_runtime_events(event_bus)
+
+        # Verify handlers are registered (event bus should have subscribers)
+        assert len(event_bus._subscribers) == 4
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.is_telemetry_enabled", return_value=False)
+    async def test_subscribe_skipped_when_telemetry_disabled(self, mock_is_enabled):
+        """Test that subscription is skipped when telemetry is disabled."""
+        subscriber = EvalTelemetrySubscriber()
+        event_bus = EventBus()
+
+        await subscriber.subscribe_to_eval_runtime_events(event_bus)
+
+        # Verify no handlers are registered
+        assert len(event_bus._subscribers) == 0
+
+
+class TestEvalSetRunCreated:
+    """Test eval set run created event handling."""
+
+    def _create_eval_set_run_created_event(
+        self,
+        execution_id: str = "exec-123",
+        eval_set_id: str = "eval-set-1",
+        eval_set_run_id: str | None = "run-456",
+        entrypoint: str = "agent.py",
+        no_of_evals: int = 5,
+        evaluators: list[Any] | None = None,
+    ) -> EvalSetRunCreatedEvent:
+        """Helper to create EvalSetRunCreatedEvent."""
+        return EvalSetRunCreatedEvent(
+            execution_id=execution_id,
+            eval_set_id=eval_set_id,
+            eval_set_run_id=eval_set_run_id,
+            entrypoint=entrypoint,
+            no_of_evals=no_of_evals,
+            evaluators=evaluators or [],
+        )
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_created_tracks_event(self, mock_track_event):
+        """Test that eval set run created event is tracked."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_set_run_created_event()
+
+        await subscriber._on_eval_set_run_created(event)
+
+        mock_track_event.assert_called_once()
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_SET_RUN_STARTED
+        properties = call_args[0][1]
+        assert properties["EvalSetId"] == "eval-set-1"
+        assert properties["Entrypoint"] == "agent.py"
+        assert properties["EvalCount"] == 5
+        assert properties["EvaluatorCount"] == 0
+        assert properties["EvalSetRunId"] == "run-456"
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_created_stores_start_time(self, mock_track_event):
+        """Test that eval set run start time is stored."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_set_run_created_event(execution_id="exec-789")
+
+        await subscriber._on_eval_set_run_created(event)
+
+        assert "exec-789" in subscriber._eval_set_start_times
+        assert "exec-789" in subscriber._eval_set_info
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_created_without_run_id(self, mock_track_event):
+        """Test event tracking when eval_set_run_id is None falls back to execution_id."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_set_run_created_event(eval_set_run_id=None)
+
+        await subscriber._on_eval_set_run_created(event)
+
+        call_args = mock_track_event.call_args
+        properties = call_args[0][1]
+        # When eval_set_run_id is None, it falls back to execution_id
+        assert properties["EvalSetRunId"] == "exec-123"  # Falls back to execution_id
+
+
+class TestEvalRunCreated:
+    """Test eval run created event handling."""
+
+    def _create_eval_run_created_event(
+        self,
+        execution_id: str = "exec-123",
+        eval_item_id: str = "item-1",
+        eval_item_name: str = "Test Eval",
+    ) -> EvalRunCreatedEvent:
+        """Helper to create EvalRunCreatedEvent."""
+        eval_item = EvaluationItem(
+            id=eval_item_id,
+            name=eval_item_name,
+            inputs={},
+            expected_agent_behavior="",
+            evaluation_criterias={},
+        )
+        return EvalRunCreatedEvent(
+            execution_id=execution_id,
+            eval_item=eval_item,
+        )
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_created_tracks_event(self, mock_track_event):
+        """Test that eval run created event is tracked."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_run_created_event()
+
+        await subscriber._on_eval_run_created(event)
+
+        mock_track_event.assert_called_once()
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_RUN_STARTED
+        properties = call_args[0][1]
+        assert properties["EvalId"] == "item-1"
+        assert properties["EvalName"] == "Test Eval"
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_created_stores_start_time(self, mock_track_event):
+        """Test that eval run start time is stored."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_run_created_event(execution_id="exec-456")
+
+        await subscriber._on_eval_run_created(event)
+
+        assert "exec-456" in subscriber._eval_run_start_times
+        assert "exec-456" in subscriber._eval_run_info
+
+
+class TestEvalRunUpdated:
+    """Test eval run updated event handling."""
+
+    def _create_eval_run_updated_event(
+        self,
+        execution_id: str = "exec-123",
+        eval_item_id: str = "item-1",
+        eval_item_name: str = "Test Eval",
+        success: bool = True,
+        agent_execution_time: float = 1.5,
+        eval_results: list[Any] | None = None,
+        exception_details: EvalItemExceptionDetails | None = None,
+    ) -> EvalRunUpdatedEvent:
+        """Helper to create EvalRunUpdatedEvent."""
+        eval_item = EvaluationItem(
+            id=eval_item_id,
+            name=eval_item_name,
+            inputs={},
+            expected_agent_behavior="",
+            evaluation_criterias={},
+        )
+        if eval_results is None:
+            eval_results = []
+        return EvalRunUpdatedEvent(
+            execution_id=execution_id,
+            eval_item=eval_item,
+            eval_results=eval_results,
+            success=success,
+            agent_output={},
+            agent_execution_time=agent_execution_time,
+            spans=[],
+            logs=[],
+            exception_details=exception_details,
+        )
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_updated_success(self, mock_track_event):
+        """Test that successful eval run completion is tracked."""
+        subscriber = EvalTelemetrySubscriber()
+        subscriber._eval_run_start_times["exec-123"] = 1000.0
+        subscriber._eval_run_info["exec-123"] = {
+            "eval_item_id": "item-1",
+            "eval_item_name": "Test Eval",
+        }
+        event = self._create_eval_run_updated_event(success=True)
+
+        with patch("time.time", return_value=1002.0):
+            await subscriber._on_eval_run_updated(event)
+
+        mock_track_event.assert_called_once()
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_RUN_COMPLETED
+        properties = call_args[0][1]
+        assert properties["Success"] is True
+        assert properties["DurationMs"] == 2000  # 2 seconds
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_updated_failure(self, mock_track_event):
+        """Test that failed eval run is tracked with EVAL_RUN_FAILED."""
+        subscriber = EvalTelemetrySubscriber()
+        exception_details = EvalItemExceptionDetails(
+            exception=ValueError("Test error"),
+            runtime_exception=True,
+        )
+        event = self._create_eval_run_updated_event(
+            success=False,
+            exception_details=exception_details,
+        )
+
+        await subscriber._on_eval_run_updated(event)
+
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_RUN_FAILED
+        properties = call_args[0][1]
+        assert properties["Success"] is False
+        assert properties["ErrorType"] == "ValueError"
+        assert "Test error" in properties["ErrorMessage"]
+        assert properties["IsRuntimeException"] is True
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_updated_with_scores(self, mock_track_event):
+        """Test that average score is calculated and tracked."""
+        subscriber = EvalTelemetrySubscriber()
+        eval_results = [
+            EvalItemResult(
+                evaluator_id="eval-1",
+                result=NumericEvaluationResult(score=0.8, details="Good"),
+            ),
+            EvalItemResult(
+                evaluator_id="eval-2",
+                result=NumericEvaluationResult(score=0.6, details="OK"),
+            ),
+        ]
+        event = self._create_eval_run_updated_event(eval_results=eval_results)
+
+        await subscriber._on_eval_run_updated(event)
+
+        properties = mock_track_event.call_args[0][1]
+        assert properties["AverageScore"] == 0.7  # (0.8 + 0.6) / 2
+        assert properties["EvaluatorCount"] == 2
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_run_updated_agent_execution_time_converted_to_ms(
+        self, mock_track_event
+    ):
+        """Test that agent execution time is converted to milliseconds."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_run_updated_event(agent_execution_time=2.5)
+
+        await subscriber._on_eval_run_updated(event)
+
+        properties = mock_track_event.call_args[0][1]
+        assert properties["AgentExecutionTimeMs"] == 2500  # 2.5 seconds = 2500 ms
+
+
+class TestEvalSetRunUpdated:
+    """Test eval set run updated event handling."""
+
+    def _create_eval_set_run_updated_event(
+        self,
+        execution_id: str = "exec-123",
+        evaluator_scores: dict[str, Any] | None = None,
+        success: bool = True,
+    ) -> EvalSetRunUpdatedEvent:
+        """Helper to create EvalSetRunUpdatedEvent."""
+        return EvalSetRunUpdatedEvent(
+            execution_id=execution_id,
+            evaluator_scores=evaluator_scores or {},
+            success=success,
+        )
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_updated_success(self, mock_track_event):
+        """Test that successful eval set completion is tracked."""
+        subscriber = EvalTelemetrySubscriber()
+        subscriber._eval_set_start_times["exec-123"] = 1000.0
+        subscriber._eval_set_info["exec-123"] = {
+            "eval_set_id": "set-1",
+            "eval_set_run_id": "run-1",
+            "entrypoint": "agent.py",
+            "no_of_evals": 3,
+        }
+        event = self._create_eval_set_run_updated_event(
+            evaluator_scores={"eval-1": 0.9, "eval-2": 0.7},
+            success=True,
+        )
+
+        with patch("time.time", return_value=1005.0):
+            await subscriber._on_eval_set_run_updated(event)
+
+        mock_track_event.assert_called_once()
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_SET_RUN_COMPLETED
+        properties = call_args[0][1]
+        assert properties["Success"] is True
+        assert properties["DurationMs"] == 5000
+        assert properties["AverageScore"] == 0.8  # (0.9 + 0.7) / 2
+        assert properties["EvalSetId"] == "set-1"
+        assert properties["EvalSetRunId"] == "run-1"
+        assert properties["Entrypoint"] == "agent.py"
+        assert properties["EvalCount"] == 3
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_updated_failure(self, mock_track_event):
+        """Test that failed eval set is tracked with EVAL_SET_RUN_FAILED."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_set_run_updated_event(success=False)
+
+        await subscriber._on_eval_set_run_updated(event)
+
+        call_args = mock_track_event.call_args
+        assert call_args[0][0] == EVAL_SET_RUN_FAILED
+        properties = call_args[0][1]
+        assert properties["Success"] is False
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_on_eval_set_run_updated_includes_evaluator_scores(
+        self, mock_track_event
+    ):
+        """Test that individual evaluator scores are included."""
+        subscriber = EvalTelemetrySubscriber()
+        event = self._create_eval_set_run_updated_event(
+            evaluator_scores={"accuracy": 0.95, "relevance-check": 0.85},
+        )
+
+        await subscriber._on_eval_set_run_updated(event)
+
+        properties = mock_track_event.call_args[0][1]
+        assert properties["Score_accuracy"] == 0.95
+        assert (
+            properties["Score_relevance_check"] == 0.85
+        )  # dash replaced with underscore
+
+
+class TestEnrichProperties:
+    """Test property enrichment with context information."""
+
+    def test_enrich_properties_adds_source(self):
+        """Test that source and application name are always added."""
+        subscriber = EvalTelemetrySubscriber()
+        properties: dict[str, Any] = {}
+
+        subscriber._enrich_properties(properties)
+
+        assert properties["Source"] == "uipath-python-cli"
+        assert properties["ApplicationName"] == "UiPath.Eval"
+
+    @patch("uipath._cli._evals._telemetry.get_claim_from_token")
+    def test_enrich_properties_adds_env_vars(self, mock_get_claim):
+        """Test that environment variables are added when present."""
+        mock_get_claim.return_value = "user-789"
+
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+
+        subscriber = EvalTelemetrySubscriber()
+        properties: dict[str, Any] = {}
+
+        with patch.dict(
+            os.environ,
+            {
+                "UIPATH_PROJECT_ID": "project-123",
+                ENV_UIPATH_AGENT_ID: "agent-123",
+                "UIPATH_ORGANIZATION_ID": "org-456",
+                "UIPATH_TENANT_ID": "tenant-abc",
+                "UIPATH_EVAL_RUN_SOURCE": "FirstSuccessfulRun",
+            },
+        ):
+            subscriber._enrich_properties(properties)
+
+        assert properties["ProjectId"] == "project-123"
+        assert properties["AgentId"] == "agent-123"
+        assert properties["CloudOrganizationId"] == "org-456"
+        assert properties["CloudUserId"] == "user-789"
+        assert properties["TenantId"] == "tenant-abc"
+        assert properties["RunSource"] == "FirstSuccessfulRun"
+
+    @patch("uipath._cli._evals._telemetry.get_claim_from_token")
+    def test_enrich_properties_skips_missing_env_vars(self, mock_get_claim):
+        """Test that missing environment variables are not added."""
+        mock_get_claim.side_effect = Exception("No token")
+
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+
+        subscriber = EvalTelemetrySubscriber()
+        properties: dict[str, Any] = {}
+
+        with patch.dict(os.environ, {}, clear=True):
+            # Remove env vars if they exist
+            for key in [
+                "UIPATH_PROJECT_ID",
+                ENV_UIPATH_AGENT_ID,
+                "UIPATH_ORGANIZATION_ID",
+                "UIPATH_TENANT_ID",
+                "UIPATH_EVAL_RUN_SOURCE",
+            ]:
+                os.environ.pop(key, None)
+
+            subscriber._enrich_properties(properties)
+
+        assert "ProjectId" not in properties
+        assert "AgentId" not in properties
+        assert "CloudOrganizationId" not in properties
+        assert "CloudUserId" not in properties
+        assert "TenantId" not in properties
+        assert "RunSource" not in properties
+
+
+class TestExceptionHandling:
+    """Test that telemetry never breaks the main application."""
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_eval_set_run_created_handles_exception(self, mock_track_event):
+        """Test that exceptions in event handling are caught."""
+        mock_track_event.side_effect = Exception("Track failed")
+        subscriber = EvalTelemetrySubscriber()
+        event = EvalSetRunCreatedEvent(
+            execution_id="exec-1",
+            eval_set_id="set-1",
+            entrypoint="agent.py",
+            no_of_evals=1,
+            evaluators=[],
+        )
+
+        # Should not raise exception
+        await subscriber._on_eval_set_run_created(event)
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_eval_run_created_handles_exception(self, mock_track_event):
+        """Test that exceptions in eval run created handling are caught."""
+        mock_track_event.side_effect = Exception("Track failed")
+        subscriber = EvalTelemetrySubscriber()
+        eval_item = EvaluationItem(
+            id="item-1",
+            name="Test",
+            inputs={},
+            expected_agent_behavior="",
+            evaluation_criterias={},
+        )
+        event = EvalRunCreatedEvent(execution_id="exec-1", eval_item=eval_item)
+
+        # Should not raise exception
+        await subscriber._on_eval_run_created(event)
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_eval_run_updated_handles_exception(self, mock_track_event):
+        """Test that exceptions in eval run updated handling are caught."""
+        mock_track_event.side_effect = Exception("Track failed")
+        subscriber = EvalTelemetrySubscriber()
+        eval_item = EvaluationItem(
+            id="item-1",
+            name="Test",
+            inputs={},
+            expected_agent_behavior="",
+            evaluation_criterias={},
+        )
+        event = EvalRunUpdatedEvent(
+            execution_id="exec-1",
+            eval_item=eval_item,
+            eval_results=[],
+            success=True,
+            agent_output={},
+            agent_execution_time=1.0,
+            spans=[],
+            logs=[],
+        )
+
+        # Should not raise exception
+        await subscriber._on_eval_run_updated(event)
+
+    @pytest.mark.asyncio
+    @patch("uipath._cli._evals._telemetry.track_event")
+    async def test_eval_set_run_updated_handles_exception(self, mock_track_event):
+        """Test that exceptions in eval set run updated handling are caught."""
+        mock_track_event.side_effect = Exception("Track failed")
+        subscriber = EvalTelemetrySubscriber()
+        event = EvalSetRunUpdatedEvent(
+            execution_id="exec-1",
+            evaluator_scores={},
+            success=True,
+        )
+
+        # Should not raise exception
+        await subscriber._on_eval_set_run_updated(event)
diff --git a/packages/uipath/tests/cli/eval/test_eval_tracing_integration.py b/packages/uipath/tests/cli/eval/test_eval_tracing_integration.py
new file mode 100644
index 000000000..b106d52ef
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_tracing_integration.py
@@ -0,0 +1,969 @@
+"""Integration tests for eval tracing flow.
+
+These tests verify that the eval runtime code correctly creates spans
+with the expected attributes by mocking the tracer.
+"""
+
+import uuid
+from contextlib import contextmanager
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.models import NumericEvaluationResult
+from uipath.eval.models.evaluation_set import EvaluationSet
+from uipath.eval.runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+
+class MockSpan:
+    """Mock span that captures attributes."""
+
+    def __init__(self, name: str, attributes: dict[str, Any] | None = None):
+        self.name = name
+        self.attributes = attributes or {}
+        self._status = None
+
+    def set_status(self, status: Any) -> None:
+        self._status = status
+
+    def set_attribute(self, key: str, value: Any) -> None:
+        self.attributes[key] = value
+
+    def __enter__(self) -> "MockSpan":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        pass
+
+
+class SpanCapturingTracer:
+    """A tracer that captures all created spans for verification."""
+
+    def __init__(self) -> None:
+        self.captured_spans: list[dict[str, Any]] = []
+
+    @contextmanager
+    def start_as_current_span(
+        self, name: str, attributes: dict[str, Any] | None = None
+    ):
+        """Capture span creation and yield a mock span."""
+        # Create MockSpan first so we can reference its attributes
+        mock_span = MockSpan(name, attributes)
+        # Store reference to mock_span.attributes so we capture any later set_attribute() calls
+        span_info = {"name": name, "attributes": mock_span.attributes}
+        self.captured_spans.append(span_info)
+        yield mock_span
+
+    def get_spans_by_type(self, span_type: str) -> list[dict[str, Any]]:
+        """Get all captured spans with the given span_type."""
+        return [
+            s
+            for s in self.captured_spans
+            if s["attributes"].get("span_type") == span_type
+        ]
+
+    def get_span_by_name(self, name: str) -> dict[str, Any] | None:
+        """Get the first span with the given name."""
+        for span in self.captured_spans:
+            if span["name"] == name:
+                return span
+        return None
+
+
+def create_eval_context(**kwargs: Any) -> UiPathEvalContext:
+    """Helper to create UiPathEvalContext with specific attribute values.
+
+    Sets sensible defaults for required fields if not provided.
+    """
+    context = UiPathEvalContext()
+
+    # Set required fields with defaults
+    if "execution_id" not in kwargs:
+        context.execution_id = str(uuid.uuid4())
+
+    if "runtime_schema" not in kwargs:
+        context.runtime_schema = UiPathRuntimeSchema(
+            filePath="test.py",
+            uniqueId="test",
+            type="workflow",
+            input={"type": "object", "properties": {}},
+            output={"type": "object", "properties": {}},
+        )
+
+    if "evaluation_set" not in kwargs:
+        context.evaluation_set = EvaluationSet(
+            id="test-eval-set",
+            name="Test Evaluation Set",
+            evaluations=[],
+        )
+
+    if "evaluators" not in kwargs:
+        context.evaluators = []
+
+    # Override with provided kwargs
+    for key, value in kwargs.items():
+        setattr(context, key, value)
+
+    return context
+
+
+class TestEvalSetRunSpanCreation:
+    """Tests that verify EvalSetRun span is created correctly by the runtime."""
+
+    @pytest.fixture
+    def mock_trace_manager(self) -> MagicMock:
+        """Create a mock trace manager with a capturing tracer."""
+        trace_manager = MagicMock()
+        self.capturing_tracer = SpanCapturingTracer()
+        trace_manager.tracer_provider.get_tracer.return_value = self.capturing_tracer
+        trace_manager.tracer_span_processors = []
+        return trace_manager
+
+    @pytest.fixture
+    def mock_factory(self) -> MagicMock:
+        """Create a mock runtime factory."""
+        factory = MagicMock()
+        mock_runtime = AsyncMock()
+        mock_runtime.get_schema = AsyncMock(return_value=MagicMock())
+        factory.new_runtime = AsyncMock(return_value=mock_runtime)
+        return factory
+
+    @pytest.fixture
+    def mock_event_bus(self) -> MagicMock:
+        """Create a mock event bus."""
+        event_bus = MagicMock()
+        event_bus.publish = AsyncMock()
+        return event_bus
+
+    @pytest.mark.asyncio
+    async def test_execute_creates_eval_set_run_span(
+        self,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that execute() creates the Evaluation Set Run span."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        # Mock initiate_evaluation to return empty results
+        mock_eval_set = MagicMock()
+        mock_eval_set.name = "Test Eval Set"
+        mock_eval_set.evaluations = []
+
+        with patch.object(
+            runtime,
+            "initiate_evaluation",
+            new=AsyncMock(return_value=(mock_eval_set, [], iter([]))),
+        ):
+            try:
+                await runtime.execute()
+            except Exception:
+                pass  # We just want to verify span creation
+
+        # Verify the span was created
+        eval_set_run_spans = self.capturing_tracer.get_spans_by_type("eval_set_run")
+        assert len(eval_set_run_spans) >= 1
+
+        span = eval_set_run_spans[0]
+        assert span["name"] == "Evaluation Set Run"
+        assert span["attributes"]["span_type"] == "eval_set_run"
+
+    @pytest.mark.asyncio
+    async def test_execute_includes_eval_set_run_id_when_provided(
+        self,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that eval_set_run_id is included in span when provided."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+            eval_set_run_id="custom-run-123",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        mock_eval_set = MagicMock()
+        mock_eval_set.name = "Test Eval Set"
+        mock_eval_set.evaluations = []
+
+        with patch.object(
+            runtime,
+            "initiate_evaluation",
+            new=AsyncMock(return_value=(mock_eval_set, [], iter([]))),
+        ):
+            try:
+                await runtime.execute()
+            except Exception:
+                pass
+
+        span = self.capturing_tracer.get_spans_by_type("eval_set_run")[0]
+        assert span["attributes"]["eval_set_run_id"] == "custom-run-123"
+
+
+class TestEvaluationSpanCreation:
+    """Tests that verify Evaluation span is created correctly."""
+
+    @pytest.fixture
+    def capturing_tracer(self) -> SpanCapturingTracer:
+        return SpanCapturingTracer()
+
+    @pytest.fixture
+    def mock_trace_manager(self, capturing_tracer: SpanCapturingTracer) -> MagicMock:
+        trace_manager = MagicMock()
+        trace_manager.tracer_provider.get_tracer.return_value = capturing_tracer
+        trace_manager.tracer_span_processors = []
+        return trace_manager
+
+    @pytest.fixture
+    def mock_factory(self) -> MagicMock:
+        factory = MagicMock()
+        mock_runtime = AsyncMock()
+        mock_runtime.get_schema = AsyncMock(return_value=MagicMock())
+        factory.new_runtime = AsyncMock(return_value=mock_runtime)
+        return factory
+
+    @pytest.fixture
+    def mock_event_bus(self) -> MagicMock:
+        event_bus = MagicMock()
+        event_bus.publish = AsyncMock()
+        return event_bus
+
+    @pytest.fixture
+    def mock_eval_item(self) -> Any:
+        """Create a real EvaluationItem instance for testing."""
+        from uipath.eval.models.evaluation_set import EvaluationItem
+
+        return EvaluationItem(
+            id="item-123",
+            name="Test Evaluation",
+            inputs={},
+            evaluation_criterias={},
+        )
+
+    @pytest.mark.asyncio
+    async def test_execute_eval_creates_evaluation_span(
+        self,
+        capturing_tracer: SpanCapturingTracer,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+        mock_eval_item: Any,
+    ) -> None:
+        """Test that _execute_eval creates an Evaluation span with correct attributes."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        # Mock execute_runtime to return a successful result
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {"result": 42}
+        mock_execution_output.result.status = "successful"
+        mock_execution_output.result.error = None
+        mock_execution_output.spans = []
+        mock_execution_output.logs = []
+
+        with patch.object(
+            runtime,
+            "execute_runtime",
+            new=AsyncMock(return_value=mock_execution_output),
+        ):
+            await runtime._execute_eval(mock_eval_item, [])
+
+        # Verify Evaluation span was created
+        evaluation_spans = capturing_tracer.get_spans_by_type("evaluation")
+        assert len(evaluation_spans) == 1
+
+        span = evaluation_spans[0]
+        assert span["name"] == "Evaluation"
+        assert span["attributes"]["span_type"] == "evaluation"
+        assert span["attributes"]["eval_item_id"] == "item-123"
+        assert span["attributes"]["eval_item_name"] == "Test Evaluation"
+        assert "execution.id" in span["attributes"]
+
+
+class TestEvaluatorSpanCreation:
+    """Tests that verify Evaluator span is created correctly."""
+
+    @pytest.fixture
+    def capturing_tracer(self) -> SpanCapturingTracer:
+        return SpanCapturingTracer()
+
+    @pytest.fixture
+    def mock_trace_manager(self, capturing_tracer: SpanCapturingTracer) -> MagicMock:
+        trace_manager = MagicMock()
+        trace_manager.tracer_provider.get_tracer.return_value = capturing_tracer
+        trace_manager.tracer_span_processors = []
+        return trace_manager
+
+    @pytest.fixture
+    def mock_factory(self) -> MagicMock:
+        factory = MagicMock()
+        return factory
+
+    @pytest.fixture
+    def mock_event_bus(self) -> MagicMock:
+        event_bus = MagicMock()
+        event_bus.publish = AsyncMock()
+        return event_bus
+
+    @pytest.fixture
+    def mock_evaluator(self) -> MagicMock:
+        evaluator = MagicMock(spec=BaseEvaluator)
+        evaluator.id = "accuracy-evaluator"
+        evaluator.name = "AccuracyEvaluator"
+        evaluator.validate_and_evaluate_criteria = AsyncMock(
+            return_value=NumericEvaluationResult(score=0.95, details="Good accuracy")
+        )
+        return evaluator
+
+    @pytest.fixture
+    def mock_eval_item(self) -> MagicMock:
+        eval_item = MagicMock()
+        eval_item.id = "eval-item-456"
+        eval_item.name = "Test Item"
+        eval_item.inputs = {"input": "test"}
+        eval_item.expected_agent_behavior = None
+        return eval_item
+
+    @pytest.fixture
+    def mock_execution_output(self) -> MagicMock:
+        output = MagicMock()
+        output.result.output = {"result": 42}
+        output.spans = []
+        return output
+
+    @pytest.mark.asyncio
+    async def test_run_evaluator_creates_evaluator_span(
+        self,
+        capturing_tracer: SpanCapturingTracer,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+        mock_evaluator: MagicMock,
+        mock_eval_item: MagicMock,
+        mock_execution_output: MagicMock,
+    ) -> None:
+        """Test that run_evaluator creates an Evaluator span with correct attributes."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        await runtime.run_evaluator(
+            evaluator=mock_evaluator,
+            execution_output=mock_execution_output,
+            eval_item=mock_eval_item,
+            evaluation_criteria=None,
+        )
+
+        # Verify Evaluator span was created
+        evaluator_spans = capturing_tracer.get_spans_by_type("evaluator")
+        assert len(evaluator_spans) == 1
+
+        span = evaluator_spans[0]
+        assert span["name"] == "Evaluator: AccuracyEvaluator"
+        assert span["attributes"]["span_type"] == "evaluator"
+        assert span["attributes"]["evaluator_id"] == "accuracy-evaluator"
+        assert span["attributes"]["evaluator_name"] == "AccuracyEvaluator"
+        assert span["attributes"]["eval_item_id"] == "eval-item-456"
+
+    @pytest.mark.asyncio
+    async def test_multiple_evaluators_create_multiple_spans(
+        self,
+        capturing_tracer: SpanCapturingTracer,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+        mock_eval_item: MagicMock,
+        mock_execution_output: MagicMock,
+    ) -> None:
+        """Test that running multiple evaluators creates multiple spans."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        evaluator_names = ["Accuracy", "Relevance", "Fluency"]
+        for name in evaluator_names:
+            evaluator = MagicMock(spec=BaseEvaluator)
+            evaluator.id = f"{name.lower()}-id"
+            evaluator.name = name
+            evaluator.validate_and_evaluate_criteria = AsyncMock(
+                return_value=NumericEvaluationResult(score=0.9)
+            )
+
+            await runtime.run_evaluator(
+                evaluator=evaluator,
+                execution_output=mock_execution_output,
+                eval_item=mock_eval_item,
+                evaluation_criteria=None,
+            )
+
+        evaluator_spans = capturing_tracer.get_spans_by_type("evaluator")
+        assert len(evaluator_spans) == 3
+
+        span_names = [s["name"] for s in evaluator_spans]
+        assert "Evaluator: Accuracy" in span_names
+        assert "Evaluator: Relevance" in span_names
+        assert "Evaluator: Fluency" in span_names
+
+
+class TestSpanAttributeValues:
+    """Tests for verifying specific span attribute values."""
+
+    @pytest.fixture
+    def capturing_tracer(self) -> SpanCapturingTracer:
+        return SpanCapturingTracer()
+
+    @pytest.fixture
+    def mock_trace_manager(self, capturing_tracer: SpanCapturingTracer) -> MagicMock:
+        trace_manager = MagicMock()
+        trace_manager.tracer_provider.get_tracer.return_value = capturing_tracer
+        trace_manager.tracer_span_processors = []
+        return trace_manager
+
+    @pytest.fixture
+    def mock_factory(self) -> MagicMock:
+        factory = MagicMock()
+        return factory
+
+    @pytest.fixture
+    def mock_event_bus(self) -> MagicMock:
+        event_bus = MagicMock()
+        event_bus.publish = AsyncMock()
+        return event_bus
+
+    @pytest.mark.asyncio
+    async def test_evaluation_span_has_unique_execution_id(
+        self,
+        capturing_tracer: SpanCapturingTracer,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that each Evaluation span gets a unique execution.id."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {}
+        mock_execution_output.result.status = "successful"
+        mock_execution_output.result.error = None
+        mock_execution_output.spans = []
+        mock_execution_output.logs = []
+
+        from uipath.eval.models.evaluation_set import EvaluationItem
+
+        for i in range(3):
+            eval_item = EvaluationItem(
+                id=f"item-{i}",
+                name=f"Test {i}",
+                inputs={},
+                evaluation_criterias={},
+            )
+
+            with patch.object(
+                runtime,
+                "execute_runtime",
+                new=AsyncMock(return_value=mock_execution_output),
+            ):
+                await runtime._execute_eval(eval_item, [])
+
+        # Get execution IDs from spans
+        evaluation_spans = capturing_tracer.get_spans_by_type("evaluation")
+        execution_ids = [s["attributes"]["execution.id"] for s in evaluation_spans]
+
+        # All execution IDs should be unique
+        assert len(set(execution_ids)) == 3
+
+    @pytest.mark.asyncio
+    async def test_evaluator_span_inherits_eval_item_id(
+        self,
+        capturing_tracer: SpanCapturingTracer,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that Evaluator span contains the same eval_item_id as its parent Evaluation."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        eval_item = MagicMock()
+        eval_item.id = "shared-item-id-789"
+        eval_item.name = "Test"
+        eval_item.inputs = {}
+        eval_item.expected_agent_behavior = None
+
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {}
+        mock_execution_output.spans = []
+
+        evaluator = MagicMock(spec=BaseEvaluator)
+        evaluator.id = "test-evaluator"
+        evaluator.name = "TestEvaluator"
+        evaluator.validate_and_evaluate_criteria = AsyncMock(
+            return_value=NumericEvaluationResult(score=1.0)
+        )
+
+        await runtime.run_evaluator(
+            evaluator=evaluator,
+            execution_output=mock_execution_output,
+            eval_item=eval_item,
+            evaluation_criteria=None,
+        )
+
+        evaluator_span = capturing_tracer.get_spans_by_type("evaluator")[0]
+        assert evaluator_span["attributes"]["eval_item_id"] == "shared-item-id-789"
+
+
+class TestEvaluationOutputSpanCreation:
+    """Tests that verify Evaluation output span is created correctly by the progress reporter."""
+
+    def test_evaluation_output_span_attributes(self) -> None:
+        """Test that Evaluation output span has correct attributes."""
+        # The Evaluation output span should have these attributes:
+        # - openinference.span.kind: "CHAIN"
+        # - span.type: "evalOutput"
+        # - value: the score
+        # - evaluatorId: the evaluator ID
+        # - justification: extracted from details (optional)
+
+        expected_attributes = {
+            "openinference.span.kind": "CHAIN",
+            "span.type": "evalOutput",
+            "value": 100,
+            "evaluatorId": "test-evaluator-id",
+            "justification": "Test justification",
+        }
+
+        assert expected_attributes["openinference.span.kind"] == "CHAIN"
+        assert expected_attributes["span.type"] == "evalOutput"
+        assert expected_attributes["value"] == 100
+        assert expected_attributes["evaluatorId"] == "test-evaluator-id"
+        assert expected_attributes["justification"] == "Test justification"
+
+    def test_evaluation_output_span_is_child_of_evaluator(self) -> None:
+        """Test that Evaluation output span is created as child of evaluator span."""
+        # In the progress reporter, the Evaluation output span is created
+        # with the evaluator span as its parent context
+        parent_span_type = "evaluator"
+        child_span_type = "evalOutput"
+
+        # These represent the expected hierarchy
+        assert parent_span_type == "evaluator"
+        assert child_span_type == "evalOutput"
+
+    def test_evaluation_output_span_name(self) -> None:
+        """Test that Evaluation output span has the correct name."""
+        expected_name = "Evaluation output"
+        assert expected_name == "Evaluation output"
+
+    def test_evaluation_output_extracts_justification_from_pydantic_model(self) -> None:
+        """Test that justification is correctly extracted from Pydantic model details."""
+        from pydantic import BaseModel
+
+        class EvalDetails(BaseModel):
+            justification: str
+            other_field: str
+
+        details = EvalDetails(
+            justification="The semantic similarity is perfect.",
+            other_field="other value",
+        )
+
+        # Simulate the extraction logic from progress reporter
+        details_dict = details.model_dump()
+        justification = details_dict.get("justification", str(details_dict))
+
+        assert justification == "The semantic similarity is perfect."
+
+    def test_evaluation_output_falls_back_to_json_when_no_justification(self) -> None:
+        """Test fallback to JSON dump when details has no justification field."""
+        import json
+
+        from pydantic import BaseModel
+
+        class EvalDetailsNoJustification(BaseModel):
+            accuracy: float
+            precision: float
+
+        details = EvalDetailsNoJustification(accuracy=0.95, precision=0.92)
+
+        # Simulate the extraction logic from progress reporter
+        details_dict = details.model_dump()
+        justification = details_dict.get("justification", json.dumps(details_dict))
+
+        assert "accuracy" in justification
+        assert "0.95" in justification
+
+    def test_evaluation_output_handles_string_details(self) -> None:
+        """Test that string details are used directly as justification."""
+        details = "Good accuracy on all test cases"
+
+        # String details should be used directly
+        justification = str(details)
+
+        assert justification == "Good accuracy on all test cases"
+
+    def test_evaluation_output_span_has_correct_status_on_success(self) -> None:
+        """Test that Evaluation output span has OK status on success."""
+        from opentelemetry.trace import StatusCode
+
+        # On success, status should be OK
+        expected_status = StatusCode.OK
+        assert expected_status == StatusCode.OK
+
+    def test_evaluation_output_span_has_correct_status_on_error(self) -> None:
+        """Test that Evaluation output span has ERROR status on evaluation failure."""
+        from opentelemetry.trace import StatusCode
+
+        from uipath.eval.models import ScoreType
+
+        # On error, status should be ERROR
+        score_type = ScoreType.ERROR
+        expected_status = StatusCode.ERROR
+
+        assert score_type == ScoreType.ERROR
+        assert expected_status == StatusCode.ERROR
+
+
+class TestSpanOutputAttributes:
+    """Integration tests that verify output attributes are set correctly on spans."""
+
+    @pytest.fixture
+    def mock_trace_manager(self) -> MagicMock:
+        """Create a mock trace manager with a capturing tracer."""
+        trace_manager = MagicMock()
+        self.capturing_tracer = SpanCapturingTracer()
+        trace_manager.tracer_provider.get_tracer.return_value = self.capturing_tracer
+        trace_manager.tracer_span_processors = []
+        return trace_manager
+
+    @pytest.fixture
+    def mock_factory(self) -> MagicMock:
+        """Create a mock runtime factory."""
+        factory = MagicMock()
+        mock_runtime = AsyncMock()
+        mock_runtime.get_schema = AsyncMock(return_value=MagicMock())
+        factory.new_runtime = AsyncMock(return_value=mock_runtime)
+        return factory
+
+    @pytest.fixture
+    def mock_event_bus(self) -> MagicMock:
+        """Create a mock event bus."""
+        event_bus = MagicMock()
+        event_bus.publish = AsyncMock()
+        return event_bus
+
+    @pytest.mark.asyncio
+    async def test_evaluation_set_run_span_has_output_attribute(
+        self,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that Evaluation Set Run span has output attribute with score."""
+        from uipath.eval.models.evaluation_set import EvaluationItem
+
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        # Mock the runtime and evaluator
+        mock_runtime = AsyncMock()
+        mock_schema = MagicMock()
+        mock_schema.input_schema = {"type": "object"}
+        mock_schema.output_schema = {"type": "object"}
+        mock_runtime.get_schema = AsyncMock(return_value=mock_schema)
+        mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+        # Mock execute_runtime to return success
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {"result": "success"}
+        mock_execution_output.result.status = "successful"
+        mock_execution_output.result.error = None
+        mock_execution_output.spans = []
+        mock_execution_output.logs = []
+
+        # Create simple evaluator that returns 0.85
+        evaluator = MagicMock()
+        evaluator.id = "test-evaluator"
+        evaluator.name = "Test Evaluator"
+
+        with patch.object(
+            runtime,
+            "execute_runtime",
+            new=AsyncMock(return_value=mock_execution_output),
+        ):
+            with patch.object(
+                runtime,
+                "run_evaluator",
+                new=AsyncMock(return_value=NumericEvaluationResult(score=0.85)),
+            ):
+                eval_item = EvaluationItem(
+                    id="item-1",
+                    name="Test",
+                    inputs={"x": 1},
+                    evaluation_criterias={"test-evaluator": {}},
+                )
+
+                # Execute evaluation
+                await runtime._execute_eval(eval_item, [evaluator])
+
+        # Check that Evaluation span has output attribute
+        eval_spans = self.capturing_tracer.get_spans_by_type("evaluation")
+        assert len(eval_spans) > 0
+
+        eval_span = eval_spans[0]
+        assert "output" in eval_span["attributes"]
+
+        # Parse and verify output JSON
+        import json
+
+        output_data = json.loads(eval_span["attributes"]["output"])
+        assert "scores" in output_data
+        assert isinstance(output_data["scores"], dict)
+        # Verify that scores are in 0-100 range
+        for _evaluator_id, score in output_data["scores"].items():
+            assert isinstance(score, (int, float))
+            assert 0 <= score <= 100
+
+    @pytest.mark.asyncio
+    async def test_evaluation_span_has_metadata_attributes(
+        self,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that Evaluation span has metadata attributes (agentId, agentName, schemas)."""
+        from uipath.eval.models.evaluation_set import EvaluationItem
+
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        # Mock the runtime
+        mock_runtime = AsyncMock()
+        mock_schema = MagicMock()
+        mock_schema.input = {
+            "type": "object",
+            "properties": {"x": {"type": "number"}},
+        }
+        mock_schema.output = {"type": "string"}
+        mock_runtime.get_schema = AsyncMock(return_value=mock_schema)
+        mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+        # Mock execute_runtime
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {"result": "success"}
+        mock_execution_output.result.status = "successful"
+        mock_execution_output.result.error = None
+        mock_execution_output.spans = []
+        mock_execution_output.logs = []
+
+        evaluator = MagicMock()
+        evaluator.id = "test-evaluator"
+        evaluator.name = "Test Evaluator"
+
+        with patch.object(
+            runtime,
+            "execute_runtime",
+            new=AsyncMock(return_value=mock_execution_output),
+        ):
+            with patch.object(
+                runtime,
+                "run_evaluator",
+                new=AsyncMock(return_value=NumericEvaluationResult(score=0.90)),
+            ):
+                eval_item = EvaluationItem(
+                    id="item-metadata",
+                    name="Test Metadata",
+                    inputs={"x": 42},
+                    evaluation_criterias={"test-evaluator": {}},
+                )
+
+                await runtime._execute_eval(eval_item, [evaluator])
+
+        # Check metadata attributes on Evaluation span
+        eval_spans = self.capturing_tracer.get_spans_by_type("evaluation")
+        assert len(eval_spans) > 0
+
+        eval_span = eval_spans[0]
+
+        # Check agentId
+        assert "agentId" in eval_span["attributes"]
+
+        # Check agentName
+        assert "agentName" in eval_span["attributes"]
+        assert eval_span["attributes"]["agentName"] == "N/A"
+
+        # Schemas are not included in Evaluation span (only in Evaluation Set Run span)
+        assert "inputSchema" not in eval_span["attributes"]
+        assert "outputSchema" not in eval_span["attributes"]
+
+    @pytest.mark.asyncio
+    async def test_evaluation_output_span_has_output_with_type_and_value(
+        self,
+        mock_trace_manager: MagicMock,
+        mock_factory: MagicMock,
+        mock_event_bus: MagicMock,
+    ) -> None:
+        """Test that Evaluation output span has output with type, value, and justification."""
+        context = create_eval_context(
+            eval_set="test.json",
+            entrypoint="main.py:main",
+        )
+
+        runtime = UiPathEvalRuntime(
+            context=context,
+            factory=mock_factory,
+            trace_manager=mock_trace_manager,
+            event_bus=mock_event_bus,
+        )
+
+        # Mock execution output
+        mock_execution_output = MagicMock()
+        mock_execution_output.result.output = {"answer": "42"}
+        mock_execution_output.spans = []
+        mock_execution_output.logs = []
+        mock_execution_output.execution_time = 1.5
+
+        # Create evaluator with details
+        evaluator = MagicMock()
+        evaluator.id = "similarity-evaluator"
+        evaluator.name = "Similarity Evaluator"
+
+        from pydantic import BaseModel
+
+        from uipath.eval.models import NumericEvaluationResult
+
+        class EvaluationDetails(BaseModel):
+            justification: str
+
+        eval_result = NumericEvaluationResult(
+            score=0.92,
+            details=EvaluationDetails(
+                justification="The outputs are semantically equivalent"
+            ),
+        )
+
+        with patch.object(
+            evaluator,
+            "validate_and_evaluate_criteria",
+            new=AsyncMock(return_value=eval_result),
+        ):
+            from uipath.eval.models.evaluation_set import EvaluationItem
+
+            eval_item = EvaluationItem(
+                id="item-with-justification",
+                name="Test Output Format",
+                inputs={"question": "What is the answer?"},
+                evaluation_criterias={},
+            )
+
+            await runtime.run_evaluator(
+                evaluator=evaluator,
+                execution_output=mock_execution_output,
+                eval_item=eval_item,
+                evaluation_criteria=None,
+            )
+
+        # Check Evaluation output span
+        eval_output_spans = [
+            span
+            for span in self.capturing_tracer.captured_spans
+            if span["attributes"].get("span.type") == "evalOutput"
+        ]
+
+        assert len(eval_output_spans) > 0
+        eval_output_span = eval_output_spans[0]
+
+        # Verify output attribute exists and has correct structure
+        assert "output" in eval_output_span["attributes"]
+
+        import json
+
+        output_data = json.loads(eval_output_span["attributes"]["output"])
+
+        # Check structure matches EvaluationOutputSpanOutput model
+        assert output_data["type"] == 1
+        assert "score" in output_data
+        assert output_data["score"] == 92.0  # 0.92 normalized to 0-100 range
+        assert "justification" in output_data
+        assert output_data["justification"] == "The outputs are semantically equivalent"
diff --git a/packages/uipath/tests/cli/eval/test_eval_util.py b/packages/uipath/tests/cli/eval/test_eval_util.py
new file mode 100644
index 000000000..6c7334c01
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_eval_util.py
@@ -0,0 +1,466 @@
+"""Tests for eval utility functions (input overrides)."""
+
+from typing import Any
+
+import pytest
+
+from uipath.eval.runtime._utils import apply_input_overrides, deep_merge
+
+
+@pytest.mark.asyncio
+async def test_input_override_simple_direct_field():
+    """Test input override with simple direct field override."""
+    # Set input overrides - per-evaluation format
+    overrides = {
+        "eval-1": {
+            "a": 10,
+            "operator": "*",
+        }
+    }
+
+    # Test inputs
+    inputs = {
+        "a": 5,
+        "b": 3,
+        "operator": "+",
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    assert result["a"] == 10  # Overridden
+    assert result["operator"] == "*"  # Overridden
+    assert result["b"] == 3  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_input_override_deep_merge():
+    """Test input override with deep merge for nested objects."""
+    overrides = {"eval-1": {"filePath": {"ID": "new-id-123", "NewField": "added"}}}
+
+    inputs = {
+        "filePath": {
+            "ID": "old-id",
+            "FullName": "test.pdf",
+            "MimeType": "application/pdf",
+        },
+        "other": "value",
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Deep merge: overridden fields updated, existing fields preserved
+    assert result["filePath"]["ID"] == "new-id-123"  # Overridden
+    assert result["filePath"]["NewField"] == "added"  # Added
+    assert result["filePath"]["FullName"] == "test.pdf"  # Preserved
+    assert result["filePath"]["MimeType"] == "application/pdf"  # Preserved
+    assert result["other"] == "value"  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_input_override_no_overrides():
+    """Test input override when no overrides are configured."""
+    inputs = {"file_id": "attachment-123", "data": {"nested": "value"}}
+
+    result = apply_input_overrides(inputs, {}, eval_id="eval-1")
+
+    # Should return the same inputs unchanged
+    assert result == inputs
+
+
+@pytest.mark.asyncio
+async def test_input_override_new_fields():
+    """Test input override adding new fields."""
+    overrides = {
+        "eval-1": {
+            "newField": "new-value",
+            "c": 7,
+        }
+    }
+
+    inputs = {"a": 5, "b": 3}
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # New fields should be added
+    assert result["a"] == 5  # Unchanged
+    assert result["b"] == 3  # Unchanged
+    assert result["newField"] == "new-value"  # Added
+    assert result["c"] == 7  # Added
+
+
+@pytest.mark.asyncio
+async def test_input_override_multimodal():
+    """Test input override with multimodal inputs (images, files)."""
+    # Override image attachment ID using per-evaluation format
+    overrides = {
+        "eval-1": {
+            "image": "job-attachment-xyz789",
+            "filePath": {"ID": "document-id-current"},
+        }
+    }
+
+    # Simulate a multimodal evaluation input with image and file references
+    inputs = {
+        "prompt": "Analyze this screenshot",
+        "image": "job-attachment-abc123",
+        "filePath": {
+            "ID": "document-id-legacy",
+            "FullName": "doc.pdf",
+            "MimeType": "application/pdf",
+        },
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Verify overrides
+    assert result["prompt"] == "Analyze this screenshot"  # Text unchanged
+    assert result["image"] == "job-attachment-xyz789"  # Overridden
+    assert result["filePath"]["ID"] == "document-id-current"  # Overridden
+    assert result["filePath"]["FullName"] == "doc.pdf"  # Preserved
+    assert result["filePath"]["MimeType"] == "application/pdf"  # Preserved
+
+
+@pytest.mark.asyncio
+async def test_input_override_calculator_example():
+    """Test input override with calculator-style inputs."""
+    # Override calculator inputs using per-evaluation format
+    overrides = {
+        "eval-1": {
+            "a": 10,
+            "operator": "*",
+        }
+    }
+
+    inputs = {"a": 5, "b": 3, "operator": "+"}
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Direct field override
+    assert result["a"] == 10  # Overridden
+    assert result["operator"] == "*"  # Overridden
+    assert result["b"] == 3  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_multiple_levels():
+    """Test deep merge with multiple levels of nesting."""
+    overrides = {
+        "eval-1": {
+            "config": {
+                "database": {
+                    "connection": {
+                        "host": "new-host",
+                        "timeout": 5000,
+                    }
+                }
+            }
+        }
+    }
+
+    inputs = {
+        "config": {
+            "database": {
+                "connection": {
+                    "host": "localhost",
+                    "port": 5432,
+                    "ssl": True,
+                },
+                "pool_size": 10,
+            },
+            "logging": {"level": "INFO"},
+        }
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Verify deep merge at multiple levels
+    assert (
+        result["config"]["database"]["connection"]["host"] == "new-host"
+    )  # Overridden
+    assert result["config"]["database"]["connection"]["timeout"] == 5000  # Added
+    assert result["config"]["database"]["connection"]["port"] == 5432  # Preserved
+    assert result["config"]["database"]["connection"]["ssl"] is True  # Preserved
+    assert result["config"]["database"]["pool_size"] == 10  # Preserved
+    assert result["config"]["logging"]["level"] == "INFO"  # Preserved
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_replace_dict_with_primitive():
+    """Test deep merge when replacing a dict value with a primitive."""
+    overrides = {
+        "eval-1": {
+            "config": "simple-string",  # Replace entire dict with string
+        }
+    }
+
+    inputs = {
+        "config": {
+            "database": "postgres",
+            "port": 5432,
+        },
+        "other": "value",
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Dict should be replaced with primitive
+    assert result["config"] == "simple-string"  # Completely replaced
+    assert result["other"] == "value"  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_replace_primitive_with_dict():
+    """Test deep merge when replacing a primitive value with a dict."""
+    overrides = {
+        "eval-1": {
+            "setting": {
+                "enabled": True,
+                "mode": "advanced",
+            }
+        }
+    }
+
+    inputs = {
+        "setting": "default",
+        "other": "value",
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Primitive should be replaced with dict
+    assert isinstance(result["setting"], dict)
+    assert result["setting"]["enabled"] is True
+    assert result["setting"]["mode"] == "advanced"
+    assert result["other"] == "value"  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_empty_dict():
+    """Test deep merge with empty dictionaries."""
+    overrides = {
+        "eval-1": {
+            "empty": {},
+            "populated": {"key": "value"},
+        }
+    }
+
+    inputs = {
+        "empty": {"existing": "data"},
+        "populated": {},
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Empty dict override should preserve existing fields
+    assert result["empty"]["existing"] == "data"
+    # Override with populated dict should add fields to empty base
+    assert result["populated"]["key"] == "value"
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_list_values():
+    """Test deep merge with list values (should replace, not merge)."""
+    overrides = {
+        "eval-1": {
+            "tags": ["new", "tags"],
+            "nested": {"items": [3, 4, 5]},
+        }
+    }
+
+    inputs = {
+        "tags": ["old", "values"],
+        "nested": {"items": [1, 2], "other": "value"},
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Lists should be replaced entirely, not merged
+    assert result["tags"] == ["new", "tags"]
+    assert result["nested"]["items"] == [3, 4, 5]
+    assert result["nested"]["other"] == "value"  # Other keys preserved
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_complex_nested_structure():
+    """Test deep merge with a complex nested structure."""
+    overrides = {
+        "eval-1": {
+            "api": {
+                "endpoints": {
+                    "auth": {
+                        "url": "https://new-auth.api.com",
+                        "timeout": 3000,
+                    }
+                }
+            }
+        }
+    }
+
+    inputs = {
+        "api": {
+            "version": "v2",
+            "endpoints": {
+                "auth": {
+                    "url": "https://old-auth.api.com",
+                    "method": "POST",
+                    "retries": 3,
+                },
+                "data": {
+                    "url": "https://data.api.com",
+                },
+            },
+            "headers": {"Authorization": "Bearer token"},
+        }
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Verify deep merge preserves structure
+    assert result["api"]["version"] == "v2"  # Top-level preserved
+    assert (
+        result["api"]["endpoints"]["auth"]["url"] == "https://new-auth.api.com"
+    )  # Overridden
+    assert result["api"]["endpoints"]["auth"]["timeout"] == 3000  # Added
+    assert result["api"]["endpoints"]["auth"]["method"] == "POST"  # Preserved
+    assert result["api"]["endpoints"]["auth"]["retries"] == 3  # Preserved
+    assert (
+        result["api"]["endpoints"]["data"]["url"] == "https://data.api.com"
+    )  # Sibling preserved
+    assert (
+        result["api"]["headers"]["Authorization"] == "Bearer token"
+    )  # Sibling preserved
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_none_values():
+    """Test deep merge with None values."""
+    overrides = {
+        "eval-1": {
+            "nullable": None,
+            "nested": {"field": None},
+        }
+    }
+
+    inputs = {
+        "nullable": "original-value",
+        "nested": {"field": "original", "other": "preserved"},
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # None values should override existing values
+    assert result["nullable"] is None
+    assert result["nested"]["field"] is None
+    assert result["nested"]["other"] == "preserved"
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_numeric_and_boolean_types():
+    """Test deep merge with various primitive types."""
+    overrides = {
+        "eval-1": {
+            "count": 100,
+            "ratio": 0.75,
+            "enabled": False,
+            "config": {
+                "max_retries": 5,
+                "timeout": 30.5,
+                "debug": True,
+            },
+        }
+    }
+
+    inputs = {
+        "count": 10,
+        "ratio": 0.5,
+        "enabled": True,
+        "config": {
+            "max_retries": 3,
+            "timeout": 10.0,
+            "debug": False,
+            "log_level": "INFO",
+        },
+    }
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-1")
+
+    # Verify all primitive types are handled correctly
+    assert result["count"] == 100
+    assert result["ratio"] == 0.75
+    assert result["enabled"] is False
+    assert result["config"]["max_retries"] == 5
+    assert result["config"]["timeout"] == 30.5
+    assert result["config"]["debug"] is True
+    assert result["config"]["log_level"] == "INFO"  # Preserved
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_does_not_mutate_original():
+    """Test that deep merge does not mutate the original inputs."""
+    overrides = {"eval-1": {"nested": {"field": "new-value"}}}
+
+    original_inputs: dict[str, Any] = {
+        "nested": {"field": "original", "other": "data"},
+        "top": "level",
+    }
+
+    # Create a deep copy to compare later
+    import copy
+
+    inputs_before = copy.deepcopy(original_inputs)
+
+    result = apply_input_overrides(original_inputs, overrides, eval_id="eval-1")
+
+    # Verify result has overrides
+    assert result["nested"]["field"] == "new-value"
+
+    # Verify original inputs are unchanged
+    assert original_inputs == inputs_before
+    assert original_inputs["nested"]["field"] == "original"
+
+
+@pytest.mark.asyncio
+async def test_deep_merge_function_directly():
+    """Test deep_merge function directly."""
+    base = {
+        "a": 1,
+        "b": {"c": 2, "d": 3},
+        "e": "unchanged",
+    }
+
+    override = {
+        "b": {"c": 10},  # Override nested value
+        "f": "new",  # Add new key
+    }
+
+    result = deep_merge(base, override)
+
+    assert result["a"] == 1  # Preserved
+    assert result["b"]["c"] == 10  # Overridden
+    assert result["b"]["d"] == 3  # Preserved
+    assert result["e"] == "unchanged"  # Preserved
+    assert result["f"] == "new"  # Added
+
+
+@pytest.mark.asyncio
+async def test_input_override_no_eval_id():
+    """Test input override when eval_id is not provided."""
+    overrides = {"eval-1": {"a": 10}}
+    inputs = {"a": 5, "b": 3}
+
+    result = apply_input_overrides(inputs, overrides, eval_id=None)
+
+    # Should return original inputs unchanged
+    assert result == inputs
+
+
+@pytest.mark.asyncio
+async def test_input_override_nonexistent_eval_id():
+    """Test input override when eval_id doesn't have overrides."""
+    overrides = {"eval-1": {"a": 10}}
+    inputs = {"a": 5, "b": 3}
+
+    result = apply_input_overrides(inputs, overrides, eval_id="eval-2")
+
+    # Should return original inputs unchanged
+    assert result == inputs
diff --git a/packages/uipath/tests/cli/eval/test_evaluate.py b/packages/uipath/tests/cli/eval/test_evaluate.py
new file mode 100644
index 000000000..39f516263
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_evaluate.py
@@ -0,0 +1,362 @@
+import uuid
+from pathlib import Path
+from typing import Any, AsyncGenerator
+
+from pydantic import BaseModel
+
+from uipath.core.events import EventBus
+from uipath.core.tracing import UiPathTraceManager
+from uipath.eval.helpers import EvalHelpers
+from uipath.eval.runtime import UiPathEvalContext, UiPathEvalRuntime, evaluate
+from uipath.eval.runtime._types import UiPathEvalOutput
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathRuntimeEvent,
+    UiPathRuntimeFactorySettings,
+    UiPathRuntimeProtocol,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+    UiPathRuntimeStorageProtocol,
+    UiPathStreamOptions,
+)
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+
+async def test_evaluate():
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    # Create a mock runtime and factory
+    async def identity(input: dict[str, Any]) -> dict[str, Any]:
+        return input
+
+    class TestRuntime:
+        def __init__(self, executor):
+            self.executor = executor
+
+        async def execute(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathExecuteOptions | None = None,
+        ) -> UiPathRuntimeResult:
+            result = await self.executor(input or {})
+            return UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def stream(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathStreamOptions | None = None,
+        ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+            result = await self.executor(input or {})
+            yield UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def get_schema(self) -> UiPathRuntimeSchema:
+            return UiPathRuntimeSchema(
+                filePath="test.py",
+                uniqueId="test",
+                type="workflow",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            )
+
+        async def dispose(self) -> None:
+            pass
+
+    class TestFactory:
+        def __init__(self, executor):
+            self.executor = executor
+
+        def discover_entrypoints(self) -> list[str]:
+            return ["test"]
+
+        async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+            return None
+
+        async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+            return None
+
+        async def new_runtime(
+            self, entrypoint: str, runtime_id: str, **kwargs
+        ) -> UiPathRuntimeProtocol:
+            return TestRuntime(self.executor)
+
+        async def dispose(self) -> None:
+            pass
+
+    factory = TestFactory(identity)
+
+    # Load evaluation set
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create runtime and get schema
+    runtime = await factory.new_runtime("test", "test-runtime-id")
+    runtime_schema = await runtime.get_schema()
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+
+    # Act
+    result = await evaluate(
+        factory,
+        trace_manager,
+        context,
+        event_bus,
+    )
+
+    # Assert that the output is json-serializable
+    eval_output = UiPathEvalOutput.model_validate(result.output)
+    eval_output.model_dump_json()
+    assert result.output
+    output_dict = (
+        result.output.model_dump()
+        if isinstance(result.output, BaseModel)
+        else result.output
+    )
+    assert isinstance(output_dict, dict)
+    first_result = output_dict["evaluationSetResults"][0]["evaluationRunResults"][0]
+    assert first_result["result"]["score"] == 1.0
+    assert first_result["evaluatorId"] == "ExactMatchEvaluator"
+    # Verify details are properly serialized (not empty dict)
+    details = first_result["result"].get("details")
+    if details is not None:
+        assert details != {}, (
+            "details should not be an empty dict - BaseModel serialization bug"
+        )
+        assert isinstance(details, (str, dict))
+
+
+async def test_eval_runtime_generates_uuid_when_no_custom_id():
+    """Test that UiPathEvalRuntime uses execution_id from context."""
+    # Arrange
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    async def identity(input: dict[str, Any]) -> dict[str, Any]:
+        return input
+
+    # Mock runtime that implements the protocol
+    class TestRuntime:
+        def __init__(self, executor):
+            self.executor = executor
+
+        async def execute(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathExecuteOptions | None = None,
+        ) -> UiPathRuntimeResult:
+            result = await self.executor(input or {})
+            return UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def stream(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathStreamOptions | None = None,
+        ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+            result = await self.executor(input or {})
+            yield UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def get_schema(self) -> UiPathRuntimeSchema:
+            return UiPathRuntimeSchema(
+                filePath="test.py",
+                uniqueId="test",
+                type="workflow",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            )
+
+        async def dispose(self) -> None:
+            pass
+
+    class TestFactory:
+        def __init__(self, executor):
+            self.executor = executor
+
+        def discover_entrypoints(self) -> list[str]:
+            return ["test"]
+
+        async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+            return None
+
+        async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+            return None
+
+        async def new_runtime(
+            self, entrypoint: str, runtime_id: str, **kwargs
+        ) -> UiPathRuntimeProtocol:
+            return TestRuntime(self.executor)
+
+        async def dispose(self) -> None:
+            pass
+
+    factory = TestFactory(identity)
+
+    # Load evaluation set
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create runtime and get schema
+    runtime = await factory.new_runtime("test", "test-runtime-id")
+    runtime_schema = await runtime.get_schema()
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+
+    # Act
+    eval_runtime = UiPathEvalRuntime(
+        context,
+        factory,
+        trace_manager,
+        event_bus,
+    )
+
+    # Assert
+    # Should be a valid UUID format (36 characters with dashes)
+    assert len(eval_runtime.execution_id) == 36
+    assert eval_runtime.execution_id.count("-") == 4
+
+
+async def test_eval_runtime_works_without_exporters():
+    """Test that UiPathEvalRuntime works when both exporters are None (local execution)."""
+    # Arrange
+    event_bus = EventBus()
+    trace_manager = UiPathTraceManager()
+
+    async def identity(input: dict[str, Any]) -> dict[str, Any]:
+        return input
+
+    # Mock runtime that implements the protocol
+    class TestRuntime:
+        def __init__(self, executor):
+            self.executor = executor
+
+        async def execute(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathExecuteOptions | None = None,
+        ) -> UiPathRuntimeResult:
+            result = await self.executor(input or {})
+            return UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def stream(
+            self,
+            input: dict[str, Any] | None = None,
+            options: UiPathStreamOptions | None = None,
+        ) -> AsyncGenerator[UiPathRuntimeEvent, None]:
+            result = await self.executor(input or {})
+            yield UiPathRuntimeResult(
+                output=result,
+                status=UiPathRuntimeStatus.SUCCESSFUL,
+            )
+
+        async def get_schema(self) -> UiPathRuntimeSchema:
+            return UiPathRuntimeSchema(
+                filePath="test.py",
+                uniqueId="test",
+                type="workflow",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            )
+
+        async def dispose(self) -> None:
+            pass
+
+    class TestFactory:
+        def __init__(self, executor):
+            self.executor = executor
+
+        def discover_entrypoints(self) -> list[str]:
+            return ["test"]
+
+        async def get_storage(self) -> UiPathRuntimeStorageProtocol | None:
+            return None
+
+        async def get_settings(self) -> UiPathRuntimeFactorySettings | None:
+            return None
+
+        async def new_runtime(
+            self, entrypoint: str, runtime_id: str, **kwargs
+        ) -> UiPathRuntimeProtocol:
+            return TestRuntime(self.executor)
+
+        async def dispose(self) -> None:
+            pass
+
+    factory = TestFactory(identity)
+
+    # Load evaluation set
+    eval_set_path = str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    evaluation_set, _ = EvalHelpers.load_eval_set(eval_set_path)
+
+    # Create runtime and get schema
+    runtime = await factory.new_runtime("test", "test-runtime-id")
+    runtime_schema = await runtime.get_schema()
+
+    # Load evaluators
+    evaluators = await EvalHelpers.load_evaluators(
+        eval_set_path, evaluation_set, agent_model=None
+    )
+
+    # Set up context
+    context = UiPathEvalContext()
+    context.execution_id = str(uuid.uuid4())
+    context.evaluation_set = evaluation_set
+    context.runtime_schema = runtime_schema
+    context.evaluators = evaluators
+
+    # Act
+    eval_runtime = UiPathEvalRuntime(
+        context,
+        factory,
+        trace_manager,
+        event_bus,
+    )
+
+    # Assert - Runtime should work
+    assert eval_runtime is not None
+    assert len(eval_runtime.execution_id) == 36
+    assert eval_runtime.execution_id.count("-") == 4
+
+    # Verify that evaluate() also works
+    result = await evaluate(
+        factory,
+        trace_manager,
+        context,
+        event_bus,
+    )
+
+    # Assert that the evaluation completed successfully
+    assert result.output is not None
diff --git a/packages/uipath/tests/cli/eval/test_input_overrides_e2e.py b/packages/uipath/tests/cli/eval/test_input_overrides_e2e.py
new file mode 100644
index 000000000..0f0ac6158
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_input_overrides_e2e.py
@@ -0,0 +1,290 @@
+"""End-to-end tests for input overrides functionality."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from uipath.eval.helpers import EvalHelpers
+from uipath.eval.models.evaluation_set import (
+    EvaluationSet,
+    LegacyEvaluationSet,
+)
+from uipath.eval.runtime.context import UiPathEvalContext
+
+
+@pytest.mark.asyncio
+async def test_input_overrides_e2e_direct_override():
+    """E2E test: per-evaluation input overrides on calculator inputs."""
+    # Create a calculator agent.json
+    agent_config = {
+        "id": "test-calc-agent",
+        "version": "1.0.0",
+        "name": "Test Calculator",
+        "messages": [
+            {"role": "system", "content": "You are a calculator."},
+            {"role": "user", "content": "Calculate: {{a}} {{operator}} {{b}}"},
+        ],
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "a": {"type": "number"},
+                "b": {"type": "number"},
+                "operator": {"type": "string"},
+            },
+        },
+        "outputSchema": {
+            "type": "object",
+            "properties": {"result": {"type": "number"}},
+        },
+        "settings": {"model": "gpt-4", "temperature": 0},
+    }
+
+    # Create evaluation set with inputs that will be overridden
+    eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": [],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test Override",
+                "inputs": {"a": 5, "b": 3, "operator": "+"},
+                "expectedOutput": {"result": 50},  # Expect 10 * 5 = 50
+                "expectedAgentBehavior": "Should calculate with overridden values",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-12-16T00:00:00.000Z",
+                "updatedAt": "2025-12-16T00:00:00.000Z",
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-12-16T00:00:00.000Z",
+        "updatedAt": "2025-12-16T00:00:00.000Z",
+    }
+
+    # Create temp files
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+
+        # Write agent.json
+        agent_file = tmpdir_path / "agent.json"
+        with open(agent_file, "w") as f:
+            json.dump(agent_config, f)
+
+        # Write eval set
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(eval_set, f)
+
+        # Load evaluation set to verify override structure
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+        assert isinstance(loaded_eval_set, (LegacyEvaluationSet, EvaluationSet))
+        assert len(loaded_eval_set.evaluations) == 1
+        original_input = loaded_eval_set.evaluations[0].inputs
+        assert original_input["a"] == 5
+        assert original_input["b"] == 3
+        assert original_input["operator"] == "+"
+
+        # Per-evaluation overrides
+        overrides = {
+            "test-eval-1": {
+                "a": 10,
+                "operator": "*",
+            }
+        }
+
+        # Apply overrides to the inputs with eval_id
+        from uipath.eval.runtime._utils import apply_input_overrides
+
+        modified_inputs = apply_input_overrides(
+            original_input, overrides, eval_id="test-eval-1"
+        )
+
+        # Verify overrides were applied
+        assert modified_inputs["a"] == 10  # Overridden
+        assert modified_inputs["operator"] == "*"  # Overridden
+        assert modified_inputs["b"] == 3  # Unchanged
+
+
+@pytest.mark.asyncio
+async def test_input_overrides_e2e_direct_field():
+    """E2E test: input overrides with direct field override."""
+    # Create evaluation set
+    eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": [],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test Direct Field Override",
+                "inputs": {
+                    "file_id": "old-attachment-123",
+                    "document_id": "old-doc-456",
+                    "count": 5,
+                },
+                "expectedOutput": {"status": "success"},
+                "expectedAgentBehavior": "Process with new values",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-12-16T00:00:00.000Z",
+                "updatedAt": "2025-12-16T00:00:00.000Z",
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-12-16T00:00:00.000Z",
+        "updatedAt": "2025-12-16T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+
+        # Write eval set
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(eval_set, f)
+
+        # Load and test
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+        original_input = loaded_eval_set.evaluations[0].inputs
+
+        # Per-evaluation overrides
+        overrides = {
+            "test-eval-1": {
+                "file_id": "new-attachment-789",
+                "document_id": "new-doc-999",
+                "count": 10,
+            }
+        }
+
+        from uipath.eval.runtime._utils import apply_input_overrides
+
+        modified_inputs = apply_input_overrides(
+            original_input, overrides, eval_id="test-eval-1"
+        )
+
+        # Verify direct field override worked
+        assert modified_inputs["file_id"] == "new-attachment-789"
+        assert modified_inputs["document_id"] == "new-doc-999"
+        assert modified_inputs["count"] == 10
+
+
+@pytest.mark.asyncio
+async def test_input_overrides_e2e_nested_objects():
+    """E2E test: input overrides with nested objects using deep merge."""
+    eval_set = {
+        "fileName": "test-eval.json",
+        "id": "test-eval-set-id",
+        "name": "Test Eval Set",
+        "batchSize": 10,
+        "evaluatorRefs": [],
+        "evaluations": [
+            {
+                "id": "test-eval-1",
+                "name": "Test Nested Override",
+                "inputs": {
+                    "filePath": {
+                        "ID": "old-attachment-id",
+                        "FullName": "document.pdf",
+                        "MimeType": "application/pdf",
+                    },
+                    "config": {"threshold": 0.8, "model": "gpt-4"},
+                },
+                "expectedOutput": {"status": "processed"},
+                "expectedAgentBehavior": "Process with overridden attachment",
+                "evalSetId": "test-eval-set-id",
+                "createdAt": "2025-12-16T00:00:00.000Z",
+                "updatedAt": "2025-12-16T00:00:00.000Z",
+            }
+        ],
+        "modelSettings": [],
+        "createdAt": "2025-12-16T00:00:00.000Z",
+        "updatedAt": "2025-12-16T00:00:00.000Z",
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        eval_file = tmpdir_path / "eval-set.json"
+        with open(eval_file, "w") as f:
+            json.dump(eval_set, f)
+
+        loaded_eval_set, _ = EvalHelpers.load_eval_set(str(eval_file))
+        original_input = loaded_eval_set.evaluations[0].inputs
+
+        # Per-evaluation overrides with deep merge for nested objects
+        overrides = {
+            "test-eval-1": {
+                "filePath": {"ID": "new-attachment-id-xyz"},
+                "config": {"threshold": 0.95},
+            }
+        }
+
+        from uipath.eval.runtime._utils import apply_input_overrides
+
+        modified_inputs = apply_input_overrides(
+            original_input, overrides, eval_id="test-eval-1"
+        )
+
+        # Verify deep merge - overridden fields updated, others preserved
+        assert (
+            modified_inputs["filePath"]["ID"] == "new-attachment-id-xyz"
+        )  # Overridden
+        assert modified_inputs["filePath"]["FullName"] == "document.pdf"  # Preserved
+        assert modified_inputs["filePath"]["MimeType"] == "application/pdf"  # Preserved
+        assert modified_inputs["config"]["threshold"] == 0.95  # Overridden
+        assert modified_inputs["config"]["model"] == "gpt-4"  # Preserved
+
+
+@pytest.mark.asyncio
+async def test_input_overrides_context_field():
+    """Test that UiPathEvalContext properly stores input_overrides."""
+    context = UiPathEvalContext()
+    context.input_overrides = {"eval-1": {"a": 10, "operator": "*"}}
+
+    assert context.input_overrides is not None
+    assert "eval-1" in context.input_overrides
+    assert context.input_overrides["eval-1"]["a"] == 10
+    assert context.input_overrides["eval-1"]["operator"] == "*"
+
+
+@pytest.mark.asyncio
+async def test_input_overrides_per_evaluation():
+    """E2E test: per-evaluation input overrides."""
+    # Per-evaluation overrides
+    overrides = {
+        "eval-1": {"operator": "*", "a": 10},
+        "eval-2": {"operator": "/", "b": 5},
+    }
+
+    from uipath.eval.runtime._utils import apply_input_overrides
+
+    # Test eval-1
+    eval_1_inputs = {"a": 5, "b": 3, "operator": "+"}
+    modified_inputs_1 = apply_input_overrides(
+        eval_1_inputs, overrides, eval_id="eval-1"
+    )
+    assert modified_inputs_1["a"] == 10  # Overridden
+    assert modified_inputs_1["operator"] == "*"  # Overridden
+    assert modified_inputs_1["b"] == 3  # Preserved
+
+    # Test eval-2
+    eval_2_inputs = {"a": 20, "b": 10, "operator": "+"}
+    modified_inputs_2 = apply_input_overrides(
+        eval_2_inputs, overrides, eval_id="eval-2"
+    )
+    assert modified_inputs_2["a"] == 20  # Preserved
+    assert modified_inputs_2["b"] == 5  # Overridden
+    assert modified_inputs_2["operator"] == "/"  # Overridden
+
+    # Test eval-3 (no overrides)
+    eval_3_inputs = {"a": 7, "b": 4, "operator": "-"}
+    modified_inputs_3 = apply_input_overrides(
+        eval_3_inputs, overrides, eval_id="eval-3"
+    )
+    assert modified_inputs_3["a"] == 7  # Unchanged
+    assert modified_inputs_3["b"] == 4  # Unchanged
+    assert modified_inputs_3["operator"] == "-"  # Unchanged
diff --git a/packages/uipath/tests/cli/eval/test_live_tracking_span_processor.py b/packages/uipath/tests/cli/eval/test_live_tracking_span_processor.py
new file mode 100644
index 000000000..a20c18d9b
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_live_tracking_span_processor.py
@@ -0,0 +1,418 @@
+"""Tests for LiveTrackingSpanProcessor."""
+
+import threading
+import time
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+from opentelemetry import context as context_api
+from opentelemetry.sdk.trace import ReadableSpan, Span
+
+from uipath.runtime import UiPathRuntimeFactorySettings
+from uipath.tracing import LiveTrackingSpanProcessor, SpanStatus
+
+
+class TestLiveTrackingSpanProcessor:
+    """Test suite for LiveTrackingSpanProcessor."""
+
+    @pytest.fixture
+    def mock_exporter(self):
+        """Create a mock LlmOpsHttpExporter."""
+        exporter = Mock()
+        exporter.upsert_span = Mock()
+        return exporter
+
+    @pytest.fixture
+    def processor_no_filter(self, mock_exporter):
+        """Create a LiveTrackingSpanProcessor with no filtering (settings=None)."""
+        return LiveTrackingSpanProcessor(mock_exporter, settings=None)
+
+    @pytest.fixture
+    def processor_with_filter(self, mock_exporter):
+        """Create a LiveTrackingSpanProcessor with custom instrumentation filter."""
+        from uipath.core.tracing.types import UiPathTraceSettings
+
+        settings = UiPathRuntimeFactorySettings(
+            trace_settings=UiPathTraceSettings(
+                span_filter=lambda span: bool(
+                    span.attributes
+                    and span.attributes.get("uipath.custom_instrumentation")
+                )
+            )
+        )
+        return LiveTrackingSpanProcessor(
+            mock_exporter, settings=settings.trace_settings
+        )
+
+    def create_mock_span(self, attributes: dict[str, Any] | None = None):
+        """Create a mock span with attributes."""
+        span = Mock(spec=Span)
+        span.attributes = attributes or {}
+        return span
+
+    def create_mock_readable_span(self, attributes: dict[str, Any] | None = None):
+        """Create a mock ReadableSpan with attributes."""
+        span = Mock(spec=ReadableSpan)
+        span.attributes = attributes or {}
+        return span
+
+    def test_init(self, mock_exporter):
+        """Test processor initialization."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+
+        assert processor.exporter == mock_exporter
+
+    def test_init_with_no_settings(self, mock_exporter):
+        """Test processor initialization with no settings."""
+        processor = LiveTrackingSpanProcessor(mock_exporter, settings=None)
+
+        assert processor.span_filter is None  # No filtering
+
+    def test_init_with_settings_and_filter(self, mock_exporter):
+        """Test processor initialization with settings containing filter."""
+        from uipath.core.tracing.types import UiPathTraceSettings
+
+        settings = UiPathRuntimeFactorySettings(
+            trace_settings=UiPathTraceSettings(
+                span_filter=lambda span: bool(
+                    span.attributes and span.attributes.get("test")
+                )
+            )
+        )
+        processor = LiveTrackingSpanProcessor(
+            mock_exporter, settings=settings.trace_settings
+        )
+
+        assert processor.span_filter is not None
+
+    # Tests for no filter (all spans pass through)
+
+    def test_on_start_no_filter_accepts_all(self, processor_no_filter, mock_exporter):
+        """Test on_start with no filter accepts all spans."""
+        span = self.create_mock_span({"span_type": "agent"})
+
+        processor_no_filter.on_start(span, None)
+
+        mock_exporter.upsert_span.assert_called_once_with(
+            span, status_override=SpanStatus.RUNNING
+        )
+
+    def test_on_end_no_filter_accepts_all(self, processor_no_filter, mock_exporter):
+        """Test on_end with no filter accepts all spans."""
+        span = self.create_mock_readable_span({"span_type": "agent"})
+
+        processor_no_filter.on_end(span)
+
+        mock_exporter.upsert_span.assert_called_once_with(span)
+
+    # Tests for custom instrumentation filter
+
+    def test_on_start_with_filter_accepts_matching(
+        self, processor_with_filter, mock_exporter
+    ):
+        """Test on_start with filter accepts matching spans."""
+        span = self.create_mock_span({"uipath.custom_instrumentation": True})
+
+        processor_with_filter.on_start(span, None)
+
+        mock_exporter.upsert_span.assert_called_once_with(
+            span, status_override=SpanStatus.RUNNING
+        )
+
+    def test_on_start_with_filter_rejects_non_matching(
+        self, processor_with_filter, mock_exporter
+    ):
+        """Test on_start with filter rejects non-matching spans."""
+        span = self.create_mock_span({"span_type": "agent"})
+
+        processor_with_filter.on_start(span, None)
+
+        mock_exporter.upsert_span.assert_not_called()
+
+    def test_on_end_with_filter_accepts_matching(
+        self, processor_with_filter, mock_exporter
+    ):
+        """Test on_end with filter accepts matching spans."""
+        span = self.create_mock_readable_span({"uipath.custom_instrumentation": True})
+
+        processor_with_filter.on_end(span)
+
+        mock_exporter.upsert_span.assert_called_once_with(span)
+
+    def test_on_end_with_filter_rejects_non_matching(
+        self, processor_with_filter, mock_exporter
+    ):
+        """Test on_end with filter rejects non-matching spans."""
+        span = self.create_mock_readable_span({"span_type": "agent"})
+
+        processor_with_filter.on_end(span)
+
+        mock_exporter.upsert_span.assert_not_called()
+
+    def test_on_start_with_no_attributes(self, processor_with_filter, mock_exporter):
+        """Test on_start with filter handles spans with no attributes."""
+        span = self.create_mock_span(None)
+
+        processor_with_filter.on_start(span, None)
+
+        mock_exporter.upsert_span.assert_not_called()
+
+    def test_on_end_with_no_attributes(self, processor_with_filter, mock_exporter):
+        """Test on_end with filter handles spans with no attributes."""
+        span = self.create_mock_readable_span(None)
+
+        processor_with_filter.on_end(span)
+
+        mock_exporter.upsert_span.assert_not_called()
+
+    def test_on_start_exception_handling(self, processor_no_filter, mock_exporter):
+        """Test on_start handles exceptions gracefully."""
+        span = self.create_mock_span({"span_type": "eval"})
+        mock_exporter.upsert_span.side_effect = Exception("Network error")
+
+        # Should not raise exception
+        processor_no_filter.on_start(span, None)
+
+        mock_exporter.upsert_span.assert_called_once()
+
+    def test_on_end_exception_handling(self, processor_no_filter, mock_exporter):
+        """Test on_end handles exceptions gracefully."""
+        span = self.create_mock_readable_span({"span_type": "eval"})
+        mock_exporter.upsert_span.side_effect = Exception("Network error")
+
+        # Should not raise exception
+        processor_no_filter.on_end(span)
+
+        mock_exporter.upsert_span.assert_called_once()
+
+    def test_shutdown(self, processor_no_filter):
+        """Test shutdown method."""
+        # Should not raise exception
+        processor_no_filter.shutdown()
+
+    def test_force_flush(self, processor_no_filter):
+        """Test force_flush method."""
+        result = processor_no_filter.force_flush()
+        assert result is True
+
+    def test_force_flush_with_timeout(self, processor_no_filter):
+        """Test force_flush with custom timeout."""
+        result = processor_no_filter.force_flush(timeout_millis=5000)
+        assert result is True
+
+    def test_on_start_with_parent_context(self, processor_no_filter, mock_exporter):
+        """Test on_start with parent context."""
+        span = self.create_mock_span({"span_type": "eval"})
+        parent_context = Mock(spec=context_api.Context)
+
+        processor_no_filter.on_start(span, parent_context)
+
+        mock_exporter.upsert_span.assert_called_once_with(
+            span, status_override=SpanStatus.RUNNING
+        )
+
+    # Tests for ThreadPoolExecutor behavior
+
+    def test_thread_pool_executor_used(self, mock_exporter):
+        """Test that processor uses ThreadPoolExecutor for async operations."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_span({"span_type": "eval"})
+
+        # Verify executor exists
+        assert hasattr(processor, "executor")
+        assert processor.executor is not None
+
+        # Submit task and verify it's non-blocking
+        start_time = time.time()
+        processor.on_start(span, None)
+        elapsed = time.time() - start_time
+
+        # Should return immediately (< 0.05 seconds)
+        assert elapsed < 0.05, f"on_start blocked for {elapsed} seconds"
+
+    def test_handles_exceptions_gracefully(self, mock_exporter):
+        """Test that exceptions in background threads don't crash."""
+        mock_exporter.upsert_span = Mock(side_effect=Exception("Network error"))
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_span({"span_type": "eval"})
+
+        # Should not raise exception
+        processor.on_start(span, None)
+        # Wait for background thread to process
+        time.sleep(0.2)
+
+        # Main thread should still be alive
+        assert threading.current_thread().is_alive()
+
+    def test_upsert_span_async_with_status_override(self, mock_exporter):
+        """Test _upsert_span_async correctly passes status_override."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_span({"span_type": "eval"})
+
+        processor._upsert_span_async(span, status_override=SpanStatus.RUNNING)
+
+        # Wait for background thread to complete
+        time.sleep(0.2)
+
+        mock_exporter.upsert_span.assert_called_once_with(
+            span, status_override=SpanStatus.RUNNING
+        )
+
+    def test_upsert_span_async_without_status_override(self, mock_exporter):
+        """Test _upsert_span_async without status_override."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_readable_span({"span_type": "eval"})
+
+        processor._upsert_span_async(span, status_override=None)
+
+        # Wait for background thread to complete
+        time.sleep(0.2)
+
+        mock_exporter.upsert_span.assert_called_once_with(span)
+
+    def test_processor_initialization_with_custom_max_workers(self, mock_exporter):
+        """Test processor can be initialized with custom max_workers."""
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=15)
+        assert processor.executor._max_workers == 15
+
+    def test_exception_in_background_thread_does_not_crash(self, mock_exporter):
+        """Test that exceptions in background threads don't crash the main thread."""
+        mock_exporter.upsert_span = Mock(side_effect=Exception("Background error"))
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_span({"span_type": "eval"})
+
+        # Should not raise exception
+        processor.on_start(span, None)
+        time.sleep(0.2)  # Wait for background thread
+
+        # Main thread should still be alive
+        assert threading.current_thread().is_alive()
+
+    # Tests for ThreadPoolExecutor and max_workers
+
+    def test_processor_with_custom_max_workers(self, mock_exporter):
+        """Test processor can be initialized with custom max_workers."""
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=20)
+        assert processor.executor._max_workers == 20
+
+    def test_processor_default_max_workers(self, mock_exporter):
+        """Test processor uses default max_workers of 10."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        assert processor.executor._max_workers == 10
+
+    def test_thread_pool_caps_concurrent_threads(self, mock_exporter):
+        """Test that thread pool caps concurrent threads to max_workers."""
+        concurrent_calls = []
+        max_concurrent = 0
+
+        def slow_upsert(*args, **kwargs):
+            concurrent_calls.append(1)
+            nonlocal max_concurrent
+            max_concurrent = max(max_concurrent, len(concurrent_calls))
+            time.sleep(0.5)
+            concurrent_calls.pop()
+
+        mock_exporter.upsert_span = Mock(side_effect=slow_upsert)
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=3)
+
+        # Submit 10 tasks rapidly
+        spans = [
+            self.create_mock_span({"span_type": "eval", "id": str(i)})
+            for i in range(10)
+        ]
+
+        for span in spans:
+            processor.on_start(span, None)
+
+        # Wait for all to complete
+        time.sleep(2)
+
+        # Max concurrent should not exceed max_workers (3)
+        assert max_concurrent <= 3, (
+            f"Max concurrent was {max_concurrent}, expected <= 3"
+        )
+
+    def test_shutdown_waits_for_pending_tasks(self, mock_exporter):
+        """Test that shutdown properly cleans up the thread pool."""
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=2)
+
+        # Submit some tasks
+        for i in range(3):
+            span = self.create_mock_span({"span_type": "eval", "id": str(i)})
+            processor.on_start(span, None)
+
+        # Shutdown should complete without errors
+        processor.shutdown()
+
+        # Verify executor is shutdown (calling shutdown multiple times should be safe)
+        processor.shutdown()  # Should not raise
+
+    def test_multiple_processors_independent_thread_pools(self, mock_exporter):
+        """Test that multiple processors have independent thread pools."""
+        processor1 = LiveTrackingSpanProcessor(mock_exporter, max_workers=5)
+        processor2 = LiveTrackingSpanProcessor(mock_exporter, max_workers=15)
+
+        assert processor1.executor != processor2.executor
+        assert processor1.executor._max_workers == 5
+        assert processor2.executor._max_workers == 15
+
+    def test_thread_pool_name_prefix(self, mock_exporter):
+        """Test that thread pool uses correct name prefix."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        # ThreadPoolExecutor sets _thread_name_prefix
+        assert processor.executor._thread_name_prefix == "span-upsert"
+
+    def test_resource_exhaustion_prevention(self, mock_exporter):
+        """Test that max_workers prevents resource exhaustion."""
+        call_times = []
+
+        def timed_upsert(*args, **kwargs):
+            call_times.append(time.time())
+            time.sleep(0.3)
+
+        mock_exporter.upsert_span = Mock(side_effect=timed_upsert)
+        # Very low max_workers to test queueing
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=2)
+
+        # Submit 6 tasks
+        for i in range(6):
+            span = self.create_mock_span({"span_type": "eval", "id": str(i)})
+            processor.on_start(span, None)
+
+        # Wait for all to complete
+        time.sleep(2)
+
+        # All 6 should complete
+        assert len(call_times) == 6
+
+        # With max_workers=2 and 0.3s per task, we should see batching
+        # Sort by time to analyze execution pattern
+        call_times.sort()
+        # First 2 should start quickly, next batch should wait
+        assert call_times[1] - call_times[0] < 0.2  # First batch starts together
+        assert (
+            call_times[3] - call_times[1] > 0.2
+        )  # Second batch waits for first to finish
+
+    def test_shutdown_can_be_called_multiple_times(self, mock_exporter):
+        """Test that shutdown can be safely called multiple times."""
+        processor = LiveTrackingSpanProcessor(mock_exporter)
+        span = self.create_mock_span({"span_type": "eval"})
+
+        processor.on_start(span, None)
+        time.sleep(0.1)
+
+        # Multiple shutdowns should not raise exceptions
+        processor.shutdown()
+        processor.shutdown()
+        processor.shutdown()
+
+    def test_executor_properly_initialized(self, mock_exporter):
+        """Test that ThreadPoolExecutor is properly initialized."""
+        processor = LiveTrackingSpanProcessor(mock_exporter, max_workers=7)
+
+        assert processor.executor is not None
+        assert hasattr(processor.executor, "submit")
+        assert hasattr(processor.executor, "shutdown")
+        assert processor.executor._max_workers == 7
diff --git a/packages/uipath/tests/cli/eval/test_progress_reporter.py b/packages/uipath/tests/cli/eval/test_progress_reporter.py
new file mode 100644
index 000000000..1fd00bf12
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_progress_reporter.py
@@ -0,0 +1,1133 @@
+"""Tests for StudioWebProgressReporter.
+
+This module tests the progress reporting functionality including:
+- Detection of coded vs legacy evaluators
+- Endpoint routing for localhost vs production
+- Usage metrics extraction from spans
+- Request spec generation for different evaluator types
+- Custom eval set run ID handling
+"""
+
+import json
+from typing import Any
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+from opentelemetry.sdk.trace import ReadableSpan
+
+from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
+from uipath.eval.runtime.events import EvalSetRunCreatedEvent, EvalSetRunUpdatedEvent
+from uipath.tracing import LlmOpsHttpExporter
+
+# Test fixtures - simple mocks without full evaluator instantiation
+
+
+@pytest.fixture
+def mock_exporter():
+    """Create a mock LlmOpsHttpExporter."""
+    return Mock(spec=LlmOpsHttpExporter)
+
+
+@pytest.fixture
+def progress_reporter(mock_exporter, monkeypatch):
+    """Create a StudioWebProgressReporter instance for testing."""
+    monkeypatch.setenv("UIPATH_URL", "https://test.uipath.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+    monkeypatch.setenv("UIPATH_PROJECT_ID", "test-project-id")
+    monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+
+    reporter = StudioWebProgressReporter()
+    return reporter
+
+
+@pytest.fixture
+def sample_spans_with_usage():
+    """Create sample spans with usage metrics."""
+    span1 = Mock(spec=ReadableSpan)
+    span1.attributes = {
+        "gen_ai.usage.prompt_tokens": 100,
+        "gen_ai.usage.completion_tokens": 50,
+        "gen_ai.usage.total_tokens": 150,
+        "gen_ai.usage.cost": 0.01,
+    }
+
+    span2 = Mock(spec=ReadableSpan)
+    span2.attributes = {
+        "gen_ai.usage.prompt_tokens": 200,
+        "gen_ai.usage.completion_tokens": 100,
+        "gen_ai.usage.total_tokens": 300,
+        "llm.usage.cost": 0.02,
+    }
+
+    return [span1, span2]
+
+
+@pytest.fixture
+def sample_spans_with_nested_usage():
+    """Create sample spans with nested usage metrics (backend format)."""
+    span = Mock(spec=ReadableSpan)
+    span.attributes = {
+        "usage": {
+            "promptTokens": 500,
+            "completionTokens": 250,
+            "totalTokens": 750,
+            "cost": 0.05,
+        }
+    }
+    span.Attributes = None
+
+    return [span]
+
+
+@pytest.fixture
+def sample_spans_with_json_attributes():
+    """Create sample spans with JSON string attributes."""
+    span = Mock(spec=ReadableSpan)
+    span.attributes = json.dumps(
+        {
+            "usage": {
+                "promptTokens": 300,
+                "completionTokens": 150,
+                "totalTokens": 450,
+            }
+        }
+    )
+    span.Attributes = None
+
+    return [span]
+
+
+# Tests for evaluator type detection
+class TestEvaluatorDetection:
+    """Tests for coded vs legacy evaluator detection."""
+
+    def test_is_coded_evaluator_with_empty_list(self, progress_reporter):
+        """Test detection with empty evaluator list."""
+        assert progress_reporter._is_coded_evaluator([]) is False
+
+    def test_is_coded_evaluator_uses_isinstance_check(self, progress_reporter):
+        """Test that detection uses isinstance to check evaluator type.
+
+        Note: Full integration test would require real evaluator instances.
+        The _is_coded_evaluator method checks isinstance, which won't work with mocks.
+        The empty list case is covered in test_is_coded_evaluator_with_empty_list.
+        """
+        # This test documents the approach - isinstance checking
+        # Actual testing requires integration tests with real evaluators
+        pass
+
+
+# Tests for endpoint routing
+class TestEndpointRouting:
+    """Tests for endpoint prefix and localhost detection."""
+
+    def test_is_localhost_with_localhost_url(self, progress_reporter, monkeypatch):
+        """Test localhost detection with localhost URL."""
+        monkeypatch.setenv("UIPATH_EVAL_BACKEND_URL", "http://localhost:8080")
+        assert progress_reporter._is_localhost() is True
+
+    def test_is_localhost_with_127_0_0_1_url(self, progress_reporter, monkeypatch):
+        """Test localhost detection with 127.0.0.1 URL."""
+        monkeypatch.setenv("UIPATH_EVAL_BACKEND_URL", "http://127.0.0.1:8080")
+        assert progress_reporter._is_localhost() is True
+
+    def test_is_localhost_with_production_url(self, progress_reporter, monkeypatch):
+        """Test localhost detection with production URL."""
+        monkeypatch.setenv("UIPATH_EVAL_BACKEND_URL", "https://cloud.uipath.com")
+        assert progress_reporter._is_localhost() is False
+
+    def test_is_localhost_without_env_var(self, progress_reporter, monkeypatch):
+        """Test localhost detection without environment variable."""
+        monkeypatch.delenv("UIPATH_EVAL_BACKEND_URL", raising=False)
+        assert progress_reporter._is_localhost() is False
+
+    def test_get_endpoint_prefix_for_localhost(self, progress_reporter, monkeypatch):
+        """Test endpoint prefix for localhost."""
+        monkeypatch.setenv("UIPATH_EVAL_BACKEND_URL", "http://localhost:8080")
+        assert progress_reporter._get_endpoint_prefix() == "api/"
+
+    def test_get_endpoint_prefix_for_production(self, progress_reporter, monkeypatch):
+        """Test endpoint prefix for production."""
+        monkeypatch.setenv("UIPATH_EVAL_BACKEND_URL", "https://cloud.uipath.com")
+        assert progress_reporter._get_endpoint_prefix() == "agentsruntime_/api/"
+
+
+# Tests for usage metrics extraction
+class TestUsageMetricsExtraction:
+    """Tests for extracting usage metrics from spans."""
+
+    def test_extract_usage_from_spans_with_opentelemetry_format(
+        self, progress_reporter, sample_spans_with_usage
+    ):
+        """Test usage extraction from OpenTelemetry semantic convention format."""
+        usage = progress_reporter._extract_usage_from_spans(sample_spans_with_usage)
+
+        assert usage["tokens"] == 450  # 150 + 300
+        assert usage["promptTokens"] == 300  # 100 + 200
+        assert usage["completionTokens"] == 150  # 50 + 100
+        assert usage["cost"] == 0.03  # 0.01 + 0.02
+
+    def test_extract_usage_from_spans_with_nested_format(
+        self, progress_reporter, sample_spans_with_nested_usage
+    ):
+        """Test usage extraction from nested usage object format."""
+        usage = progress_reporter._extract_usage_from_spans(
+            sample_spans_with_nested_usage
+        )
+
+        assert usage["tokens"] == 750
+        assert usage["promptTokens"] == 500
+        assert usage["completionTokens"] == 250
+        assert usage["cost"] == 0.05
+
+    def test_extract_usage_from_spans_with_json_string(
+        self, progress_reporter, sample_spans_with_json_attributes
+    ):
+        """Test usage extraction from JSON string attributes."""
+        usage = progress_reporter._extract_usage_from_spans(
+            sample_spans_with_json_attributes
+        )
+
+        assert usage["tokens"] == 450
+        assert usage["promptTokens"] == 300
+        assert usage["completionTokens"] == 150
+        assert usage["cost"] is None  # No cost in this example
+
+    def test_extract_usage_from_empty_spans(self, progress_reporter):
+        """Test usage extraction from empty span list."""
+        usage = progress_reporter._extract_usage_from_spans([])
+
+        assert usage["tokens"] is None
+        assert usage["promptTokens"] is None
+        assert usage["completionTokens"] is None
+        assert usage["cost"] is None
+
+    def test_extract_usage_from_spans_without_usage(self, progress_reporter):
+        """Test usage extraction from spans without usage data."""
+        span = Mock(spec=ReadableSpan)
+        span.attributes = {"other_field": "value"}
+
+        usage = progress_reporter._extract_usage_from_spans([span])
+
+        assert usage["tokens"] is None
+        assert usage["promptTokens"] is None
+        assert usage["completionTokens"] is None
+        assert usage["cost"] is None
+
+
+# Result collection tests removed - complex to test without real evaluator instances
+# The core functionality is tested indirectly through the request spec generation tests
+
+
+# Tests for request spec generation
+class TestRequestSpecGeneration:
+    """Tests for generating request specs for different evaluator types."""
+
+    def test_create_eval_set_run_spec_for_coded(self, progress_reporter):
+        """Test creating eval set run spec for coded evaluators."""
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        agent_snapshot = StudioWebAgentSnapshot(
+            input_schema={"type": "object"}, output_schema={"type": "object"}
+        )
+
+        spec = progress_reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=agent_snapshot,
+            no_of_evals=5,
+            is_coded=True,
+        )
+
+        assert spec.method == "POST"
+        assert "coded/" in spec.endpoint
+        assert spec.json["evalSetId"] == "test-eval-set"
+        assert spec.json["source"] == 0
+        assert spec.json["numberOfEvalsExecuted"] == 5
+
+    def test_create_eval_set_run_spec_for_legacy(self, progress_reporter):
+        """Test creating eval set run spec for legacy evaluators."""
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        agent_snapshot = StudioWebAgentSnapshot(
+            input_schema={"type": "object"}, output_schema={"type": "object"}
+        )
+
+        spec = progress_reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=agent_snapshot,
+            no_of_evals=5,
+            is_coded=False,
+        )
+
+        assert spec.method == "POST"
+        assert "coded/" not in spec.endpoint
+        # Both coded and legacy now send payload directly at root level
+        # Legacy should not have version field
+        assert "version" not in spec.json
+        # Source field is now required by backend for all evaluations
+        assert spec.json["source"] == 0
+        assert spec.json["numberOfEvalsExecuted"] == 5
+        # Backend expects integer status
+        assert spec.json["status"] == 1  # IN_PROGRESS
+
+    def test_update_coded_eval_run_spec(self, progress_reporter):
+        """Test updating eval run spec for coded evaluators."""
+        evaluator_runs = [
+            {
+                "evaluatorId": "test-1",
+                "status": "completed",
+                "result": {"score": {"value": 0.9}},
+            }
+        ]
+        evaluator_scores = [{"evaluatorId": "test-1", "value": 0.9}]
+
+        spec = progress_reporter._update_coded_eval_run_spec(
+            evaluator_runs=evaluator_runs,
+            evaluator_scores=evaluator_scores,
+            eval_run_id="test-run-id",
+            actual_output={"result": "success"},
+            execution_time=5.5,
+            success=True,
+            is_coded=True,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" in spec.endpoint
+        assert spec.json["evalRunId"] == "test-run-id"
+        assert spec.json["evaluatorRuns"] == evaluator_runs
+        assert spec.json["result"]["scores"] == evaluator_scores
+        assert (
+            spec.json["completionMetrics"]["duration"] == 5500
+        )  # 5.5 seconds * 1000 = 5500 ms
+        assert spec.json["status"] == 2  # COMPLETED
+
+    def test_update_legacy_eval_run_spec(self, progress_reporter):
+        """Test updating eval run spec for legacy evaluators."""
+        assertion_runs = [
+            {"evaluatorId": "test-1", "status": "completed", "assertionSnapshot": {}}
+        ]
+        evaluator_scores = [{"evaluatorId": "test-1", "value": 0.9}]
+
+        spec = progress_reporter._update_eval_run_spec(
+            assertion_runs=assertion_runs,
+            evaluator_scores=evaluator_scores,
+            eval_run_id="test-run-id",
+            actual_output={"result": "success"},
+            execution_time=5.5,
+            success=True,
+            is_coded=False,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" not in spec.endpoint
+        # Both coded and legacy now send payload directly at root level
+        assert "request" not in spec.json
+        assert spec.json["evalRunId"] == "test-run-id"
+        assert spec.json["assertionRuns"] == assertion_runs
+        assert spec.json["result"]["evaluatorScores"] == evaluator_scores
+        assert (
+            spec.json["completionMetrics"]["duration"] == 5500
+        )  # 5.5 seconds * 1000 = 5500 ms
+        # Backend expects integer status
+        assert spec.json["status"] == 2  # COMPLETED
+
+    def test_update_coded_eval_run_spec_with_failure(self, progress_reporter):
+        """Test updating eval run spec for coded evaluators with failure."""
+        evaluator_runs: list[dict[str, Any]] = []
+        evaluator_scores: list[dict[str, Any]] = []
+
+        spec = progress_reporter._update_coded_eval_run_spec(
+            evaluator_runs=evaluator_runs,
+            evaluator_scores=evaluator_scores,
+            eval_run_id="test-run-id",
+            actual_output={},
+            execution_time=0.0,
+            success=False,
+            is_coded=True,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" in spec.endpoint
+        assert spec.json["evalRunId"] == "test-run-id"
+        assert spec.json["status"] == 3  # FAILED
+
+    def test_update_legacy_eval_run_spec_with_failure(self, progress_reporter):
+        """Test updating eval run spec for legacy evaluators with failure."""
+        assertion_runs: list[dict[str, Any]] = []
+        evaluator_scores: list[dict[str, Any]] = []
+
+        spec = progress_reporter._update_eval_run_spec(
+            assertion_runs=assertion_runs,
+            evaluator_scores=evaluator_scores,
+            eval_run_id="test-run-id",
+            actual_output={},
+            execution_time=0.0,
+            success=False,
+            is_coded=False,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" not in spec.endpoint
+        # Both coded and legacy now send payload directly at root level
+        assert "request" not in spec.json
+        assert spec.json["evalRunId"] == "test-run-id"
+        # Backend expects integer status
+        assert spec.json["status"] == 3  # FAILED
+
+
+# Tests for custom eval set run ID handling
+class TestCustomEvalSetRunId:
+    """Tests for handling custom eval set run IDs."""
+
+    @pytest.mark.asyncio
+    async def test_eval_set_run_created_event_with_user_provided_id(
+        self, progress_reporter
+    ):
+        """Test that when eval_set_run_id is provided, eval set run creation is skipped."""
+        # Arrange
+        execution_id = "execution-id-12345"
+        user_provided_id = "user-provided-id-12345"
+        event = EvalSetRunCreatedEvent(
+            execution_id=execution_id,
+            entrypoint="test.py",
+            eval_set_id="test-eval-set",
+            eval_set_run_id=user_provided_id,  # User provides custom ID for tracing
+            no_of_evals=5,
+            evaluators=[],
+        )
+
+        # Mock the create_eval_set_run_sw method to ensure it's not called
+        with patch.object(
+            progress_reporter,
+            "create_eval_set_run_sw",
+            new_callable=AsyncMock,
+        ) as mock_create:
+            with patch.object(
+                progress_reporter, "_extract_agent_snapshot"
+            ) as mock_extract:
+                mock_extract.return_value = Mock()
+                # Act
+                await progress_reporter.handle_create_eval_set_run(event)
+
+                # Assert
+                # Verify that create_eval_set_run_sw WAS NOT called (skip creation)
+                mock_create.assert_not_called()
+                # Verify that the user-provided ID was stored for operations
+                assert (
+                    progress_reporter.eval_set_run_ids[execution_id] == user_provided_id
+                )
+                # Verify that eval_set_run_id is tracked as user-provided (for skipping evalSetRun operations)
+                assert (
+                    user_provided_id in progress_reporter.user_provided_eval_set_run_ids
+                )
+
+    @pytest.mark.asyncio
+    async def test_eval_set_run_created_event_with_skip_sw_creation_false(
+        self, progress_reporter
+    ):
+        """Test that when eval_set_run_id is not provided, create_eval_set_run_sw is called."""
+        # Arrange
+        execution_id = "execution-id-67890"
+        generated_run_id = "generated-run-id-abcde"
+        event = EvalSetRunCreatedEvent(
+            execution_id=execution_id,
+            entrypoint="test.py",
+            eval_set_id="test-eval-set",
+            eval_set_run_id=None,  # When this is None, SW creation happens
+            no_of_evals=5,
+            evaluators=[],
+        )
+
+        # Mock the create_eval_set_run_sw method to return a generated ID
+        with patch.object(
+            progress_reporter,
+            "create_eval_set_run_sw",
+            new_callable=AsyncMock,
+            return_value=generated_run_id,
+        ) as mock_create:
+            with patch.object(
+                progress_reporter, "_extract_agent_snapshot"
+            ) as mock_extract:
+                mock_extract.return_value = Mock()
+                # Act
+                await progress_reporter.handle_create_eval_set_run(event)
+
+                # Assert
+                # Verify that create_eval_set_run_sw was called
+                mock_create.assert_called_once()
+                # Verify that the generated run ID was stored
+                assert (
+                    progress_reporter.eval_set_run_ids[execution_id] == generated_run_id
+                )
+
+    def test_eval_set_run_created_event_initialization_with_custom_run_id(self):
+        """Test that EvalSetRunCreatedEvent can be initialized with eval_set_run_id."""
+        # Act
+        event = EvalSetRunCreatedEvent(
+            execution_id="test-id",
+            entrypoint="main.py",
+            eval_set_id="eval-123",
+            eval_set_run_id="custom-run-id",
+            no_of_evals=10,
+            evaluators=[],
+        )
+
+        # Assert
+        assert event.execution_id == "test-id"
+        assert event.entrypoint == "main.py"
+        assert event.eval_set_id == "eval-123"
+        assert event.eval_set_run_id == "custom-run-id"
+        assert event.no_of_evals == 10
+
+    def test_eval_set_run_created_event_initialization_without_custom_run_id(self):
+        """Test that EvalSetRunCreatedEvent can be initialized without eval_set_run_id."""
+        # Act
+        event = EvalSetRunCreatedEvent(
+            execution_id="test-id",
+            entrypoint="main.py",
+            eval_set_id="eval-123",
+            no_of_evals=10,
+            evaluators=[],
+        )
+
+        # Assert
+        assert event.eval_set_run_id is None
+
+    @pytest.mark.asyncio
+    async def test_eval_set_run_update_skipped_when_user_provided(
+        self, progress_reporter
+    ):
+        """Test that eval set run updates are skipped when eval_set_run_id is user-provided."""
+        # Arrange
+        execution_id = "execution-id-12345"
+        custom_run_id = "custom-run-id-12345"
+
+        # First, create the eval set run with a user-provided ID
+        create_event = EvalSetRunCreatedEvent(
+            execution_id=execution_id,
+            entrypoint="test.py",
+            eval_set_id="test-eval-set",
+            eval_set_run_id=custom_run_id,
+            no_of_evals=5,
+            evaluators=[],
+        )
+        await progress_reporter.handle_create_eval_set_run(create_event)
+
+        # Now try to update the eval set run
+        update_event = EvalSetRunUpdatedEvent(
+            execution_id=execution_id,
+            evaluator_scores={"eval-1": 0.9},
+            success=True,
+        )
+
+        # Mock the update_eval_set_run method to ensure it's not called
+        with patch.object(
+            progress_reporter, "update_eval_set_run", new_callable=AsyncMock
+        ) as mock_update:
+            # Act
+            await progress_reporter.handle_update_eval_set_run(update_event)
+
+            # Assert
+            # Verify that update_eval_set_run was NOT called
+            mock_update.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_eval_set_run_update_called_when_system_generated(
+        self, progress_reporter
+    ):
+        """Test that eval set run updates are called when eval_set_run_id is system-generated."""
+        # Arrange
+        execution_id = "execution-id-67890"
+        generated_run_id = "generated-run-id-abcde"
+
+        # First, create the eval set run without a user-provided ID (system generates it)
+        create_event = EvalSetRunCreatedEvent(
+            execution_id=execution_id,
+            entrypoint="test.py",
+            eval_set_id="test-eval-set",
+            eval_set_run_id=None,  # System will generate
+            no_of_evals=5,
+            evaluators=[],
+        )
+
+        # Mock the create_eval_set_run_sw method to return a generated ID
+        with patch.object(
+            progress_reporter,
+            "create_eval_set_run_sw",
+            new_callable=AsyncMock,
+            return_value=generated_run_id,
+        ):
+            with patch.object(
+                progress_reporter, "_extract_agent_snapshot"
+            ) as mock_extract:
+                mock_extract.return_value = Mock()
+                await progress_reporter.handle_create_eval_set_run(create_event)
+
+        # Now try to update the eval set run
+        update_event = EvalSetRunUpdatedEvent(
+            execution_id=execution_id,
+            evaluator_scores={"eval-1": 0.9},
+            success=True,
+        )
+
+        # Mock the update_eval_set_run method to verify it IS called
+        with patch.object(
+            progress_reporter, "update_eval_set_run", new_callable=AsyncMock
+        ) as mock_update:
+            # Act
+            await progress_reporter.handle_update_eval_set_run(update_event)
+
+            # Assert
+            # Verify that update_eval_set_run WAS called
+            mock_update.assert_called_once_with(
+                generated_run_id,
+                {"eval-1": 0.9},
+                is_coded=False,
+                success=True,
+            )
+
+
+# Tests for eval set run status updates
+class TestEvalSetRunStatusUpdates:
+    """Tests for handling eval set run status updates (completed vs failed)."""
+
+    def test_update_eval_set_run_spec_with_success_coded(self, progress_reporter):
+        """Test updating eval set run spec for coded evaluators with success=True."""
+        evaluator_scores = {"eval-1": 0.9, "eval-2": 0.85}
+
+        spec = progress_reporter._update_eval_set_run_spec(
+            eval_set_run_id="test-run-id",
+            evaluator_scores=evaluator_scores,
+            is_coded=True,
+            success=True,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" in spec.endpoint
+        assert spec.json["evalSetRunId"] == "test-run-id"
+        assert spec.json["status"] == 2  # COMPLETED = 2
+
+    def test_update_eval_set_run_spec_with_failure_coded(self, progress_reporter):
+        """Test updating eval set run spec for coded evaluators with success=False."""
+        evaluator_scores = {"eval-1": 0.9, "eval-2": 0.85}
+
+        spec = progress_reporter._update_eval_set_run_spec(
+            eval_set_run_id="test-run-id",
+            evaluator_scores=evaluator_scores,
+            is_coded=True,
+            success=False,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" in spec.endpoint
+        assert spec.json["evalSetRunId"] == "test-run-id"
+        assert spec.json["status"] == 3  # FAILED = 3
+
+    def test_update_eval_set_run_spec_with_success_legacy(self, progress_reporter):
+        """Test updating eval set run spec for legacy evaluators with success=True."""
+        evaluator_scores = {"eval-1": 0.9, "eval-2": 0.85}
+
+        spec = progress_reporter._update_eval_set_run_spec(
+            eval_set_run_id="test-run-id",
+            evaluator_scores=evaluator_scores,
+            is_coded=False,
+            success=True,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" not in spec.endpoint
+        # Both coded and legacy now send payload directly at root level
+        assert "request" not in spec.json
+        assert spec.json["evalSetRunId"] == "test-run-id"
+        # Backend expects integer status
+        assert spec.json["status"] == 2  # COMPLETED
+
+    def test_update_eval_set_run_spec_with_failure_legacy(self, progress_reporter):
+        """Test updating eval set run spec for legacy evaluators with success=False."""
+        evaluator_scores = {"eval-1": 0.9, "eval-2": 0.85}
+
+        spec = progress_reporter._update_eval_set_run_spec(
+            eval_set_run_id="test-run-id",
+            evaluator_scores=evaluator_scores,
+            is_coded=False,
+            success=False,
+        )
+
+        assert spec.method == "PUT"
+        assert "coded/" not in spec.endpoint
+        # Both coded and legacy now send payload directly at root level
+        assert "request" not in spec.json
+        assert spec.json["evalSetRunId"] == "test-run-id"
+        # Backend expects integer status
+        assert spec.json["status"] == 3  # FAILED
+
+
+# Tests for agent snapshot extraction
+class TestAgentSnapshotExtraction:
+    """Tests for extracting agent snapshot with proper schema handling."""
+
+    def test_extract_agent_snapshot_reads_from_entry_points(
+        self, progress_reporter, tmp_path, monkeypatch
+    ):
+        """Test that agent snapshot reads schemas from entry points file."""
+        import os
+
+        # Create a temporary entry points file with full schemas
+        entry_points_data = {
+            "entryPoints": [
+                {
+                    "filePath": "test_agent",
+                    "uniqueId": "test-uuid",
+                    "type": "agent",
+                    "input": {
+                        "type": "object",
+                        "properties": {"query": {"type": "string"}},
+                    },
+                    "output": {
+                        "type": "object",
+                        "properties": {"response": {"type": "string"}},
+                    },
+                }
+            ]
+        }
+
+        entry_points_file = tmp_path / "entry-points.json"
+        with open(entry_points_file, "w") as f:
+            json.dump(entry_points_data, f)
+
+        # Change to the temp directory so the reporter finds the file
+        original_cwd = os.getcwd()
+        os.chdir(tmp_path)
+
+        try:
+            snapshot = progress_reporter._extract_agent_snapshot(
+                entrypoint="test_agent"
+            )
+
+            # Should read full schemas from entry points
+            assert snapshot.input_schema == {
+                "type": "object",
+                "properties": {"query": {"type": "string"}},
+            }
+            assert snapshot.output_schema == {
+                "type": "object",
+                "properties": {"response": {"type": "string"}},
+            }
+        finally:
+            os.chdir(original_cwd)
+
+    def test_extract_agent_snapshot_returns_empty_when_no_file(self, progress_reporter):
+        """Test that empty schemas are returned when entry points file doesn't exist."""
+        snapshot = progress_reporter._extract_agent_snapshot(
+            entrypoint="nonexistent_agent"
+        )
+
+        assert snapshot.input_schema == {}
+        assert snapshot.output_schema == {}
+
+    def test_extract_agent_snapshot_warns_when_entrypoint_is_none(
+        self, progress_reporter
+    ):
+        """Test that empty schemas are returned when entrypoint is None."""
+        snapshot = progress_reporter._extract_agent_snapshot(entrypoint=None)
+
+        assert snapshot.input_schema == {}
+        assert snapshot.output_schema == {}
+
+    def test_extract_agent_snapshot_warns_when_entrypoint_is_empty(
+        self, progress_reporter
+    ):
+        """Test that empty schemas are returned when entrypoint is empty string."""
+        snapshot = progress_reporter._extract_agent_snapshot(entrypoint="")
+
+        assert snapshot.input_schema == {}
+        assert snapshot.output_schema == {}
+
+    def test_extract_agent_snapshot_returns_empty_when_entrypoint_not_found(
+        self, progress_reporter, tmp_path
+    ):
+        """Test that empty schemas are returned when entrypoint is not in file."""
+        import os
+
+        # Create entry points file without the requested entrypoint
+        entry_points_data = {
+            "entryPoints": [
+                {
+                    "filePath": "other_agent",
+                    "uniqueId": "test-uuid",
+                    "type": "agent",
+                    "input": {"type": "object"},
+                    "output": {"type": "object"},
+                }
+            ]
+        }
+
+        entry_points_file = tmp_path / "entry-points.json"
+        with open(entry_points_file, "w") as f:
+            json.dump(entry_points_data, f)
+
+        original_cwd = os.getcwd()
+        os.chdir(tmp_path)
+
+        try:
+            snapshot = progress_reporter._extract_agent_snapshot(
+                entrypoint="nonexistent_agent"
+            )
+
+            assert snapshot.input_schema == {}
+            assert snapshot.output_schema == {}
+        finally:
+            os.chdir(original_cwd)
+
+    def test_agent_snapshot_serializes_with_camel_case(
+        self, progress_reporter, tmp_path
+    ):
+        """Test that agent snapshot serializes to correct JSON format with camelCase."""
+        import os
+
+        entry_points_data = {
+            "entryPoints": [
+                {
+                    "filePath": "test_agent",
+                    "uniqueId": "test-uuid",
+                    "type": "agent",
+                    "input": {"type": "object", "properties": {}},
+                    "output": {"type": "object", "properties": {}},
+                }
+            ]
+        }
+
+        entry_points_file = tmp_path / "entry-points.json"
+        with open(entry_points_file, "w") as f:
+            json.dump(entry_points_data, f)
+
+        original_cwd = os.getcwd()
+        os.chdir(tmp_path)
+
+        try:
+            snapshot = progress_reporter._extract_agent_snapshot(
+                entrypoint="test_agent"
+            )
+
+            # Serialize using pydantic
+            serialized = snapshot.model_dump(by_alias=True)
+
+            # Should have camelCase keys
+            assert "inputSchema" in serialized
+            assert "outputSchema" in serialized
+            assert serialized["inputSchema"] == {"type": "object", "properties": {}}
+            assert serialized["outputSchema"] == {"type": "object", "properties": {}}
+        finally:
+            os.chdir(original_cwd)
+
+
+# Tests for assertion properties and evaluator snapshot building
+class TestAssertionPropertiesBuilding:
+    """Tests for _build_assertion_properties and _build_evaluator_snapshot."""
+
+    def test_build_assertion_properties_with_prompt_and_model(self, progress_reporter):
+        """Test that prompt and model are included when evaluator has them."""
+        evaluator = Mock()
+        evaluator.prompt = "Evaluate the output quality"
+        evaluator.model = "gemini-2.5-pro"
+
+        props = progress_reporter._build_assertion_properties(evaluator)
+
+        assert props["prompt"] == "Evaluate the output quality"
+        assert props["model"] == "gemini-2.5-pro"
+
+    def test_build_assertion_properties_without_prompt_and_model(
+        self, progress_reporter
+    ):
+        """Test that properties are empty when evaluator lacks prompt/model."""
+        evaluator = Mock(spec=[])  # No attributes at all
+
+        props = progress_reporter._build_assertion_properties(evaluator)
+
+        assert props == {}
+
+    def test_build_assertion_properties_with_only_prompt(self, progress_reporter):
+        """Test that only prompt is included when model is absent."""
+        evaluator = Mock(spec=["prompt"])
+        evaluator.prompt = "Check similarity"
+
+        props = progress_reporter._build_assertion_properties(evaluator)
+
+        assert props["prompt"] == "Check similarity"
+        assert "model" not in props
+
+    def test_build_assertion_properties_with_only_model(self, progress_reporter):
+        """Test that only model is included when prompt is absent."""
+        evaluator = Mock(spec=["model"])
+        evaluator.model = "gpt-4o"
+
+        props = progress_reporter._build_assertion_properties(evaluator)
+
+        assert "prompt" not in props
+        assert props["model"] == "gpt-4o"
+
+    def test_build_assertion_properties_skips_non_string_prompt(
+        self, progress_reporter
+    ):
+        """Test that non-string prompt values are skipped."""
+        evaluator = Mock()
+        evaluator.prompt = 123  # Not a string
+        evaluator.model = "gpt-4o"
+
+        props = progress_reporter._build_assertion_properties(evaluator)
+
+        assert "prompt" not in props
+        assert props["model"] == "gpt-4o"
+
+    def test_build_evaluator_snapshot_with_prompt_and_model(self, progress_reporter):
+        """Test that evaluator snapshot includes prompt/model from config."""
+        config = Mock()
+        config.prompt = "Rate the response"
+        config.model = "claude-sonnet-4-20250514"
+
+        evaluator = Mock()
+        evaluator.evaluator_config = config
+
+        snapshot = progress_reporter._build_evaluator_snapshot(evaluator)
+
+        assert snapshot["prompt"] == "Rate the response"
+        assert snapshot["model"] == "claude-sonnet-4-20250514"
+
+    def test_build_evaluator_snapshot_without_config(self, progress_reporter):
+        """Test that snapshot is empty when evaluator has no config."""
+        evaluator = Mock(spec=[])  # No evaluator_config attribute
+
+        snapshot = progress_reporter._build_evaluator_snapshot(evaluator)
+
+        assert snapshot == {}
+
+    def test_build_evaluator_snapshot_config_without_prompt_model(
+        self, progress_reporter
+    ):
+        """Test that snapshot is empty when config lacks prompt/model."""
+        config = Mock(spec=["name"])  # Config without prompt/model
+        config.name = "MyEvaluator"
+
+        evaluator = Mock()
+        evaluator.evaluator_config = config
+
+        snapshot = progress_reporter._build_evaluator_snapshot(evaluator)
+
+        assert snapshot == {}
+
+    def test_build_evaluator_snapshot_skips_non_string_model(self, progress_reporter):
+        """Test that non-string model values are skipped."""
+        config = Mock()
+        config.prompt = "Evaluate this"
+        config.model = None  # Not a string
+
+        evaluator = Mock()
+        evaluator.evaluator_config = config
+
+        snapshot = progress_reporter._build_evaluator_snapshot(evaluator)
+
+        assert snapshot["prompt"] == "Evaluate this"
+
+
+class TestAgentIdRouting:
+    """Eval-set/eval-run API URLs route by AgentId, not file-source project.
+
+    For local-workspace eval runs the file-source project (UIPATH_PROJECT_ID,
+    typically the cloud debug project's GUID) differs from the logical agent
+    (UIPATH_AGENT_ID). The route URL must reflect the logical agent so backend
+    auth/ownership/telemetry don't see the per-run debug project as the agent.
+    File fetching (UiPathConfig.project_id) is unaffected.
+    """
+
+    def _make_reporter(self, monkeypatch, project_id, agent_id):
+        monkeypatch.setenv("UIPATH_URL", "https://test.uipath.com")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        if project_id is not None:
+            monkeypatch.setenv("UIPATH_PROJECT_ID", project_id)
+        else:
+            monkeypatch.delenv("UIPATH_PROJECT_ID", raising=False)
+        if agent_id is not None:
+            monkeypatch.setenv("UIPATH_AGENT_ID", agent_id)
+        else:
+            monkeypatch.delenv("UIPATH_AGENT_ID", raising=False)
+        return StudioWebProgressReporter()
+
+    def test_agent_id_used_in_url_when_both_set(self, monkeypatch):
+        reporter = self._make_reporter(
+            monkeypatch, project_id="debug-project-guid", agent_id="real-agent-id"
+        )
+        assert reporter._agent_id == "real-agent-id"
+        assert reporter._project_id == "debug-project-guid"
+
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        spec = reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=StudioWebAgentSnapshot(
+                input_schema={"type": "object"}, output_schema={"type": "object"}
+            ),
+            no_of_evals=1,
+            is_coded=False,
+        )
+        assert "/agents/real-agent-id/" in spec.endpoint
+        assert "/agents/debug-project-guid/" not in spec.endpoint
+
+    def test_agent_id_in_eval_set_run_payload(self, monkeypatch):
+        reporter = self._make_reporter(
+            monkeypatch, project_id="debug-project-guid", agent_id="real-agent-id"
+        )
+
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        spec = reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=StudioWebAgentSnapshot(
+                input_schema={"type": "object"}, output_schema={"type": "object"}
+            ),
+            no_of_evals=1,
+            is_coded=False,
+        )
+        assert spec.json["agentId"] == "real-agent-id"
+
+    def test_falls_back_to_project_id_when_agent_id_unset(self, monkeypatch):
+        reporter = self._make_reporter(
+            monkeypatch, project_id="cloud-project-id", agent_id=None
+        )
+        assert reporter._agent_id == "cloud-project-id"
+
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        spec = reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=StudioWebAgentSnapshot(
+                input_schema={"type": "object"}, output_schema={"type": "object"}
+            ),
+            no_of_evals=1,
+            is_coded=False,
+        )
+        assert "/agents/cloud-project-id/" in spec.endpoint
+
+
+class TestProjectFilesSourcePropagation:
+    """Reporter must propagate UIPATH_PROJECT_FILES_SOURCE to backend rows.
+
+    Backend filters listings by `projectFilesSource` (Local=1, Cloud=0). Without
+    the SDK setting it on POST/PUT payloads and GET query params, every row
+    lands as Cloud and the UI's `?projectFilesSource=1` filter never matches
+    local-workspace runs.
+    """
+
+    def _make_reporter(self, monkeypatch, project_files_source):
+        monkeypatch.setenv("UIPATH_URL", "https://test.uipath.com")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test-token")
+        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
+        monkeypatch.setenv("UIPATH_PROJECT_ID", "test-project-id")
+        if project_files_source is not None:
+            monkeypatch.setenv("UIPATH_PROJECT_FILES_SOURCE", project_files_source)
+        else:
+            monkeypatch.delenv("UIPATH_PROJECT_FILES_SOURCE", raising=False)
+        return StudioWebProgressReporter()
+
+    @pytest.mark.parametrize(
+        "raw,expected",
+        [("Local", 1), ("local", 1), ("Cloud", 0), ("cloud", 0), ("1", 1), ("0", 0)],
+    )
+    def test_resolves_env_var_to_int(self, monkeypatch, raw, expected):
+        reporter = self._make_reporter(monkeypatch, raw)
+        assert reporter._project_files_source == expected
+
+    def test_returns_none_when_unset_or_garbage(self, monkeypatch):
+        reporter = self._make_reporter(monkeypatch, None)
+        assert reporter._project_files_source is None
+        reporter2 = self._make_reporter(monkeypatch, "Banana")
+        assert reporter2._project_files_source is None
+
+    def test_post_eval_set_run_payload_carries_source(self, monkeypatch):
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        reporter = self._make_reporter(monkeypatch, "Local")
+        spec = reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=StudioWebAgentSnapshot(
+                input_schema={"type": "object"}, output_schema={"type": "object"}
+            ),
+            no_of_evals=1,
+            is_coded=False,
+        )
+        assert spec.json["projectFilesSource"] == 1
+
+    def test_post_eval_run_payload_carries_source(self, monkeypatch):
+        from uipath.eval.models.evaluation_set import EvaluationItem
+
+        reporter = self._make_reporter(monkeypatch, "Local")
+        item = EvaluationItem(
+            id="11111111-1111-1111-1111-111111111111",
+            name="t",
+            inputs={},
+            evaluation_criterias={},
+        )
+        spec = reporter._create_eval_run_spec(
+            eval_item=item, eval_set_run_id="run-1", is_coded=False
+        )
+        assert spec.json["projectFilesSource"] == 1
+
+    def test_put_eval_run_payload_carries_source(self, monkeypatch):
+        reporter = self._make_reporter(monkeypatch, "Local")
+        spec = reporter._update_eval_run_spec(
+            assertion_runs=[],
+            evaluator_scores=[],
+            eval_run_id="run-1",
+            actual_output={},
+            execution_time=1.0,
+            success=True,
+            is_coded=False,
+        )
+        assert spec.json["projectFilesSource"] == 1
+
+    def test_put_coded_eval_run_payload_carries_source(self, monkeypatch):
+        reporter = self._make_reporter(monkeypatch, "Local")
+        spec = reporter._update_coded_eval_run_spec(
+            evaluator_runs=[],
+            evaluator_scores=[],
+            eval_run_id="run-1",
+            actual_output={},
+            execution_time=1.0,
+            success=True,
+            is_coded=True,
+        )
+        assert spec.json["projectFilesSource"] == 1
+
+    def test_put_eval_set_run_payload_carries_source(self, monkeypatch):
+        reporter = self._make_reporter(monkeypatch, "Local")
+        spec = reporter._update_eval_set_run_spec(
+            eval_set_run_id="set-run-1",
+            evaluator_scores={},
+            is_coded=False,
+            success=True,
+        )
+        assert spec.json["projectFilesSource"] == 1
+
+    def test_get_eval_runs_query_carries_source(self, monkeypatch):
+        reporter = self._make_reporter(monkeypatch, "Local")
+        spec = reporter._get_eval_runs_spec(
+            eval_set_id="set-1",
+            eval_set_run_id="run-1",
+            evaluation_id=None,
+            is_coded=False,
+        )
+        assert spec.params == {"projectFilesSource": 1}
+
+    def test_unset_source_omits_field_from_payloads(self, monkeypatch):
+        from uipath._cli._evals._progress_reporter import StudioWebAgentSnapshot
+
+        reporter = self._make_reporter(monkeypatch, None)
+        spec = reporter._create_eval_set_run_spec(
+            eval_set_id="test-eval-set",
+            agent_snapshot=StudioWebAgentSnapshot(
+                input_schema={"type": "object"}, output_schema={"type": "object"}
+            ),
+            no_of_evals=1,
+            is_coded=False,
+        )
+        assert "projectFilesSource" not in spec.json
diff --git a/packages/uipath/tests/cli/eval/test_span_persistence.py b/packages/uipath/tests/cli/eval/test_span_persistence.py
new file mode 100644
index 000000000..96bf3ca74
--- /dev/null
+++ b/packages/uipath/tests/cli/eval/test_span_persistence.py
@@ -0,0 +1,287 @@
+"""Tests for span persistence: serialization roundtrip and processor fallback.
+
+Tests cover:
+1. serialize_span / deserialize_span roundtrip preserves all span data
+2. ExecutionSpanProcessor.on_start() fallback to execution_id_context ContextVar
+"""
+
+from typing import Any
+from unittest.mock import Mock, patch
+
+from opentelemetry.sdk.trace import Event, ReadableSpan, Span
+from opentelemetry.sdk.trace.export import SpanExporter
+from opentelemetry.trace import SpanContext, SpanKind, Status, StatusCode, TraceFlags
+
+from uipath.eval._execution_context import ExecutionSpanCollector, execution_id_context
+from uipath.eval.runtime._spans import (
+    deserialize_span,
+    serialize_span,
+)
+
+
+def _make_span_context(
+    trace_id: int = 0xABCDEF1234567890, span_id: int = 0x1234567890ABCDEF
+) -> SpanContext:
+    return SpanContext(
+        trace_id=trace_id,
+        span_id=span_id,
+        is_remote=False,
+        trace_flags=TraceFlags(0x01),
+    )
+
+
+def _make_full_span() -> ReadableSpan:
+    """Create a ReadableSpan with all fields populated."""
+    return ReadableSpan(
+        name="test-span",
+        context=_make_span_context(),
+        parent=_make_span_context(trace_id=0xABCDEF1234567890, span_id=0xFEDCBA),
+        attributes={
+            "execution.id": "exec-123",
+            "span_type": "evaluation",
+            "score": 0.95,
+            "count": 42,
+            "active": True,
+        },
+        events=[
+            Event(
+                name="test-event",
+                attributes={"key": "value", "num": 10},
+                timestamp=1000000000,
+            ),
+        ],
+        status=Status(StatusCode.OK),
+        start_time=5000000000,
+        end_time=6000000000,
+        kind=SpanKind.INTERNAL,
+    )
+
+
+# --- Serialization Roundtrip Tests ---
+
+
+class TestSerializationRoundtrip:
+    """Tests that serialize_span -> deserialize_span preserves all span data."""
+
+    def test_roundtrip_preserves_name(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.name == "test-span"
+
+    def test_roundtrip_preserves_context(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.context is not None
+        assert span.context is not None
+        assert result.context.trace_id == span.context.trace_id
+        assert result.context.span_id == span.context.span_id
+        assert int(result.context.trace_flags) == int(span.context.trace_flags)
+
+    def test_roundtrip_preserves_parent(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.parent is not None
+        assert span.parent is not None
+        assert result.parent.trace_id == span.parent.trace_id
+        assert result.parent.span_id == span.parent.span_id
+
+    def test_roundtrip_preserves_attributes(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.attributes is not None
+        assert result.attributes["execution.id"] == "exec-123"
+        assert result.attributes["span_type"] == "evaluation"
+        assert result.attributes["score"] == 0.95
+        assert result.attributes["count"] == 42
+        assert result.attributes["active"] is True
+
+    def test_roundtrip_preserves_tuple_attributes(self) -> None:
+        """Tuples are converted to lists during serialization."""
+        span = ReadableSpan(
+            name="tuple-span",
+            attributes={"tags": ("a", "b", "c")},
+        )
+        result = deserialize_span(serialize_span(span))
+        assert result.attributes is not None
+        assert result.attributes["tags"] == ["a", "b", "c"]
+
+    def test_roundtrip_preserves_events(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert len(result.events) == 1
+        event = result.events[0]
+        assert event.name == "test-event"
+        assert event.attributes is not None
+        assert event.attributes["key"] == "value"
+        assert event.attributes["num"] == 10
+        assert event.timestamp == 1000000000
+
+    def test_roundtrip_preserves_status(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.status.status_code == StatusCode.OK
+
+    def test_roundtrip_preserves_error_status(self) -> None:
+        span = ReadableSpan(
+            name="error-span",
+            status=Status(StatusCode.ERROR, "something failed"),
+        )
+        result = deserialize_span(serialize_span(span))
+        assert result.status.status_code == StatusCode.ERROR
+        assert result.status.description == "something failed"
+
+    def test_roundtrip_preserves_timestamps(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.start_time == 5000000000
+        assert result.end_time == 6000000000
+
+    def test_roundtrip_preserves_kind(self) -> None:
+        span = _make_full_span()
+        result = deserialize_span(serialize_span(span))
+        assert result.kind == SpanKind.INTERNAL
+
+    def test_roundtrip_span_with_no_parent(self) -> None:
+        span = ReadableSpan(
+            name="orphan-span",
+            context=_make_span_context(),
+            parent=None,
+            attributes={"key": "val"},
+        )
+        result = deserialize_span(serialize_span(span))
+        assert result.parent is None
+        assert result.context is not None
+
+    def test_roundtrip_span_with_no_events(self) -> None:
+        span = ReadableSpan(
+            name="no-events-span",
+            attributes={"key": "val"},
+        )
+        result = deserialize_span(serialize_span(span))
+        assert len(result.events) == 0
+
+    def test_roundtrip_span_with_no_attributes(self) -> None:
+        span = ReadableSpan(name="minimal-span")
+        result = deserialize_span(serialize_span(span))
+        assert result.name == "minimal-span"
+
+    def test_roundtrip_multiple_events(self) -> None:
+        span = ReadableSpan(
+            name="multi-event-span",
+            events=[
+                Event(name="event-1", attributes={"a": 1}, timestamp=100),
+                Event(name="event-2", attributes={"b": 2}, timestamp=200),
+                Event(name="event-3", attributes={}, timestamp=300),
+            ],
+        )
+        result = deserialize_span(serialize_span(span))
+        assert len(result.events) == 3
+        assert result.events[0].name == "event-1"
+        assert result.events[1].name == "event-2"
+        assert result.events[2].name == "event-3"
+
+
+# --- ExecutionSpanProcessor Fallback Tests ---
+
+
+class TestExecutionSpanProcessorFallback:
+    """Tests for ExecutionSpanProcessor.on_start() execution_id_context fallback."""
+
+    def _create_processor(self) -> tuple[Any, ExecutionSpanCollector, Mock]:
+        from uipath.eval.runtime._exporters import ExecutionSpanProcessor
+
+        mock_exporter = Mock(spec=SpanExporter)
+        collector = ExecutionSpanCollector()
+        processor = ExecutionSpanProcessor(mock_exporter, collector)
+        return processor, collector, mock_exporter
+
+    def _create_mock_span(self, attributes: dict[str, Any] | None = None) -> Mock:
+        span = Mock(spec=Span)
+        span.attributes = attributes or {}
+        return span
+
+    @patch("uipath.eval.runtime._exporters.UiPathExecutionBatchTraceProcessor.on_start")
+    def test_span_with_execution_id_added_to_collector(
+        self, mock_super_on_start: Mock
+    ) -> None:
+        processor, collector, _ = self._create_processor()
+        span = self._create_mock_span({"execution.id": "exec-123"})
+
+        processor.on_start(span)
+
+        spans = collector.get_spans("exec-123")
+        assert len(spans) == 1
+        assert spans[0] is span
+
+    @patch("uipath.eval.runtime._exporters.UiPathExecutionBatchTraceProcessor.on_start")
+    def test_span_without_execution_id_not_added(
+        self, mock_super_on_start: Mock
+    ) -> None:
+        processor, collector, _ = self._create_processor()
+        span = self._create_mock_span({"span_type": "agent"})
+
+        # Ensure context var is empty
+        token = execution_id_context.set(None)
+        try:
+            processor.on_start(span)
+        finally:
+            execution_id_context.reset(token)
+
+        assert collector.get_spans("") == []
+
+    @patch("uipath.eval.runtime._exporters.UiPathExecutionBatchTraceProcessor.on_start")
+    def test_fallback_sets_execution_id_from_context_var(
+        self, mock_super_on_start: Mock
+    ) -> None:
+        """Core bug fix test: NonRecordingSpan parent doesn't propagate execution.id,
+        so the processor should fall back to execution_id_context."""
+        processor, collector, _ = self._create_processor()
+        span = self._create_mock_span({"span_type": "agent"})
+
+        # After set_attribute, the mock's attributes dict should reflect the change
+        def side_effect_set_attr(key: str, value: Any) -> None:
+            span.attributes[key] = value
+
+        span.set_attribute = Mock(side_effect=side_effect_set_attr)
+
+        token = execution_id_context.set("exec-from-context")
+        try:
+            processor.on_start(span)
+        finally:
+            execution_id_context.reset(token)
+
+        # Verify set_attribute was called with the context var value
+        span.set_attribute.assert_called_once_with("execution.id", "exec-from-context")
+
+        # Verify span was added to collector
+        spans = collector.get_spans("exec-from-context")
+        assert len(spans) == 1
+        assert spans[0] is span
+
+    @patch("uipath.eval.runtime._exporters.UiPathExecutionBatchTraceProcessor.on_start")
+    def test_no_fallback_when_context_var_empty(
+        self, mock_super_on_start: Mock
+    ) -> None:
+        processor, collector, _ = self._create_processor()
+        span = self._create_mock_span({"span_type": "agent"})
+
+        token = execution_id_context.set(None)
+        try:
+            processor.on_start(span)
+        finally:
+            execution_id_context.reset(token)
+
+        # Span should not have been added anywhere
+        span.set_attribute.assert_not_called()
+
+    @patch("uipath.eval.runtime._exporters.UiPathExecutionBatchTraceProcessor.on_start")
+    def test_span_with_non_string_execution_id_not_added(
+        self, mock_super_on_start: Mock
+    ) -> None:
+        processor, collector, _ = self._create_processor()
+        span = self._create_mock_span({"execution.id": 12345})
+
+        processor.on_start(span)
+
+        # Non-string execution.id should not be added to collector
+        assert collector.get_spans("12345") == []
diff --git a/packages/uipath/tests/cli/evaluators/test_json_similarity_evaluator.py b/packages/uipath/tests/cli/evaluators/test_json_similarity_evaluator.py
new file mode 100644
index 000000000..0b74ae07c
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_json_similarity_evaluator.py
@@ -0,0 +1,243 @@
+"""Tests for JsonSimilarityEvaluator.
+
+Covers exact matches, numeric tolerance, string similarity, and nested structures.
+"""
+
+import json
+from typing import Any
+
+import pytest
+
+from uipath.eval.evaluators import LegacyJsonSimilarityEvaluator
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params() -> dict[str, Any]:
+    """Create base parameters for faithfulness evaluator."""
+    return {
+        "id": "json-sim",
+        "category": LegacyEvaluatorCategory.Deterministic,
+        "type": LegacyEvaluatorType.JsonSimilarity,
+        "name": "JSON Similarity",
+        "description": "Compares JSON structures",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": "*",
+    }
+
+
+class TestJsonSimilarityEvaluator:
+    @pytest.mark.asyncio
+    async def test_json_similarity_exact_score_1(self) -> None:
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_base_params())
+        expected_json = """
+            {
+                "user": {
+                    "name": "Alice",
+                    "age": 30,
+                    "address": {
+                        "city": "New York",
+                        "zip": "10001"
+                    }
+                },
+                "active": true
+            }
+            """
+
+        actual_json = """
+            {
+                "user": {
+                    "name": "Alicia",
+                    "age": 28,
+                    "address": {
+                        "city": "New York",
+                        "zip": "10002"
+                    }
+                },
+                "active": false,
+                "extraField": "Ignored"
+            }
+            """
+
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={},
+                agent_trace=[],
+                agent_output=json.loads(actual_json),
+            ),
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=json.loads(expected_json),
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score == 68.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_exact_score_2(self) -> None:
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_base_params())
+        expected_json = """
+        {
+            "users": [
+                { "name": "Alice", "age": 25 },
+                { "name": "Bob", "age": 30 }
+            ]
+        }
+        """
+
+        actual_json = """
+        {
+            "users": [
+                { "name": "Alice", "age": 24 },
+                { "name": "Robert", "age": 30 }
+            ],
+            "extraField": "Ignored"
+        }
+        """
+
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={},
+                agent_trace=[],
+                agent_output=json.loads(actual_json),
+            ),
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=json.loads(expected_json),
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score >= 82.333
+        assert result.score <= 82.3334
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_exact_score_3(self) -> None:
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_base_params())
+        expected_json = """
+        {
+            "name": "Alice",
+            "age": 30,
+            "active": true
+        }
+        """
+
+        actual_json = """
+        {
+            "name": "Alice",
+            "age": "30",
+            "active": "true"
+        }
+        """
+
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={},
+                agent_trace=[],
+                agent_output=json.loads(actual_json),
+            ),
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=json.loads(expected_json),
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score >= 33.333
+        assert result.score <= 33.3334
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_exact_score_4(self) -> None:
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_base_params())
+        expected_json = """
+        {
+          "user": {
+            "name": "Alice Johnson",
+            "age": 30,
+            "active": true,
+            "address": {
+              "street": "123 Main St",
+              "city": "Metropolis",
+              "zip": 90210
+            }
+          },
+          "preferences": {
+            "newsletter": true,
+            "languages": ["en", "fr", "es"]
+          },
+          "metrics": {
+            "visits": 100,
+            "ratio": 0,
+            "growth": 1.0
+          },
+          "posts": [
+            { "title": "Hello World", "tags": ["intro", "welcome"] },
+            { "title": "Deep Dive", "tags": ["advanced", "json", "parsing"] }
+          ],
+          "permissions": { "admin": false, "editor": true, "viewer": true },
+          "notes": null,
+          "bio": "Café au lait",
+          "scores": [10, 9.5, "N/A", true],
+          "settings": {
+            "features": [
+              { "key": "A", "enabled": true },
+              { "key": "B", "enabled": false }
+            ]
+          }
+        }
+        """
+
+        actual_json = """
+        {
+          "user": {
+            "name": "Alice Johnson",
+            "age": "30",
+            "active": "true",
+            "address": {
+              "street": "123 Main St",
+              "city": "Metropolis",
+              "zip": "90210"
+            }
+          },
+          "preferences": {
+            "newsletter": "yes",
+            "languages": ["en", "es", "fr", "de"]
+          },
+          "metrics": {
+            "visits": 98,
+            "ratio": 1e-11,
+            "growth": 0.9
+          },
+          "posts": [
+            { "title": "Hello-World", "tags": ["intro"] },
+            { "title": "Deep  Dive", "tags": ["advanced", "json"] }
+          ],
+          "permissions": { "admin": "false", "editor": true },
+          "bio": "Cafe au lait",
+          "scores": [10, "9.5", "NA", "true"],
+          "settings": {
+            "features": [
+              { "key": "B", "enabled": "false" },
+              { "key": "A", "enabled": "true" }
+            ]
+          },
+          "extra": { "debug": true }
+        }
+        """
+
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={},
+                agent_trace=[],
+                agent_output=json.loads(actual_json),
+            ),
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=json.loads(expected_json),
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score == 43.24977043158861
diff --git a/packages/uipath/tests/cli/evaluators/test_legacy_context_precision_evaluator.py b/packages/uipath/tests/cli/evaluators/test_legacy_context_precision_evaluator.py
new file mode 100644
index 000000000..19723eb25
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_legacy_context_precision_evaluator.py
@@ -0,0 +1,321 @@
+"""Tests for LegacyContextPrecisionEvaluator.
+
+Tests span extraction, chunk normalization, and LLM evaluation.
+"""
+
+import json
+from types import MappingProxyType
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from uipath.eval.evaluators import LegacyContextPrecisionEvaluator
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params() -> dict[str, Any]:
+    """Create base parameters for context precision evaluator."""
+    return {
+        "id": "context-precision",
+        "category": LegacyEvaluatorCategory.LlmAsAJudge,
+        "type": LegacyEvaluatorType.ContextPrecision,
+        "name": "Context Precision",
+        "description": "Evaluates context chunk relevance",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": "*",
+    }
+
+
+@pytest.fixture(autouse=True)
+def mock_uipath_platform():
+    """Fixture to mock UiPath platform for all tests."""
+    with patch("uipath.platform.UiPath") as mock_uipath_class:
+        mock_uipath_instance = mock_uipath_class.return_value
+        mock_uipath_instance.llm = AsyncMock()
+        yield mock_uipath_class
+
+
+@pytest.fixture
+def evaluator_with_mocked_llm():
+    """Fixture to create evaluator with mocked LLM service."""
+    evaluator = LegacyContextPrecisionEvaluator(
+        **_make_base_params(),
+        model="gpt-4.1-2025-04-14",
+    )
+    evaluator.llm = AsyncMock()
+    return evaluator
+
+
+def _make_mock_span(input_query: str, output_chunks: list[str]):
+    """Create a mock span with context grounding data."""
+
+    class MockSpan:
+        def __init__(self):
+            self.attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": "RETRIEVER",
+                    "input.mime_type": "text/plain",
+                    "input.value": input_query,
+                    "output.value": json.dumps(
+                        {
+                            "documents": [
+                                {"id": str(i), "text": chunk}
+                                for i, chunk in enumerate(output_chunks)
+                            ]
+                        }
+                    ),
+                    "output.mime_type": "application/json",
+                }
+            )
+
+    return MockSpan()
+
+
+class TestLegacyContextPrecisionEvaluator:
+    """Test suite for LegacyContextPrecisionEvaluator."""
+
+    @pytest.mark.asyncio
+    async def test_span_extraction_with_valid_data(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test extraction of context groundings from spans."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create mock span with context grounding data
+        span = _make_mock_span(
+            input_query="construction industry",
+            output_chunks=["Building materials", "Safety codes", "Project management"],
+        )
+
+        # Extract context groundings
+        groundings = evaluator._extract_context_groundings([span])
+
+        assert len(groundings) == 1
+        assert groundings[0]["query"] == "construction industry"
+        assert len(groundings[0]["chunks"]) == 3
+        # Chunks are JSON-serialized because they come from the output
+        assert any("Building materials" in chunk for chunk in groundings[0]["chunks"])
+
+    @pytest.mark.asyncio
+    async def test_span_extraction_skips_invalid_spans(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that spans without proper structure are skipped."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create spans: one valid, one invalid
+        valid_span = _make_mock_span(
+            input_query="test query",
+            output_chunks=["chunk1"],
+        )
+
+        class InvalidSpan:
+            attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": "RETRIEVER",
+                    # Missing input.value and output.value
+                }
+            )
+
+        groundings = evaluator._extract_context_groundings([valid_span, InvalidSpan()])
+
+        assert len(groundings) == 1
+        assert groundings[0]["query"] == "test query"
+
+    @pytest.mark.asyncio
+    async def test_chunk_normalization(self, evaluator_with_mocked_llm) -> None:
+        """Test normalization of various chunk formats."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Test list of strings
+        chunks = evaluator._normalize_chunks(["chunk1", "chunk2"])
+        assert len(chunks) == 2
+        assert all(isinstance(c, str) for c in chunks)
+
+        # Test list of dicts
+        chunks = evaluator._normalize_chunks(
+            [
+                {"id": "1", "text": "content1"},
+                {"id": "2", "text": "content2"},
+            ]
+        )
+        assert len(chunks) == 2
+        assert all(isinstance(c, str) for c in chunks)
+
+        # Test single string
+        chunks = evaluator._normalize_chunks("single chunk")
+        assert len(chunks) == 1
+        assert chunks[0] == "single chunk"
+
+    @pytest.mark.asyncio
+    async def test_evaluation_with_mocked_llm(self, evaluator_with_mocked_llm) -> None:
+        """Test evaluation logic with mocked LLM."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create mock spans
+        span = _make_mock_span(
+            input_query="python programming",
+            output_chunks=[
+                "Python syntax guide",
+                "Python libraries overview",
+                "JavaScript fundamentals",
+            ],
+        )
+
+        # Extract context groundings from the span
+        groundings = evaluator._extract_context_groundings([span])
+        assert len(groundings) == 1
+        assert groundings[0]["query"] == "python programming"
+        assert len(groundings[0]["chunks"]) == 3
+
+        # Test the grounding evaluation with mocked LLM response
+        mock_llm_response = {
+            "relevancies": [
+                {"relevancy_score": 95},
+                {"relevancy_score": 75},
+                {"relevancy_score": 45},
+            ]
+        }
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_llm_response
+
+            # Evaluate the context grounding
+            scores = await evaluator._evaluate_context_grounding(
+                groundings[0]["query"], groundings[0]["chunks"]
+            )
+
+            assert scores == [95, 75, 45]
+            assert abs(sum(scores) / len(scores) - 71.66666667) < 0.01
+
+    @pytest.mark.asyncio
+    async def test_evaluation_with_no_context_groundings(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation when no context groundings are found."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create empty agent execution (no spans)
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score == 0.0
+        assert "no context grounding" in result.details.lower()
+
+    @pytest.mark.asyncio
+    async def test_evaluation_multiple_context_calls(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation logic with multiple context grounding calls."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create two mock spans
+        span1 = _make_mock_span(
+            input_query="query 1",
+            output_chunks=["chunk1a", "chunk1b"],
+        )
+        span2 = _make_mock_span(
+            input_query="query 2",
+            output_chunks=["chunk2a", "chunk2b", "chunk2c"],
+        )
+
+        # Extract context groundings from the spans
+        groundings = evaluator._extract_context_groundings([span1, span2])
+        assert len(groundings) == 2
+        assert groundings[0]["query"] == "query 1"
+        assert groundings[1]["query"] == "query 2"
+
+        # Mock the LLM responses
+        mock_llm_response_1 = {
+            "relevancies": [{"relevancy_score": 90}, {"relevancy_score": 80}]
+        }
+        mock_llm_response_2 = {
+            "relevancies": [
+                {"relevancy_score": 85},
+                {"relevancy_score": 75},
+                {"relevancy_score": 65},
+            ]
+        }
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            # Return different responses for each call
+            mock_llm.side_effect = [mock_llm_response_1, mock_llm_response_2]
+
+            # Evaluate both context groundings
+            scores1 = await evaluator._evaluate_context_grounding(
+                groundings[0]["query"], groundings[0]["chunks"]
+            )
+            scores2 = await evaluator._evaluate_context_grounding(
+                groundings[1]["query"], groundings[1]["chunks"]
+            )
+
+            # Verify individual scores
+            assert scores1 == [90, 80]
+            assert scores2 == [85, 75, 65]
+
+            # Verify means
+            mean1 = sum(scores1) / len(scores1)  # 85
+            mean2 = sum(scores2) / len(scores2)  # 75
+            overall_mean = (mean1 + mean2) / 2  # 80
+            assert overall_mean == 80.0
+
+    @pytest.mark.asyncio
+    async def test_span_extraction_handles_json_parse_errors(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that spans with invalid JSON are skipped."""
+        evaluator = evaluator_with_mocked_llm
+
+        class BadJsonSpan:
+            attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": "RETRIEVER",
+                    "input.value": "test query",
+                    "output.value": "not valid json",
+                }
+            )
+
+        # Should not raise, should skip the span
+        groundings = evaluator._extract_context_groundings([BadJsonSpan()])
+        assert len(groundings) == 0
+
+    @pytest.mark.asyncio
+    async def test_serialization_of_dict_chunks(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that dict chunks are properly serialized."""
+        evaluator = evaluator_with_mocked_llm
+
+        chunks = evaluator._normalize_chunks(
+            [
+                {"title": "Document 1", "content": "Some content"},
+                {"title": "Document 2", "content": "More content"},
+            ]
+        )
+
+        assert len(chunks) == 2
+        assert all(isinstance(c, str) for c in chunks)
+        # Should be JSON serialized
+        assert '"title"' in chunks[0] or '"content"' in chunks[0]
diff --git a/packages/uipath/tests/cli/evaluators/test_legacy_csv_exact_match_evaluator.py b/packages/uipath/tests/cli/evaluators/test_legacy_csv_exact_match_evaluator.py
new file mode 100644
index 000000000..1fd2f4f9f
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_legacy_csv_exact_match_evaluator.py
@@ -0,0 +1,648 @@
+"""Tests for LegacyCSVExactMatchEvaluator.
+
+Tests CSV column exact matching functionality including:
+- Single and multiple column comparisons
+- Case-insensitive column names
+- Various CSV formats
+- Job attachment support
+- Line-by-line evaluation
+"""
+
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.evaluators.legacy_csv_exact_match_evaluator import (
+    LegacyCSVExactMatchEvaluator,
+)
+from uipath.eval.evaluators.output_evaluator import LineByLineEvaluationDetails
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params(target_sub_output_key: str = "Name") -> dict[str, Any]:
+    """Create base parameters for CSV evaluator."""
+    return {
+        "id": "csv_exact_match",
+        "category": LegacyEvaluatorCategory.Deterministic,
+        "type": LegacyEvaluatorType.CSVColumnExactMatch,
+        "name": "CSVExactMatch",
+        "description": "Evaluates exact match of CSV columns",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetSubOutputKey": target_sub_output_key,
+    }
+
+
+@pytest.fixture
+def evaluator_single_column():
+    """Fixture to create evaluator with single column."""
+    with patch("uipath.platform.UiPath"):
+        return LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name")
+        )
+
+
+@pytest.fixture
+def evaluator_multiple_columns():
+    """Fixture to create evaluator with multiple columns."""
+    with patch("uipath.platform.UiPath"):
+        return LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name,Age")
+        )
+
+
+class TestLegacyCSVExactMatchEvaluator:
+    """Test suite for LegacyCSVExactMatchEvaluator."""
+
+    @pytest.mark.asyncio
+    async def test_single_column_match(self, evaluator_single_column) -> None:
+        """Test exact match with single column."""
+        csv_content = "Name,Age,City\nJohn,25,Paris"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_multiple_columns_match(self, evaluator_multiple_columns) -> None:
+        """Test exact match with multiple columns."""
+        csv_content = "Name,Age,City\nJohn,25,Paris"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator_multiple_columns.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_column_value_differs(self, evaluator_single_column) -> None:
+        """Test when column values differ."""
+        actual_csv = "Name,Age,City\nJohn,25,Paris"
+        expected_csv = "Name,Age,City\nJane,25,Paris"  # Different name
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=actual_csv,
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": expected_csv},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_case_insensitive_column_names(self) -> None:
+        """Test case-insensitive column name matching."""
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key="NAME,age")
+            )
+
+        csv_content = "name,AGE,CiTy\nJohn,25,Paris"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_json_element_with_content_property(
+        self, evaluator_single_column
+    ) -> None:
+        """Test handling dict with 'content' property."""
+        csv_content = "Name,Age\nJohn,25"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"content": csv_content},
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_empty_target_sub_output_key_raises_error(self) -> None:
+        """Test that empty targetSubOutputKey raises ValueError."""
+        with patch("uipath.platform.UiPath"):
+            with pytest.raises(
+                ValueError, match="target_sub_output_key must not be empty"
+            ):
+                LegacyCSVExactMatchEvaluator(
+                    **_make_base_params(target_sub_output_key="")
+                )
+
+    @pytest.mark.asyncio
+    async def test_column_not_found_returns_error(
+        self, evaluator_single_column
+    ) -> None:
+        """Test that missing column returns error result."""
+        csv_content = "Name,Age\nJohn,25"
+
+        # Create evaluator with non-existent column
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key="NonExistentColumn")
+            )
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert isinstance(result.details, str)
+        assert "Missing columns: NonExistentColumn" in result.details
+
+    @pytest.mark.asyncio
+    async def test_empty_csv_returns_error(self, evaluator_single_column) -> None:
+        """Test that empty CSV returns error result."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="",
+        )
+
+        result = await evaluator_single_column.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": "Name,Age\nJohn,25"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert "CSV output is null or empty" in result.details
+
+    @pytest.mark.asyncio
+    async def test_complex_csv_with_quotes_and_commas(
+        self, evaluator_multiple_columns
+    ) -> None:
+        """Test handling CSV with quotes and commas in values."""
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key="Name,Description")
+            )
+
+        csv_content = (
+            'Name,Description,Status\n"John, Jr.","Software Engineer, Senior","Active"'
+        )
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_empty_values(self) -> None:
+        """Test handling empty column values."""
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key="Age")
+            )
+
+        csv_content = "Name,Age,City\nJohn,,Paris"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_no_data_rows_returns_error(self, evaluator_single_column) -> None:
+        """Test that CSV with headers but no data rows returns error result."""
+        csv_content = "Name,Age"  # Headers only, no data
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator_single_column.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert "CSV must contain one data row" in result.details
+
+    @pytest.mark.asyncio
+    async def test_whitespace_only_target_columns_returns_error(self) -> None:
+        """Test that whitespace-only targetSubOutputKey returns error result."""
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key=" , , ")
+            )
+
+        csv_content = "Name,Age\nJohn,25"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert isinstance(result.details, str)
+        assert "At least one target column must be specified" in result.details
+
+    @pytest.mark.asyncio
+    async def test_expected_output_without_content_property_returns_error(
+        self, evaluator_single_column
+    ) -> None:
+        """Test that expected output without 'content' property returns error result."""
+        csv_content = "Name,Age\nJohn,25"
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=csv_content,
+        )
+
+        # Expected output as empty string
+        result = await evaluator_single_column.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="",
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert "CSV output is null or empty" in result.details
+
+    # Note: Python's csv module is more lenient than C# CsvHelper and handles most
+    # malformed CSVs gracefully. Invalid CSV errors are rare in practice.
+
+    @pytest.mark.asyncio
+    async def test_actual_missing_column_in_comparison(self) -> None:
+        """Test when actual CSV is missing a column that's in expected."""
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyCSVExactMatchEvaluator(
+                **_make_base_params(target_sub_output_key="Name,Age")
+            )
+
+        actual_csv = "Name\nJohn"  # Missing Age column
+        expected_csv = "Name,Age\nJohn,25"
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=actual_csv,
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": expected_csv},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should return error result
+        assert isinstance(result.details, str)
+        assert "Missing columns: Age" in result.details
+
+    @pytest.mark.asyncio
+    async def test_whitespace_trimming_in_values(self, evaluator_single_column) -> None:
+        """Test that whitespace is trimmed from column values."""
+        actual_csv = "Name,Age\n  John  ,25"
+        expected_csv = "Name,Age\nJohn,25"
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=actual_csv,
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": expected_csv},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_case_sensitive_value_comparison(
+        self, evaluator_single_column
+    ) -> None:
+        """Test that value comparison is case-sensitive."""
+        actual_csv = "Name,Age\nJohn,25"
+        expected_csv = "Name,Age\njohn,25"  # Different case
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=actual_csv,
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": expected_csv},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_extra_columns_are_ignored(self, evaluator_single_column) -> None:
+        """Test that extra columns not in targetSubOutputKey are ignored."""
+        actual_csv = "Name,Age,City,Country\nJohn,25,Paris,France"
+        expected_csv = "Name,Age,City\nJohn,30,London"  # Different Age and City, but we only check Name
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=actual_csv,
+        )
+
+        result = await evaluator_single_column.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": expected_csv},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Should match because we only check the "Name" column
+        assert result.score is True
+
+
+# Line-by-line evaluation tests
+# CSV evaluator overrides _evaluate_line_by_line to preserve headers
+@pytest.mark.asyncio
+async def test_line_by_line_all_match():
+    """Test line-by-line evaluation when all CSV data rows match."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    csv_content = "Name,Age\nJohn,25\nJane,30\nBob,35"
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output=csv_content,
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output={"content": csv_content},
+            expected_agent_behavior="",
+        ),
+    )
+
+    # All 3 data rows match, so score should be 1.0
+    assert result.score == 1.0
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    # total_lines counts data rows only (not header)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_partial_match():
+    """Test line-by-line evaluation with partial matches."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    actual_csv = "Name,Age\nJohn,25\nDifferent,30\nBob,35"
+    expected_csv = "Name,Age\nJohn,25\nJane,30\nBob,35"
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output=actual_csv,
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output={"content": expected_csv},
+            expected_agent_behavior="",
+        ),
+    )
+
+    # 2 out of 3 data rows match, so score should be ~0.67
+    assert 0.6 < result.score < 0.7
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3
+
+    # Check individual line scores
+    assert result.details.line_by_line_results[0].score == 1.0  # John matches
+    assert result.details.line_by_line_results[1].score == 0.0  # Different != Jane
+    assert result.details.line_by_line_results[2].score == 1.0  # Bob matches
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_multiple_columns():
+    """Test line-by-line evaluation with multiple columns."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name,Age"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    csv_content = "Name,Age,City\nJohn,25,Paris\nJane,30,London"
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output=csv_content,
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output={"content": csv_content},
+            expected_agent_behavior="",
+        ),
+    )
+
+    # All rows match on Name and Age, so score should be 1.0
+    assert result.score == 1.0
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 2
+    assert result.details.total_lines_expected == 2
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_unequal_line_counts():
+    """Test line-by-line evaluation with different line counts."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    actual_csv = "Name,Age\nJohn,25\nJane,30"  # 2 data rows
+    expected_csv = "Name,Age\nJohn,25\nJane,30\nBob,35"  # 3 data rows
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output=actual_csv,
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output={"content": expected_csv},
+            expected_agent_behavior="",
+        ),
+    )
+
+    # 2 out of 3 lines match (third line is missing), so score should be ~0.67
+    assert 0.6 < result.score < 0.7
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 2
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3  # Evaluates max(2, 3) lines
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_with_job_attachment():
+    """Test line-by-line evaluation with job attachment (mocked)."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyCSVExactMatchEvaluator(
+            **_make_base_params(target_sub_output_key="Name"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    # Mock job attachment download
+    csv_content = "Name,Age\nJohn,25\nJane,30"
+
+    with patch(
+        "uipath.eval.evaluators.base_legacy_evaluator.download_attachment_as_string",
+        return_value=csv_content,
+    ):
+        agent_execution = AgentExecution(
+            agent_input={"input": "test"},
+            # Simulate job attachment URI
+            agent_output="urn:uipath:cas:file:orchestrator:12345678-1234-1234-1234-123456789abc",
+            agent_trace=[],
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"content": csv_content},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # All lines match, so score should be 1.0
+        assert result.score == 1.0
+        assert isinstance(result.details, LineByLineEvaluationDetails)
+        assert result.details.total_lines_actual == 2
+        assert result.details.total_lines_expected == 2
+
+
+# Note: Custom delimiters work but CSV must still use commas for column separation
+# Line-by-line evaluation with custom delimiter would split "Name,Age|John,25|Jane,30"
+# into ["Name,Age", "John,25", "Jane,30"] which creates valid CSV rows.
diff --git a/packages/uipath/tests/cli/evaluators/test_legacy_exact_match_evaluator.py b/packages/uipath/tests/cli/evaluators/test_legacy_exact_match_evaluator.py
new file mode 100644
index 000000000..b5b5bfd4f
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_legacy_exact_match_evaluator.py
@@ -0,0 +1,757 @@
+"""Tests for LegacyExactMatchEvaluator.
+
+Tests the exact match evaluation functionality including target_output_key support,
+canonical JSON normalization, and number normalization.
+"""
+
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from uipath.eval.evaluators import LegacyExactMatchEvaluator
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.evaluators.output_evaluator import LineByLineEvaluationDetails
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params(target_output_key: str = "*") -> dict[str, Any]:
+    """Create base parameters for faithfulness evaluator."""
+    return {
+        "id": "exact_match",
+        "category": LegacyEvaluatorCategory.Deterministic,
+        "type": LegacyEvaluatorType.Equals,
+        "name": "ExactMatch",
+        "description": "Evaluates exact match of outputs",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": target_output_key,
+    }
+
+
+@pytest.fixture
+def evaluator():
+    """Fixture to create evaluator."""
+    with patch("uipath.platform.UiPath"):
+        return LegacyExactMatchEvaluator(**_make_base_params())
+
+
+@pytest.fixture
+def evaluator_with_target_key():
+    """Fixture to create evaluator with a specific target output key."""
+    with patch("uipath.platform.UiPath"):
+        return LegacyExactMatchEvaluator(
+            **_make_base_params(target_output_key="result")
+        )
+
+
+class TestLegacyExactMatchEvaluator:
+    """Test suite for LegacyExactMatchEvaluator."""
+
+    @pytest.mark.asyncio
+    async def test_exact_match_same_strings(self, evaluator) -> None:
+        """Test exact match with identical string outputs."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Hello World",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="Hello World",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+        assert isinstance(result.score, bool)
+
+    @pytest.mark.asyncio
+    async def test_exact_match_different_strings(self, evaluator) -> None:
+        """Test exact match with different string outputs."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Hello World",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="Goodbye World",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_exact_match_identical_dicts(self, evaluator) -> None:
+        """Test exact match with identical dictionaries."""
+        output = {"name": "John", "age": 30}
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=output,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=output,
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_different_dicts(self, evaluator) -> None:
+        """Test exact match with different dictionaries."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"name": "John", "age": 30},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"name": "Jane", "age": 25},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_exact_match_dict_key_order_doesnt_matter(self, evaluator) -> None:
+        """Test that canonical JSON normalization handles key order."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"a": 1, "b": 2},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"b": 2, "a": 1},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_number_normalization_int_to_float(
+        self, evaluator
+    ) -> None:
+        """Test that integers are normalized to floats for comparison."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"value": 42},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"value": 42.0},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_number_normalization_in_list(self, evaluator) -> None:
+        """Test number normalization in lists."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"values": [1, 2, 3]},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"values": [1.0, 2.0, 3.0]},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_booleans_preserved(self, evaluator) -> None:
+        """Test that booleans are not converted to numbers."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"active": True, "deleted": False},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"active": True, "deleted": False},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_nested_structures(self, evaluator) -> None:
+        """Test exact match with nested dictionaries and lists."""
+        output = {
+            "user": {
+                "name": "John",
+                "scores": [95, 87, 92],
+                "active": True,
+            },
+            "metadata": {"version": 1.0},
+        }
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=output,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=output,
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_both_have_key(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key extraction when both outputs have the key."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"result": {"status": "success"}, "other": "ignore"},
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"result": {"status": "success"}, "other": "different"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # Both outputs have the target key, so both get extracted and compared
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_missing_in_both(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key when key is missing in both outputs."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"other": "data"},
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"other": "different"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # When key is missing in both, both are set to {}, so they match
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_missing_in_actual(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key when key is missing in actual output."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"other": "data"},
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"result": {"status": "success"}},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # When key is missing in actual, both are set to {}, so they match
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_missing_in_expected(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key when key is missing in expected output."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"result": {"status": "success"}},
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"other": "data"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        # When key is missing in expected, both are set to {}, so they match
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_wildcard_target_key(self, evaluator) -> None:
+        """Test that wildcard target_output_key compares full outputs."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"data": "value", "extra": "field"},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"data": "value", "extra": "field"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_non_dict_inputs(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key with non-dict inputs (should compare as-is)."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="string_value",
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="other_string",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_exact_match_null_values(self, evaluator) -> None:
+        """Test exact match with None values."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"value": None},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"value": None},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_empty_dict(self, evaluator) -> None:
+        """Test exact match with empty dictionaries."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_empty_string(self, evaluator) -> None:
+        """Test exact match with empty strings."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_unicode_characters(self, evaluator) -> None:
+        """Test exact match with unicode characters."""
+        output = {"greeting": "你好世界", "emoji": "🎉"}
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output=output,
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output=output,
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_whitespace_matters(self, evaluator) -> None:
+        """Test that whitespace differences are detected."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Hello World",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="Hello  World",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_exact_match_case_sensitivity(self, evaluator) -> None:
+        """Test that string comparison is case sensitive."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Hello",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="hello",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_exact_match_large_numbers(self, evaluator) -> None:
+        """Test exact match with large numbers."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"value": 999999999999999},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"value": 999999999999999.0},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_floating_point_precision(self, evaluator) -> None:
+        """Test exact match with floating point numbers."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"pi": 3.14159},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"pi": 3.14159},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_float_vs_int_zero(self, evaluator) -> None:
+        """Test that 0 and 0.0 are considered equal."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"value": 0},
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"value": 0.0},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_target_key_different_values(
+        self, evaluator_with_target_key
+    ) -> None:
+        """Test target_output_key with different values in target key."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={"result": {"status": "success"}, "other": "ignore"},
+        )
+
+        result = await evaluator_with_target_key.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={"result": {"status": "failed"}, "other": "ignore"},
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_canonical_json_normalization(self, evaluator) -> None:
+        """Test that canonical JSON normalization works correctly."""
+        # Create complex nested structure with mixed types
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output={
+                "z_key": 1,
+                "a_key": [3, 2, 1],
+                "m_key": {"nested": 42},
+            },
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output={
+                    "a_key": [3, 2, 1],
+                    "m_key": {"nested": 42.0},
+                    "z_key": 1.0,
+                },
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score is True
+
+
+# Line-by-line evaluation tests
+@pytest.mark.asyncio
+async def test_line_by_line_all_match():
+    """Test line-by-line evaluation when all lines match."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_base_params(),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output="Line 1\nLine 2\nLine 3",
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output="Line 1\nLine 2\nLine 3",
+            expected_agent_behavior="",
+        ),
+    )
+
+    # All lines match, so score should be 1.0
+    assert result.score == 1.0
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3
+    assert all(line.score is True for line in result.details.line_by_line_results)
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_partial_match():
+    """Test line-by-line evaluation with partial matches."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_base_params(),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output="Line 1\nDifferent\nLine 3",
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output="Line 1\nLine 2\nLine 3",
+            expected_agent_behavior="",
+        ),
+    )
+
+    # 2 out of 3 lines match, so score should be ~0.67
+    assert 0.6 < result.score < 0.7
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3
+
+    # Check individual line scores
+    assert result.details.line_by_line_results[0].score is True  # Line 1 matches
+    assert result.details.line_by_line_results[1].score is False  # Line 2 doesn't match
+    assert result.details.line_by_line_results[2].score is True  # Line 3 matches
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_with_target_output_key():
+    """Test line-by-line evaluation with targetOutputKey."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_base_params(target_output_key="result"),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output={"result": "Line 1\nLine 2\nLine 3"},
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output={"result": "Line 1\nLine 2\nLine 3"},
+            expected_agent_behavior="",
+        ),
+    )
+
+    # All lines match, so score should be 1.0
+    assert result.score == 1.0
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_custom_delimiter():
+    """Test line-by-line evaluation with custom delimiter."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_base_params(),
+            lineByLineEvaluation=True,
+            lineDelimiter="|",
+        )
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output="Item1|Item2|Item3",
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output="Item1|Item2|Item3",
+            expected_agent_behavior="",
+        ),
+    )
+
+    # All items match, so score should be 1.0
+    assert result.score == 1.0
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 3
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3
+
+
+@pytest.mark.asyncio
+async def test_line_by_line_unequal_line_counts():
+    """Test line-by-line evaluation with different line counts."""
+    with patch("uipath.platform.UiPath"):
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_base_params(),
+            lineByLineEvaluation=True,
+            lineDelimiter="\n",
+        )
+
+    agent_execution = AgentExecution(
+        agent_input={"input": "test"},
+        agent_output="Line 1\nLine 2",
+        agent_trace=[],
+    )
+
+    result = await evaluator.validate_and_evaluate_criteria(
+        agent_execution=agent_execution,
+        evaluation_criteria=LegacyEvaluationCriteria(
+            expected_output="Line 1\nLine 2\nLine 3",
+            expected_agent_behavior="",
+        ),
+    )
+
+    # 2 out of 3 lines match (third line is missing), so score should be ~0.67
+    assert 0.6 < result.score < 0.7
+    assert hasattr(result, "details")
+    assert isinstance(result.details, LineByLineEvaluationDetails)
+    assert result.details.total_lines_actual == 2
+    assert result.details.total_lines_expected == 3
+    assert len(result.details.line_by_line_results) == 3  # Evaluates max(2, 3) lines
diff --git a/packages/uipath/tests/cli/evaluators/test_legacy_faithfulness_evaluator.py b/packages/uipath/tests/cli/evaluators/test_legacy_faithfulness_evaluator.py
new file mode 100644
index 000000000..68d8b407b
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_legacy_faithfulness_evaluator.py
@@ -0,0 +1,641 @@
+"""Tests for LegacyFaithfulnessEvaluator.
+
+Tests span extraction, claim extraction (3-stage pipeline), and claim evaluation.
+"""
+
+import json
+from types import MappingProxyType
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from uipath.eval.evaluators import LegacyFaithfulnessEvaluator
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params() -> dict[str, Any]:
+    """Create base parameters for faithfulness evaluator."""
+    return {
+        "id": "faithfulness",
+        "category": LegacyEvaluatorCategory.LlmAsAJudge,
+        "type": LegacyEvaluatorType.Faithfulness,
+        "name": "Faithfulness",
+        "description": "Evaluates faithfulness of claims against context",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": "*",
+    }
+
+
+@pytest.fixture(autouse=True)
+def mock_uipath_platform():
+    """Fixture to mock UiPath platform for all tests."""
+    with patch("uipath.platform.UiPath") as mock_uipath_class:
+        mock_uipath_instance = mock_uipath_class.return_value
+        mock_uipath_instance.llm = AsyncMock()
+        yield mock_uipath_class
+
+
+@pytest.fixture
+def evaluator_with_mocked_llm():
+    """Fixture to create evaluator with mocked LLM service."""
+    evaluator = LegacyFaithfulnessEvaluator(
+        **_make_base_params(),
+        model="gpt-4.1-2025-04-14",
+    )
+    evaluator.llm = AsyncMock()
+    return evaluator
+
+
+def _make_mock_span(tool_name: str, output_data: dict[str, Any]):
+    """Create a mock span with tool call data."""
+
+    class MockSpan:
+        def __init__(self):
+            self.attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": tool_name,
+                    "output.value": json.dumps(output_data),
+                }
+            )
+
+    return MockSpan()
+
+
+def _make_retriever_span(query: str, documents: list[str]):
+    """Create a mock RETRIEVER span with context grounding data."""
+    return _make_mock_span(
+        "RETRIEVER",
+        {"documents": [{"id": str(i), "text": doc} for i, doc in enumerate(documents)]},
+    )
+
+
+class TestLegacyFaithfulnessEvaluator:
+    """Test suite for LegacyFaithfulnessEvaluator."""
+
+    @pytest.mark.asyncio
+    async def test_context_source_extraction_from_tool_calls(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test extraction of context sources from tool call spans."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create mock spans with tool outputs
+        span1 = _make_mock_span("TOOL_CALL", {"result": "Tool output 1"})
+        span2 = _make_mock_span("TOOL_CALL", {"result": "Tool output 2"})
+
+        # Extract context sources
+        sources = evaluator._extract_context_sources([span1, span2])
+
+        assert len(sources) == 2
+        assert all("content" in s and "source" in s for s in sources)
+
+    @pytest.mark.asyncio
+    async def test_context_source_extraction_from_retriever(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test extraction of context sources from RETRIEVER spans."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create mock RETRIEVER span with documents
+        span = _make_retriever_span(
+            "construction", ["Building materials info", "Safety codes"]
+        )
+
+        # Extract context sources (should extract each document individually)
+        sources = evaluator._extract_context_sources([span])
+
+        assert len(sources) == 2
+        assert all(s["source"] == "Context Grounding" for s in sources)
+        # Check that we have both documents
+        contents = [s["content"] for s in sources]
+        assert any("Building materials" in c for c in contents)
+        assert any("Safety codes" in c for c in contents)
+
+    @pytest.mark.asyncio
+    async def test_context_source_extraction_skips_invalid_spans(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that spans without proper structure are skipped."""
+        evaluator = evaluator_with_mocked_llm
+
+        class InvalidSpan:
+            attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": "TOOL_CALL",
+                    # Missing output.value
+                }
+            )
+
+        # Should skip invalid span
+        sources = evaluator._extract_context_sources([InvalidSpan()])
+        assert len(sources) == 0
+
+    @pytest.mark.asyncio
+    async def test_select_verifiable_sentences(self, evaluator_with_mocked_llm) -> None:
+        """Test Stage 1: Selection of verifiable sentences."""
+        evaluator = evaluator_with_mocked_llm
+
+        agent_output = (
+            "The capital of France is Paris. Do you agree? This is important."
+        )
+
+        mock_response = {"sentences": ["The capital of France is Paris."]}
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            sentences = await evaluator._select_verifiable_sentences(agent_output)
+
+            assert len(sentences) == 1
+            assert "capital of France" in sentences[0]
+
+    @pytest.mark.asyncio
+    async def test_disambiguate_sentences(self, evaluator_with_mocked_llm) -> None:
+        """Test Stage 2: Disambiguation of sentences."""
+        evaluator = evaluator_with_mocked_llm
+
+        verifiable_sentences = ["It is located in Western Europe."]
+        full_output = "France is a country. It is located in Western Europe."
+
+        mock_response = {
+            "disambiguated": [
+                {
+                    "original": "It is located in Western Europe.",
+                    "disambiguated": "France is located in Western Europe.",
+                }
+            ]
+        }
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            result = await evaluator._disambiguate_sentences(
+                verifiable_sentences, full_output
+            )
+
+            assert len(result) == 1
+            assert result[0]["disambiguated"] == "France is located in Western Europe."
+
+    @pytest.mark.asyncio
+    async def test_decompose_to_claims(self, evaluator_with_mocked_llm) -> None:
+        """Test Stage 3: Decomposition into standalone claims."""
+        evaluator = evaluator_with_mocked_llm
+
+        disambiguated = [
+            {
+                "original": "Paris and Lyon have populations over 1 million.",
+                "disambiguated": "Paris and Lyon have populations over 1 million.",
+            }
+        ]
+        full_output = (
+            "France has major cities. Paris and Lyon have populations over 1 million."
+        )
+
+        mock_response = {
+            "claims": [
+                {
+                    "claim": "Paris has a population over 1 million",
+                    "original_sentence": "1",
+                },
+                {
+                    "claim": "Lyon has a population over 1 million",
+                    "original_sentence": "1",
+                },
+            ]
+        }
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            claims = await evaluator._decompose_to_claims(disambiguated, full_output)
+
+            assert len(claims) == 2
+            assert any("Paris" in c["text"] for c in claims)
+            assert any("Lyon" in c["text"] for c in claims)
+
+    @pytest.mark.asyncio
+    async def test_evaluate_claim_stance_supports(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test claim stance evaluation when source supports claim."""
+        evaluator = evaluator_with_mocked_llm
+
+        claim = "Paris is the capital of France"
+        context = "The capital of France is Paris, a major European city."
+
+        mock_response = {"stance": "SUPPORTS"}
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            stance = await evaluator._evaluate_claim_stance(claim, context)
+
+            assert stance == "SUPPORTS"
+
+    @pytest.mark.asyncio
+    async def test_evaluate_claim_stance_contradicts(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test claim stance evaluation when source contradicts claim."""
+        evaluator = evaluator_with_mocked_llm
+
+        claim = "Paris is in Germany"
+        context = "Paris is a city in France, not Germany."
+
+        mock_response = {"stance": "CONTRADICTS"}
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            stance = await evaluator._evaluate_claim_stance(claim, context)
+
+            assert stance == "CONTRADICTS"
+
+    @pytest.mark.asyncio
+    async def test_evaluate_claim_stance_irrelevant(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test claim stance evaluation when source is irrelevant."""
+        evaluator = evaluator_with_mocked_llm
+
+        claim = "Paris is the capital of France"
+        context = "The Eiffel Tower is made of iron."
+
+        mock_response = {"stance": "IRRELEVANT"}
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            stance = await evaluator._evaluate_claim_stance(claim, context)
+
+            assert stance == "IRRELEVANT"
+
+    @pytest.mark.asyncio
+    async def test_evaluate_claims_against_context(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation of claims against multiple context sources."""
+        evaluator = evaluator_with_mocked_llm
+
+        claims = [
+            {"text": "Paris is in France", "original_sentence": "1"},
+            {"text": "Tokyo is in Japan", "original_sentence": "2"},
+        ]
+        context_sources = [
+            {"content": "Paris is the capital of France", "source": "Source 1"},
+            {"content": "Tokyo is the capital of Japan", "source": "Source 2"},
+        ]
+
+        # Mock stance evaluations
+        with patch.object(
+            evaluator, "_evaluate_claim_stance", new_callable=AsyncMock
+        ) as mock_stance:
+            # Return SUPPORTS for both claims
+            mock_stance.side_effect = ["SUPPORTS", "SUPPORTS", "SUPPORTS", "SUPPORTS"]
+
+            evaluations = await evaluator._evaluate_claims_against_context(
+                claims, context_sources
+            )
+
+            assert len(evaluations) == 2
+            assert all(e["is_grounded"] for e in evaluations)
+            assert len(evaluations[0]["supporting_sources"]) == 2
+            assert len(evaluations[1]["supporting_sources"]) == 2
+
+    @pytest.mark.asyncio
+    async def test_claim_grounding_with_contradicting_source(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that claims with contradicting sources are not grounded."""
+        evaluator = evaluator_with_mocked_llm
+
+        claims = [
+            {"text": "The Earth is flat", "original_sentence": "1"},
+        ]
+        context_sources = [
+            {"content": "The Earth is spherical", "source": "Science Source"},
+        ]
+
+        with patch.object(
+            evaluator, "_evaluate_claim_stance", new_callable=AsyncMock
+        ) as mock_stance:
+            mock_stance.return_value = "CONTRADICTS"
+
+            evaluations = await evaluator._evaluate_claims_against_context(
+                claims, context_sources
+            )
+
+            assert len(evaluations) == 1
+            assert not evaluations[0]["is_grounded"]
+            assert len(evaluations[0]["contradicting_sources"]) == 1
+
+    @pytest.mark.asyncio
+    async def test_full_evaluation_with_no_agent_output(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation when no agent output is provided."""
+        evaluator = evaluator_with_mocked_llm
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="",
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution,
+            evaluation_criteria=LegacyEvaluationCriteria(
+                expected_output="",
+                expected_agent_behavior="",
+            ),
+        )
+
+        assert result.score == 0.0
+        assert "no agent output" in result.details.lower()
+
+    @pytest.mark.asyncio
+    async def test_full_evaluation_with_no_context_sources(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation when no context sources are available."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Create a span without output (no context source)
+        class NoOutputSpan:
+            attributes = MappingProxyType(
+                {
+                    "openinference.span.kind": "TOOL_CALL",
+                    # No output.value
+                }
+            )
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="The sky is blue.",
+        )
+
+        with patch.object(evaluator, "_extract_context_sources", return_value=[]):
+            result = await evaluator.evaluate(
+                agent_execution,
+                evaluation_criteria=LegacyEvaluationCriteria(
+                    expected_output="The sky is blue.",
+                    expected_agent_behavior="",
+                ),
+            )
+
+            assert result.score == 0.0
+            assert "no context sources" in result.details.lower()
+
+    @pytest.mark.asyncio
+    async def test_full_evaluation_with_no_verifiable_claims(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test evaluation when no verifiable claims are found."""
+        evaluator = evaluator_with_mocked_llm
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Just a greeting.",
+        )
+
+        with (
+            patch.object(
+                evaluator,
+                "_extract_context_sources",
+                return_value=[{"content": "Some context", "source": "Test"}],
+            ),
+            patch.object(
+                evaluator, "_extract_claims", new_callable=AsyncMock
+            ) as mock_claims,
+        ):
+            mock_claims.return_value = []
+
+            result = await evaluator.evaluate(
+                agent_execution,
+                evaluation_criteria=LegacyEvaluationCriteria(
+                    expected_output="Just a greeting.",
+                    expected_agent_behavior="",
+                ),
+            )
+
+            assert result.score == 100.0
+            assert "no verifiable claims" in result.details.lower()
+
+    @pytest.mark.asyncio
+    async def test_full_evaluation_with_grounded_claims(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test full evaluation flow with grounded claims."""
+        evaluator = evaluator_with_mocked_llm
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Paris is in France.",
+        )
+
+        # Mock the extraction and evaluation steps
+        with (
+            patch.object(
+                evaluator,
+                "_extract_context_sources",
+                return_value=[
+                    {
+                        "content": "Paris is the capital of France",
+                        "source": "Context Grounding",
+                    }
+                ],
+            ),
+            patch.object(
+                evaluator, "_extract_claims", new_callable=AsyncMock
+            ) as mock_claims,
+            patch.object(
+                evaluator, "_evaluate_claims_against_context", new_callable=AsyncMock
+            ) as mock_eval,
+        ):
+            mock_claims.return_value = [
+                {"text": "Paris is in France", "original_sentence": "1"}
+            ]
+            mock_eval.return_value = [
+                {
+                    "claim": "Paris is in France",
+                    "original_sentence": "1",
+                    "is_grounded": True,
+                    "supporting_sources": ["Context Grounding"],
+                    "contradicting_sources": [],
+                }
+            ]
+
+            result = await evaluator.evaluate(
+                agent_execution,
+                evaluation_criteria=LegacyEvaluationCriteria(
+                    expected_output="Paris is in France.",
+                    expected_agent_behavior="",
+                ),
+            )
+
+            assert result.score == 100.0
+            assert "GROUNDED CLAIMS" in result.details
+            assert "Paris is in France" in result.details
+
+    @pytest.mark.asyncio
+    async def test_full_evaluation_with_mixed_claims(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test full evaluation with both grounded and ungrounded claims."""
+        evaluator = evaluator_with_mocked_llm
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_trace=[],
+            agent_output="Paris is in France. The sky is green.",
+        )
+
+        # Mock the extraction and evaluation steps
+        with (
+            patch.object(
+                evaluator,
+                "_extract_context_sources",
+                return_value=[
+                    {
+                        "content": "Paris is the capital of France",
+                        "source": "Context Grounding",
+                    }
+                ],
+            ),
+            patch.object(
+                evaluator, "_extract_claims", new_callable=AsyncMock
+            ) as mock_claims,
+            patch.object(
+                evaluator, "_evaluate_claims_against_context", new_callable=AsyncMock
+            ) as mock_eval,
+        ):
+            mock_claims.return_value = [
+                {"text": "Paris is in France", "original_sentence": "1"},
+                {"text": "The sky is green", "original_sentence": "2"},
+            ]
+            mock_eval.return_value = [
+                {
+                    "claim": "Paris is in France",
+                    "original_sentence": "1",
+                    "is_grounded": True,
+                    "supporting_sources": ["Context Grounding"],
+                    "contradicting_sources": [],
+                },
+                {
+                    "claim": "The sky is green",
+                    "original_sentence": "2",
+                    "is_grounded": False,
+                    "supporting_sources": [],
+                    "contradicting_sources": [],
+                },
+            ]
+
+            result = await evaluator.evaluate(
+                agent_execution,
+                evaluation_criteria=LegacyEvaluationCriteria(
+                    expected_output="Paris is in France. The sky is green.",
+                    expected_agent_behavior="",
+                ),
+            )
+
+            assert result.score == 50.0
+            assert "1/2" in result.details
+            assert "GROUNDED CLAIMS" in result.details
+            assert "UNGROUNDED CLAIMS" in result.details
+
+    @pytest.mark.asyncio
+    async def test_serialize_content_handles_various_types(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test serialization of various content types."""
+        evaluator = evaluator_with_mocked_llm
+
+        # Test string
+        result = evaluator._serialize_content("simple string")
+        assert result == "simple string"
+
+        # Test dict
+        result = evaluator._serialize_content({"key": "value"})
+        assert "key" in result and "value" in result
+
+        # Test list
+        result = evaluator._serialize_content(["item1", "item2"])
+        assert "item1" in result and "item2" in result
+
+    @pytest.mark.asyncio
+    async def test_evaluate_claim_stance_with_invalid_response(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test that invalid stance responses default to IRRELEVANT."""
+        evaluator = evaluator_with_mocked_llm
+
+        claim = "Test claim"
+        context = "Test context"
+
+        mock_response = {"stance": "INVALID_STANCE"}
+
+        with patch.object(
+            evaluator, "_get_structured_llm_response", new_callable=AsyncMock
+        ) as mock_llm:
+            mock_llm.return_value = mock_response
+
+            stance = await evaluator._evaluate_claim_stance(claim, context)
+
+            assert stance == "IRRELEVANT"
+
+    @pytest.mark.asyncio
+    async def test_format_justification_structure(
+        self, evaluator_with_mocked_llm
+    ) -> None:
+        """Test the structure of formatted justification."""
+        evaluator = evaluator_with_mocked_llm
+
+        claim_evaluations = [
+            {
+                "claim": "Grounded claim 1",
+                "original_sentence": "1",
+                "is_grounded": True,
+                "supporting_sources": ["Source A", "Source B"],
+                "contradicting_sources": [],
+            },
+            {
+                "claim": "Ungrounded claim",
+                "original_sentence": "2",
+                "is_grounded": False,
+                "supporting_sources": [],
+                "contradicting_sources": ["Source C"],
+            },
+        ]
+
+        justification = evaluator._format_justification(50.0, claim_evaluations)
+
+        assert "Overall Faithfulness: 50.0/100" in justification
+        assert "1/2" in justification
+        assert "GROUNDED CLAIMS" in justification
+        assert "UNGROUNDED CLAIMS" in justification
+        assert "Grounded claim 1" in justification
+        assert "Ungrounded claim" in justification
+        assert "Source A" in justification
+        assert "Source C" in justification
diff --git a/packages/uipath/tests/cli/evaluators/test_legacy_llm_as_judge_placeholder_validation.py b/packages/uipath/tests/cli/evaluators/test_legacy_llm_as_judge_placeholder_validation.py
new file mode 100644
index 000000000..34f4c7cdb
--- /dev/null
+++ b/packages/uipath/tests/cli/evaluators/test_legacy_llm_as_judge_placeholder_validation.py
@@ -0,0 +1,256 @@
+"""Tests for LegacyLlmAsAJudgeEvaluator placeholder auto-addition.
+
+Tests that missing {{ActualOutput}} and {{ExpectedOutput}} placeholders are
+automatically added to prompts with XML tags for clear delimitation.
+"""
+
+from typing import Any
+from unittest.mock import patch
+
+from uipath.eval.evaluators.legacy_llm_as_judge_evaluator import (
+    LegacyLlmAsAJudgeEvaluator,
+)
+from uipath.eval.models.models import (
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+
+def _make_base_params() -> dict[str, Any]:
+    """Create base parameters for faithfulness evaluator."""
+    return {
+        "id": "test",
+        "category": LegacyEvaluatorCategory.LlmAsAJudge,
+        "type": LegacyEvaluatorType.Custom,
+        "name": "TestEvaluator",
+        "description": "Test",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": "*",
+    }
+
+
+class TestLegacyLlmAsAJudgePlaceholderValidation:
+    """Test suite for automatic placeholder addition in legacy LLM judge evaluators."""
+
+    def test_both_placeholders_present_no_modification(self):
+        """Test that prompts with both placeholders are not modified."""
+        original_prompt = (
+            "Evaluate the quality.\n"
+            "Actual: {{ActualOutput}}\n"
+            "Expected: {{ExpectedOutput}}"
+        )
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Prompt should remain unchanged
+        assert evaluator.prompt == original_prompt
+        assert "## Actual Output" not in evaluator.prompt
+        assert "## Expected Output" not in evaluator.prompt
+        assert "<ActualOutput>" not in evaluator.prompt
+        assert "<ExpectedOutput>" not in evaluator.prompt
+
+    def test_missing_expected_output_placeholder_added_with_tags(self):
+        """Test that missing {{ExpectedOutput}} is auto-added with XML tags."""
+        original_prompt = "Evaluate this output: {{ActualOutput}}"
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Check that ExpectedOutput section was added
+        assert "## Expected Output" in evaluator.prompt
+        assert "<ExpectedOutput>" in evaluator.prompt
+        assert "{{ExpectedOutput}}" in evaluator.prompt
+        assert "</ExpectedOutput>" in evaluator.prompt
+
+        # Original prompt should still be there
+        assert "Evaluate this output: {{ActualOutput}}" in evaluator.prompt
+
+        # Verify structure: tags should wrap the placeholder
+        expected_section = (
+            "\n\n## Expected Output\n"
+            "<ExpectedOutput>\n"
+            "{{ExpectedOutput}}\n"
+            "</ExpectedOutput>"
+        )
+        assert expected_section in evaluator.prompt
+
+    def test_missing_actual_output_placeholder_added_with_tags(self):
+        """Test that missing {{ActualOutput}} is auto-added with XML tags."""
+        original_prompt = "Compare against expected: {{ExpectedOutput}}"
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Check that ActualOutput section was added
+        assert "## Actual Output" in evaluator.prompt
+        assert "<ActualOutput>" in evaluator.prompt
+        assert "{{ActualOutput}}" in evaluator.prompt
+        assert "</ActualOutput>" in evaluator.prompt
+
+        # Original prompt should still be there
+        assert "Compare against expected: {{ExpectedOutput}}" in evaluator.prompt
+
+        # Verify structure: tags should wrap the placeholder
+        expected_section = (
+            "\n\n## Actual Output\n<ActualOutput>\n{{ActualOutput}}\n</ActualOutput>"
+        )
+        assert expected_section in evaluator.prompt
+
+    def test_both_placeholders_missing_both_added_with_tags(self):
+        """Test that both placeholders are auto-added when both are missing."""
+        original_prompt = "Evaluate the quality of the agent output."
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Check that both sections were added
+        assert "## Actual Output" in evaluator.prompt
+        assert "<ActualOutput>" in evaluator.prompt
+        assert "{{ActualOutput}}" in evaluator.prompt
+        assert "</ActualOutput>" in evaluator.prompt
+
+        assert "## Expected Output" in evaluator.prompt
+        assert "<ExpectedOutput>" in evaluator.prompt
+        assert "{{ExpectedOutput}}" in evaluator.prompt
+        assert "</ExpectedOutput>" in evaluator.prompt
+
+        # Original prompt should still be there
+        assert "Evaluate the quality of the agent output." in evaluator.prompt
+
+        # Verify both sections are present
+        actual_section = (
+            "\n\n## Actual Output\n<ActualOutput>\n{{ActualOutput}}\n</ActualOutput>"
+        )
+        expected_section = (
+            "\n\n## Expected Output\n"
+            "<ExpectedOutput>\n"
+            "{{ExpectedOutput}}\n"
+            "</ExpectedOutput>"
+        )
+        assert actual_section in evaluator.prompt
+        assert expected_section in evaluator.prompt
+
+    def test_placeholder_order_actual_then_expected(self):
+        """Test that when both placeholders are added, ActualOutput comes before ExpectedOutput."""
+        original_prompt = "Rate the output quality."
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Find positions of the sections
+        actual_pos = evaluator.prompt.find("## Actual Output")
+        expected_pos = evaluator.prompt.find("## Expected Output")
+
+        # ActualOutput should come before ExpectedOutput
+        assert actual_pos < expected_pos
+
+    def test_xml_tags_properly_nested(self):
+        """Test that XML tags are properly nested around placeholders."""
+        original_prompt = "Evaluate."
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Check proper nesting for ActualOutput
+        actual_section = evaluator.prompt[evaluator.prompt.find("## Actual Output") :]
+        assert "<ActualOutput>" in actual_section
+        assert "{{ActualOutput}}" in actual_section
+        assert "</ActualOutput>" in actual_section
+
+        # Verify order: opening tag, placeholder, closing tag
+        opening_tag_pos = actual_section.find("<ActualOutput>")
+        placeholder_pos = actual_section.find("{{ActualOutput}}")
+        closing_tag_pos = actual_section.find("</ActualOutput>")
+
+        assert opening_tag_pos < placeholder_pos < closing_tag_pos
+
+    def test_custom_placeholder_delimiters_not_affected(self):
+        """Test that custom placeholder delimiters (curly braces) are preserved."""
+        original_prompt = "Evaluate: {{ActualOutput}} vs {{ExpectedOutput}}"
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Double braces should be preserved
+        assert "{{ActualOutput}}" in evaluator.prompt
+        assert "{{ExpectedOutput}}" in evaluator.prompt
+        # Single braces in tags should not interfere
+        assert "<ActualOutput>" not in evaluator.prompt  # Shouldn't be added
+        assert "<ExpectedOutput>" not in evaluator.prompt  # Shouldn't be added
+
+    def test_sections_appended_not_prepended(self):
+        """Test that missing sections are appended to the end, not prepended."""
+        original_prompt = "Original prompt content at the start."
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Original prompt should be at the start
+        assert evaluator.prompt.startswith("Original prompt content")
+        # Added sections should be at the end
+        assert evaluator.prompt.index("## Actual Output") > len(original_prompt)
+
+    def test_multiline_prompt_with_missing_placeholders(self):
+        """Test placeholder addition works with multiline prompts."""
+        original_prompt = """
+You are an expert evaluator.
+
+Task: Evaluate the quality of the agent output.
+
+Consider the following criteria:
+1. Accuracy
+2. Completeness
+3. Clarity
+
+Provide a score from 0-100.
+"""
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LegacyLlmAsAJudgeEvaluator(
+                **_make_base_params(),
+                prompt=original_prompt,
+                model="gpt-4",
+            )
+
+        # Original multiline content should be preserved
+        assert "You are an expert evaluator." in evaluator.prompt
+        assert "1. Accuracy" in evaluator.prompt
+
+        # Both placeholders should be added at the end
+        assert "## Actual Output" in evaluator.prompt
+        assert "## Expected Output" in evaluator.prompt
+        assert evaluator.prompt.index("## Actual Output") > len(original_prompt)
diff --git a/packages/uipath/tests/cli/integration/test_assets_commands.py b/packages/uipath/tests/cli/integration/test_assets_commands.py
new file mode 100644
index 000000000..e5e804963
--- /dev/null
+++ b/packages/uipath/tests/cli/integration/test_assets_commands.py
@@ -0,0 +1,164 @@
+"""Integration tests for assets CLI commands.
+
+These tests verify end-to-end functionality of the assets service commands,
+including proper context handling, error messages, and output formatting.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath.platform.common.paging import PagedResult
+
+
+@pytest.fixture
+def runner():
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Provide a mocked UiPath client."""
+    with patch("uipath.platform._uipath.UiPath") as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+
+        # Mock assets service
+        client_instance.assets = MagicMock()
+
+        yield client_instance
+
+
+def test_assets_list_command_basic(runner, mock_client, mock_env_vars):
+    """Test basic assets list command."""
+    mock_assets = [
+        MagicMock(
+            name="asset1",
+            value="value1",
+            value_type="Text",
+            model_dump=lambda: {
+                "name": "asset1",
+                "value": "value1",
+                "valueType": "Text",
+            },
+        ),
+        MagicMock(
+            name="asset2",
+            value="value2",
+            value_type="Text",
+            model_dump=lambda: {
+                "name": "asset2",
+                "value": "value2",
+                "valueType": "Text",
+            },
+        ),
+    ]
+    mock_client.assets.list.return_value = PagedResult(
+        items=mock_assets,
+        has_more=False,
+        skip=0,
+        top=100,
+    )
+
+    result = runner.invoke(cli, ["assets", "list"])
+
+    assert result.exit_code == 0
+    assert "asset1" in result.output
+    assert "asset2" in result.output
+
+
+def test_assets_list_with_json_format(runner, mock_client, mock_env_vars):
+    """Test assets list with JSON output format."""
+    mock_assets = [
+        MagicMock(model_dump=lambda: {"name": "test-asset", "value": "test-value"}),
+    ]
+    mock_client.assets.list.return_value = PagedResult(
+        items=mock_assets,
+        has_more=False,
+        skip=0,
+        top=100,
+    )
+
+    result = runner.invoke(cli, ["assets", "list", "--format", "json"])
+
+    assert result.exit_code == 0
+    assert "test-asset" in result.output
+
+
+def test_assets_list_with_filter(runner, mock_client, mock_env_vars):
+    """Test assets list with OData filter."""
+    mock_assets = [
+        MagicMock(model_dump=lambda: {"name": "text-asset", "valueType": "Text"}),
+    ]
+    mock_client.assets.list.return_value = PagedResult(
+        items=mock_assets,
+        has_more=False,
+        skip=0,
+        top=100,
+    )
+
+    result = runner.invoke(cli, ["assets", "list", "--filter", "ValueType eq 'Text'"])
+
+    assert result.exit_code == 0
+    mock_client.assets.list.assert_called_once()
+    call_kwargs = mock_client.assets.list.call_args.kwargs
+    assert call_kwargs["filter"] == "ValueType eq 'Text'"
+
+
+def test_assets_list_with_orderby(runner, mock_client, mock_env_vars):
+    """Test assets list with OData orderby."""
+    mock_assets: list[MagicMock] = []
+    mock_client.assets.list.return_value = PagedResult(
+        items=mock_assets,
+        has_more=False,
+        skip=0,
+        top=100,
+    )
+
+    result = runner.invoke(cli, ["assets", "list", "--orderby", "Name asc"])
+
+    assert result.exit_code == 0
+    call_kwargs = mock_client.assets.list.call_args.kwargs
+    assert call_kwargs["orderby"] == "Name asc"
+
+
+def test_assets_list_with_folder_path(runner, mock_client, mock_env_vars):
+    """Test assets list with folder path option."""
+    mock_assets: list[MagicMock] = []
+    mock_client.assets.list.return_value = PagedResult(
+        items=mock_assets,
+        has_more=False,
+        skip=0,
+        top=100,
+    )
+
+    result = runner.invoke(cli, ["assets", "list", "--folder-path", "Shared"])
+
+    assert result.exit_code == 0
+    call_kwargs = mock_client.assets.list.call_args.kwargs
+    assert call_kwargs["folder_path"] == "Shared"
+
+
+def test_assets_help_text(runner):
+    """Test that assets command has proper help text."""
+    result = runner.invoke(cli, ["assets", "--help"])
+
+    assert result.exit_code == 0
+    assert "Manage UiPath assets" in result.output
+    assert "list" in result.output
+
+
+def test_assets_list_help_text(runner):
+    """Test that assets list command has proper help text."""
+    result = runner.invoke(cli, ["assets", "list", "--help"])
+
+    assert result.exit_code == 0
+    assert "List assets" in result.output
+    assert "--folder-path" in result.output
+    assert "--filter" in result.output
+    assert "--orderby" in result.output
+    assert "--top" in result.output
+    assert "--skip" in result.output
diff --git a/packages/uipath/tests/cli/integration/test_buckets_commands.py b/packages/uipath/tests/cli/integration/test_buckets_commands.py
new file mode 100644
index 000000000..1de705bda
--- /dev/null
+++ b/packages/uipath/tests/cli/integration/test_buckets_commands.py
@@ -0,0 +1,236 @@
+"""Integration tests for buckets CLI commands.
+
+These tests verify end-to-end functionality of the buckets service commands,
+including proper context handling, error messages, and output formatting.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+
+
+@pytest.fixture
+def runner():
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Provide a mocked UiPath client."""
+    # Patch where UiPath is actually defined
+    with patch("uipath.platform._uipath.UiPath") as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+
+        # Mock buckets service
+        client_instance.buckets = MagicMock()
+
+        yield client_instance
+
+
+def test_buckets_list_command_basic(runner, mock_client, mock_env_vars):
+    """Test basic buckets list command."""
+    # Mock bucket data - list command now expects an iterator
+    mock_client.buckets.list.return_value = iter(
+        [
+            MagicMock(
+                name="bucket1",
+                description="First bucket",
+                model_dump=lambda: {"name": "bucket1", "description": "First bucket"},
+            ),
+            MagicMock(
+                name="bucket2",
+                description="Second bucket",
+                model_dump=lambda: {"name": "bucket2", "description": "Second bucket"},
+            ),
+        ]
+    )
+
+    result = runner.invoke(cli, ["buckets", "list"])
+
+    assert result.exit_code == 0
+    assert "bucket1" in result.output
+    assert "bucket2" in result.output
+
+
+def test_buckets_list_with_json_format(runner, mock_client, mock_env_vars):
+    """Test buckets list with JSON output format."""
+    mock_client.buckets.list.return_value = iter(
+        [
+            MagicMock(model_dump=lambda: {"name": "test-bucket", "id": "123"}),
+        ]
+    )
+
+    result = runner.invoke(cli, ["buckets", "list", "--format", "json"])
+
+    assert result.exit_code == 0
+    assert "test-bucket" in result.output
+
+
+def test_buckets_create_command(runner, mock_client, mock_env_vars):
+    """Test buckets create command."""
+    mock_bucket = MagicMock()
+    mock_bucket.name = "new-bucket"
+    mock_bucket.model_dump.return_value = {"name": "new-bucket", "id": "456"}
+    mock_client.buckets.create.return_value = mock_bucket
+
+    result = runner.invoke(
+        cli, ["buckets", "create", "new-bucket", "--description", "Test bucket"]
+    )
+
+    assert result.exit_code == 0
+    # Click's CliRunner captures both stdout and stderr in result.output by default
+    assert "Created bucket 'new-bucket'" in result.output
+
+
+def test_buckets_retrieve_without_name_or_key_fails(runner, mock_env_vars):
+    """Test that retrieve without --name or --key fails with usage error."""
+    result = runner.invoke(cli, ["buckets", "retrieve"])
+
+    assert result.exit_code != 0
+    assert "Either --name or --key must be provided" in result.output
+
+
+def test_buckets_retrieve_with_both_name_and_key_fails(runner, mock_env_vars):
+    """Test that retrieve with both --name and --key fails."""
+    result = runner.invoke(
+        cli, ["buckets", "retrieve", "--name", "test", "--key", "123"]
+    )
+
+    assert result.exit_code != 0
+    assert "Provide either --name or --key, not both" in result.output
+
+
+def test_buckets_delete_with_confirm(runner, mock_client, mock_env_vars):
+    """Test buckets delete command with --confirm flag."""
+    mock_bucket = MagicMock()
+    mock_bucket.name = "test-bucket"
+    mock_bucket.id = 123
+    mock_client.buckets.retrieve.return_value = mock_bucket
+    mock_client.buckets.delete = MagicMock()  # Mock the SDK delete method
+
+    result = runner.invoke(cli, ["buckets", "delete", "test-bucket", "--confirm"])
+
+    assert result.exit_code == 0
+    # Click's CliRunner captures both stdout and stderr in result.output by default
+    assert "Deleted bucket 'test-bucket'" in result.output
+    # Assert SDK delete was called
+    mock_client.buckets.delete.assert_called_once_with(
+        name="test-bucket",
+        folder_path=None,
+        folder_key=None,
+    )
+
+
+def test_buckets_delete_dry_run(runner, mock_client, mock_env_vars):
+    """Test buckets delete command with --dry-run flag."""
+    mock_bucket = MagicMock()
+    mock_bucket.name = "test-bucket"
+    mock_bucket.id = 123
+    mock_client.buckets.retrieve.return_value = mock_bucket
+    mock_client.buckets.delete = MagicMock()  # Mock the SDK delete method
+
+    result = runner.invoke(cli, ["buckets", "delete", "test-bucket", "--dry-run"])
+
+    assert result.exit_code == 0
+    # Click's CliRunner captures both stdout and stderr in result.output by default
+    assert "Would delete bucket" in result.output
+    mock_client.buckets.delete.assert_not_called()  # Assert SDK method was not called
+
+
+def test_buckets_list_with_pagination(runner, mock_client, mock_env_vars):
+    """Test buckets list command with pagination options.
+
+    Note: SDK list() auto-paginates internally and doesn't accept limit/offset.
+    The CLI applies client-side pagination after fetching results.
+    """
+    # Create test data
+    mock_buckets = [
+        MagicMock(model_dump=lambda i=i: {"name": f"bucket{i}", "id": str(i)})
+        for i in range(20)
+    ]
+    mock_client.buckets.list.return_value = iter(mock_buckets)
+
+    result = runner.invoke(cli, ["buckets", "list", "--limit", "10", "--offset", "5"])
+
+    assert result.exit_code == 0
+    mock_client.buckets.list.assert_called_once()
+
+    # Verify SDK was called WITHOUT limit/offset (it handles pagination internally)
+    call_kwargs = mock_client.buckets.list.call_args.kwargs
+    assert "limit" not in call_kwargs
+    assert "offset" not in call_kwargs
+
+    # Verify client-side pagination was applied (should show buckets 5-14)
+    # We can't easily verify the exact output without parsing, but we can check success
+    assert "bucket" in result.output.lower()
+
+
+def test_buckets_list_with_limit_zero(runner, mock_client, mock_env_vars):
+    """Test that --limit 0 returns empty list (regression test for truthiness bug).
+
+    This is a regression test for the bug where limit=0 would return all items
+    instead of an empty list due to Python's truthiness evaluation (0 is falsy).
+    """
+    # Create test data
+    mock_buckets = [
+        MagicMock(model_dump=lambda i=i: {"name": f"bucket{i}", "id": str(i)})
+        for i in range(10)
+    ]
+    mock_client.buckets.list.return_value = iter(mock_buckets)
+
+    result = runner.invoke(cli, ["buckets", "list", "--limit", "0"])
+
+    assert result.exit_code == 0
+    # Verify empty output (no buckets should be returned)
+    # With --format table (default), should show empty table or "no results"
+    # We check that no bucket names appear in the output
+    assert "bucket0" not in result.output
+    assert "bucket1" not in result.output
+
+
+def test_buckets_help_text(runner):
+    """Test that buckets command has proper help text."""
+    result = runner.invoke(cli, ["buckets", "--help"])
+
+    assert result.exit_code == 0
+    assert "Manage UiPath storage buckets" in result.output
+    assert "list" in result.output
+    assert "create" in result.output
+    assert "delete" in result.output
+
+
+def test_buckets_list_help_text(runner):
+    """Test that buckets list command has proper help text."""
+    result = runner.invoke(cli, ["buckets", "list", "--help"])
+
+    assert result.exit_code == 0
+    assert "List all Buckets" in result.output
+    assert "--folder-path" in result.output
+    assert "--limit" in result.output
+
+
+def test_buckets_delete_non_existent_bucket(runner, mock_client, mock_env_vars):
+    """Test deleting a bucket that does not exist."""
+    # Mock retrieve to raise LookupError
+    mock_client.buckets.retrieve.side_effect = LookupError("Bucket not found")
+
+    result = runner.invoke(cli, ["buckets", "delete", "no-such-bucket", "--confirm"])
+
+    assert result.exit_code != 0
+    assert "Bucket 'no-such-bucket' not found" in result.output
+
+
+def test_buckets_retrieve_non_existent_bucket(runner, mock_client, mock_env_vars):
+    """Test retrieving a bucket that does not exist."""
+    # Mock retrieve to raise LookupError
+    mock_client.buckets.retrieve.side_effect = LookupError("Bucket not found")
+
+    result = runner.invoke(cli, ["buckets", "retrieve", "--name", "no-such-bucket"])
+
+    assert result.exit_code != 0
+    assert "Bucket 'no-such-bucket' not found" in result.output
diff --git a/packages/uipath/tests/cli/integration/test_context_grounding_commands.py b/packages/uipath/tests/cli/integration/test_context_grounding_commands.py
new file mode 100644
index 000000000..7296d7080
--- /dev/null
+++ b/packages/uipath/tests/cli/integration/test_context_grounding_commands.py
@@ -0,0 +1,883 @@
+"""Integration tests for context-grounding CLI commands.
+
+Tests verify end-to-end functionality of all context-grounding commands,
+including proper option handling, error messages, and output formatting.
+"""
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath.platform.context_grounding import ContextGroundingIndex
+
+
+@pytest.fixture
+def runner():
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Provide a mocked UiPath client."""
+    with patch("uipath.platform._uipath.UiPath") as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+        client_instance.context_grounding = MagicMock()
+        client_instance.attachments = MagicMock()
+        yield client_instance
+
+
+def _make_index(name="my-index", status="Completed", description="Test index"):
+    """Build a mock ContextGroundingIndex."""
+    index = MagicMock(spec=ContextGroundingIndex)
+    index.id = "test-index-id"
+    index.name = name
+    index.last_ingestion_status = status
+    index.last_ingested = None
+    index.description = description
+    index.folder_key = "test-folder-key"
+    index.in_progress_ingestion.return_value = False
+    index.model_dump.return_value = {
+        "id": "test-index-id",
+        "name": name,
+        "last_ingestion_status": status,
+        "description": description,
+    }
+    return index
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+
+class TestListCommand:
+    def test_list_basic(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.list_indexes.return_value = [
+            _make_index(name="index-one"),
+            _make_index(name="index-two"),
+        ]
+        result = runner.invoke(
+            cli, ["context-grounding", "list", "--folder-path", "Shared"]
+        )
+        assert result.exit_code == 0
+        assert "index-one" in result.output
+        assert "index-two" in result.output
+        mock_client.context_grounding.list_indexes.assert_called_once_with(
+            folder_path="Shared", folder_key=None
+        )
+
+    def test_list_empty(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.list_indexes.return_value = []
+        result = runner.invoke(
+            cli, ["context-grounding", "list", "--folder-path", "Shared"]
+        )
+        assert result.exit_code == 0
+
+    def test_list_with_folder_key(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.list_indexes.return_value = []
+        fk = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+        result = runner.invoke(cli, ["context-grounding", "list", "--folder-key", fk])
+        assert result.exit_code == 0
+        mock_client.context_grounding.list_indexes.assert_called_once_with(
+            folder_path=None, folder_key=fk
+        )
+
+
+# ---------------------------------------------------------------------------
+# retrieve
+# ---------------------------------------------------------------------------
+
+
+class TestRetrieveCommand:
+    def test_retrieve_by_name(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.return_value = _make_index()
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "retrieve",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code == 0
+        assert "my-index" in result.output
+        mock_client.context_grounding.retrieve.assert_called_once_with(
+            name="my-index", folder_path="Shared", folder_key=None
+        )
+
+    def test_retrieve_by_id(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve_by_id.return_value = {
+            "id": "abc-123",
+            "name": "ephemeral-index",
+            "lastIngestionStatus": "Successful",
+        }
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "retrieve",
+                "--index-id",
+                "abc-123",
+                "--format",
+                "json",
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.retrieve_by_id.assert_called_once()
+
+    def test_retrieve_no_identifier_fails(self, runner, mock_env_vars):
+        result = runner.invoke(cli, ["context-grounding", "retrieve"])
+        assert result.exit_code != 0
+        assert (
+            "index-name" in result.output.lower() or "index-id" in result.output.lower()
+        )
+
+    def test_retrieve_both_identifiers_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "retrieve", "--index-name", "X", "--index-id", "Y"],
+        )
+        assert result.exit_code != 0
+
+    def test_retrieve_not_found(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.side_effect = LookupError("not found")
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "retrieve",
+                "--index-name",
+                "missing",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code != 0
+        assert "not found" in result.output.lower()
+
+    def test_retrieve_not_found_http_404(self, runner, mock_client, mock_env_vars):
+        from httpx import HTTPStatusError, Request, Response
+
+        resp = Response(404, request=Request("GET", "http://test"))
+        mock_client.context_grounding.retrieve.side_effect = HTTPStatusError(
+            "Not found", request=resp.request, response=resp
+        )
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "retrieve",
+                "--index-name",
+                "missing",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code != 0
+        assert "not found" in result.output.lower()
+
+
+# ---------------------------------------------------------------------------
+# create
+# ---------------------------------------------------------------------------
+
+
+class TestCreateCommand:
+    def test_create_with_bucket_source(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.create_index.return_value = _make_index(
+            name="new-index"
+        )
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "create",
+                "--index-name",
+                "new-index",
+                "--bucket-source",
+                "my-bucket",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.create_index.assert_called_once()
+        call_kwargs = mock_client.context_grounding.create_index.call_args[1]
+        assert call_kwargs["name"] == "new-index"
+
+    def test_create_both_sources_fails(self, runner, mock_env_vars, tmp_path):
+        f = tmp_path / "config.json"
+        f.write_text("{}")
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "create",
+                "--index-name",
+                "X",
+                "--bucket-source",
+                "B",
+                "--source-file",
+                str(f),
+            ],
+        )
+        assert result.exit_code != 0
+        assert (
+            "cannot use both" in result.output.lower()
+            or "choose one" in result.output.lower()
+        )
+
+    def test_create_no_source_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "create",
+                "--index-name",
+                "X",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code != 0
+
+    def test_create_missing_index_name_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "create", "--bucket-source", "B"],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# create-ephemeral
+# ---------------------------------------------------------------------------
+
+
+class TestCreateEphemeralCommand:
+    def test_create_ephemeral_basic(self, runner, mock_client, mock_env_vars, tmp_path):
+        test_file = tmp_path / "doc.pdf"
+        test_file.write_text("test content")
+
+        import uuid
+
+        mock_client.attachments.upload.return_value = uuid.uuid4()
+        mock_client.context_grounding.create_ephemeral_index.return_value = _make_index(
+            name="ephemeral"
+        )
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "create-ephemeral",
+                "--usage",
+                "DeepRAG",
+                "--files",
+                str(test_file),
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.attachments.upload.assert_called_once()
+        mock_client.context_grounding.create_ephemeral_index.assert_called_once()
+
+    def test_create_ephemeral_multiple_files(
+        self, runner, mock_client, mock_env_vars, tmp_path
+    ):
+        f1 = tmp_path / "a.csv"
+        f2 = tmp_path / "b.csv"
+        f1.write_text("a")
+        f2.write_text("b")
+
+        import uuid
+
+        mock_client.attachments.upload.return_value = uuid.uuid4()
+        mock_client.context_grounding.create_ephemeral_index.return_value = (
+            _make_index()
+        )
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "create-ephemeral",
+                "--usage",
+                "BatchRAG",
+                "--files",
+                str(f1),
+                "--files",
+                str(f2),
+            ],
+        )
+        assert result.exit_code == 0
+        assert mock_client.attachments.upload.call_count == 2
+
+    def test_create_ephemeral_missing_usage_fails(
+        self, runner, mock_env_vars, tmp_path
+    ):
+        f = tmp_path / "doc.pdf"
+        f.write_text("x")
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "create-ephemeral", "--files", str(f)],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# source-schema
+# ---------------------------------------------------------------------------
+
+
+class TestSourceSchemaCommand:
+    def test_source_schema_all(self, runner):
+        result = runner.invoke(cli, ["context-grounding", "source-schema"])
+        assert result.exit_code == 0
+        assert "google_drive" in result.output
+        assert "onedrive" in result.output
+        assert "dropbox" in result.output
+        assert "confluence" in result.output
+        assert "connection_id" in result.output
+
+    def test_source_schema_specific_type(self, runner):
+        result = runner.invoke(
+            cli, ["context-grounding", "source-schema", "--type", "confluence"]
+        )
+        assert result.exit_code == 0
+        assert "confluence" in result.output
+        assert "space_id" in result.output
+        assert "google_drive" not in result.output
+
+
+# ---------------------------------------------------------------------------
+# delete
+# ---------------------------------------------------------------------------
+
+
+class TestDeleteCommand:
+    def test_delete_with_confirm(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.return_value = _make_index()
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "delete",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+                "--confirm",
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.delete_by_name.assert_called_once_with(
+            name="my-index", folder_path="Shared", folder_key=None
+        )
+
+    def test_delete_dry_run(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.return_value = _make_index()
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "delete",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+                "--dry-run",
+            ],
+        )
+        assert result.exit_code == 0
+        assert "would delete" in result.output.lower()
+        mock_client.context_grounding.delete_by_name.assert_not_called()
+
+    def test_delete_prompts_no_cancels(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.return_value = _make_index()
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "delete",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+            ],
+            input="n\n",
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.delete_by_name.assert_not_called()
+
+    def test_delete_prompts_yes_deletes(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.return_value = _make_index()
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "delete",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+            ],
+            input="y\n",
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.delete_by_name.assert_called_once()
+
+    def test_delete_not_found(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.retrieve.side_effect = LookupError("not found")
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "delete",
+                "--index-name",
+                "missing",
+                "--folder-path",
+                "Shared",
+                "--confirm",
+            ],
+        )
+        assert result.exit_code != 0
+        assert "not found" in result.output.lower()
+
+    def test_delete_missing_index_name_fails(self, runner, mock_env_vars):
+        result = runner.invoke(cli, ["context-grounding", "delete", "--confirm"])
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# ingest
+# ---------------------------------------------------------------------------
+
+
+class TestIngestCommand:
+    def test_ingest_basic(self, runner, mock_client, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "ingest",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code == 0
+        assert "ingestion triggered" in result.output.lower()
+        mock_client.context_grounding.ingest_by_name.assert_called_once_with(
+            name="my-index", folder_path="Shared", folder_key=None
+        )
+
+    def test_ingest_missing_index_name_fails(self, runner, mock_env_vars):
+        result = runner.invoke(cli, ["context-grounding", "ingest"])
+        assert result.exit_code != 0
+
+    def test_ingest_with_folder_key(self, runner, mock_client, mock_env_vars):
+        fk = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "ingest",
+                "--index-name",
+                "my-index",
+                "--folder-key",
+                fk,
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.ingest_by_name.assert_called_once_with(
+            name="my-index", folder_path=None, folder_key=fk
+        )
+
+
+# ---------------------------------------------------------------------------
+# search
+# ---------------------------------------------------------------------------
+
+
+class TestSearchCommand:
+    def test_search_by_name(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.unified_search.return_value = []
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "search",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+                "--query",
+                "revenue",
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.unified_search.assert_called_once()
+        call_kwargs = mock_client.context_grounding.unified_search.call_args[1]
+        assert call_kwargs["name"] == "my-index"
+        assert call_kwargs["query"] == "revenue"
+
+    def test_search_with_limit(self, runner, mock_client, mock_env_vars):
+        mock_client.context_grounding.unified_search.return_value = []
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "search",
+                "--index-name",
+                "X",
+                "--folder-path",
+                "Shared",
+                "--query",
+                "test",
+                "--limit",
+                "3",
+            ],
+        )
+        assert result.exit_code == 0
+        call_kwargs = mock_client.context_grounding.unified_search.call_args[1]
+        assert call_kwargs["number_of_results"] == 3
+
+    def test_search_missing_query_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "search",
+                "--index-name",
+                "X",
+                "--folder-path",
+                "Shared",
+            ],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# deep-rag start
+# ---------------------------------------------------------------------------
+
+
+class TestDeepRagStartCommand:
+    def test_start_by_name(self, runner, mock_client, mock_env_vars):
+        mock_result = MagicMock()
+        mock_result.id = "task-123"
+        mock_result.model_dump.return_value = {"id": "task-123", "status": "Queued"}
+        mock_client.context_grounding.start_deep_rag.return_value = mock_result
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "deep-rag",
+                "start",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+                "--task-name",
+                "my-task",
+                "--prompt",
+                "Summarize",
+            ],
+        )
+        assert result.exit_code == 0
+        call_kwargs = mock_client.context_grounding.start_deep_rag.call_args[1]
+        assert call_kwargs["name"] == "my-task"
+        assert call_kwargs["index_name"] == "my-index"
+        assert call_kwargs["index_id"] is None
+
+    def test_start_by_id(self, runner, mock_client, mock_env_vars):
+        mock_result = MagicMock()
+        mock_result.id = "task-456"
+        mock_result.model_dump.return_value = {"id": "task-456"}
+        mock_client.context_grounding.start_deep_rag.return_value = mock_result
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "deep-rag",
+                "start",
+                "--index-id",
+                "idx-789",
+                "--task-name",
+                "my-task",
+                "--prompt",
+                "Summarize",
+            ],
+        )
+        assert result.exit_code == 0
+        call_kwargs = mock_client.context_grounding.start_deep_rag.call_args[1]
+        assert call_kwargs["index_id"] == "idx-789"
+        assert call_kwargs["index_name"] is None
+
+    def test_start_no_index_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "deep-rag",
+                "start",
+                "--task-name",
+                "T",
+                "--prompt",
+                "P",
+            ],
+        )
+        assert result.exit_code != 0
+
+    def test_start_both_index_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "deep-rag",
+                "start",
+                "--index-name",
+                "X",
+                "--index-id",
+                "Y",
+                "--task-name",
+                "T",
+                "--prompt",
+                "P",
+            ],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# deep-rag retrieve
+# ---------------------------------------------------------------------------
+
+
+class TestDeepRagRetrieveCommand:
+    def test_retrieve(self, runner, mock_client, mock_env_vars):
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {"id": "task-123", "status": "Successful"}
+        mock_client.context_grounding.retrieve_deep_rag.return_value = mock_result
+
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "deep-rag", "retrieve", "--task-id", "task-123"],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.retrieve_deep_rag.assert_called_once_with(
+            id="task-123"
+        )
+
+    def test_retrieve_missing_task_id_fails(self, runner, mock_env_vars):
+        result = runner.invoke(cli, ["context-grounding", "deep-rag", "retrieve"])
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# batch-transform start
+# ---------------------------------------------------------------------------
+
+
+class TestBatchTransformStartCommand:
+    def test_start_by_name(self, runner, mock_client, mock_env_vars, tmp_path):
+        cols_file = tmp_path / "cols.json"
+        cols_file.write_text(
+            json.dumps([{"name": "entity", "description": "Entity name"}])
+        )
+
+        mock_result = MagicMock()
+        mock_result.id = "bt-123"
+        mock_result.model_dump.return_value = {"id": "bt-123"}
+        mock_client.context_grounding.start_batch_transform.return_value = mock_result
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "batch-transform",
+                "start",
+                "--index-name",
+                "my-index",
+                "--folder-path",
+                "Shared",
+                "--task-name",
+                "my-task",
+                "--prompt",
+                "Extract entities",
+                "--columns-file",
+                str(cols_file),
+            ],
+        )
+        assert result.exit_code == 0
+        call_kwargs = mock_client.context_grounding.start_batch_transform.call_args[1]
+        assert call_kwargs["name"] == "my-task"
+        assert call_kwargs["index_name"] == "my-index"
+
+    def test_start_by_id(self, runner, mock_client, mock_env_vars, tmp_path):
+        cols_file = tmp_path / "cols.json"
+        cols_file.write_text(json.dumps([{"name": "col1", "description": "Col"}]))
+
+        mock_result = MagicMock()
+        mock_result.id = "bt-456"
+        mock_result.model_dump.return_value = {"id": "bt-456"}
+        mock_client.context_grounding.start_batch_transform.return_value = mock_result
+
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "batch-transform",
+                "start",
+                "--index-id",
+                "idx-789",
+                "--task-name",
+                "my-task",
+                "--prompt",
+                "Extract",
+                "--columns-file",
+                str(cols_file),
+            ],
+        )
+        assert result.exit_code == 0
+        call_kwargs = mock_client.context_grounding.start_batch_transform.call_args[1]
+        assert call_kwargs["index_id"] == "idx-789"
+        assert call_kwargs["index_name"] is None
+
+    def test_start_no_index_fails(self, runner, mock_env_vars, tmp_path):
+        cols_file = tmp_path / "cols.json"
+        cols_file.write_text("[]")
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "batch-transform",
+                "start",
+                "--task-name",
+                "T",
+                "--prompt",
+                "P",
+                "--columns-file",
+                str(cols_file),
+            ],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# batch-transform retrieve
+# ---------------------------------------------------------------------------
+
+
+class TestBatchTransformRetrieveCommand:
+    def test_retrieve(self, runner, mock_client, mock_env_vars):
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {"id": "bt-123", "status": "Successful"}
+        mock_client.context_grounding.retrieve_batch_transform.return_value = (
+            mock_result
+        )
+
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "batch-transform", "retrieve", "--task-id", "bt-123"],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.retrieve_batch_transform.assert_called_once_with(
+            id="bt-123"
+        )
+
+
+# ---------------------------------------------------------------------------
+# batch-transform download
+# ---------------------------------------------------------------------------
+
+
+class TestBatchTransformDownloadCommand:
+    def test_download(self, runner, mock_client, mock_env_vars, tmp_path):
+        out_file = str(tmp_path / "result.csv")
+        result = runner.invoke(
+            cli,
+            [
+                "context-grounding",
+                "batch-transform",
+                "download",
+                "--task-id",
+                "bt-123",
+                "--output-file",
+                out_file,
+            ],
+        )
+        assert result.exit_code == 0
+        mock_client.context_grounding.download_batch_transform_result.assert_called_once_with(
+            id="bt-123", destination_path=out_file
+        )
+        assert "downloaded" in result.output.lower()
+
+    def test_download_missing_output_file_fails(self, runner, mock_env_vars):
+        result = runner.invoke(
+            cli,
+            ["context-grounding", "batch-transform", "download", "--task-id", "bt-123"],
+        )
+        assert result.exit_code != 0
+
+
+# ---------------------------------------------------------------------------
+# help text
+# ---------------------------------------------------------------------------
+
+
+class TestHelpText:
+    def test_group_help(self, runner):
+        result = runner.invoke(cli, ["context-grounding", "--help"])
+        assert result.exit_code == 0
+        assert "Two index types" in result.output
+        assert "Regular" in result.output
+        assert "Ephemeral" in result.output
+        for cmd in [
+            "list",
+            "retrieve",
+            "create",
+            "create-ephemeral",
+            "delete",
+            "ingest",
+            "search",
+            "source-schema",
+            "deep-rag",
+            "batch-transform",
+        ]:
+            assert cmd in result.output
+
+    def test_retrieve_help(self, runner):
+        result = runner.invoke(cli, ["context-grounding", "retrieve", "--help"])
+        assert result.exit_code == 0
+        assert "--index-name" in result.output
+        assert "--index-id" in result.output
+
+    def test_deep_rag_start_help(self, runner):
+        result = runner.invoke(
+            cli, ["context-grounding", "deep-rag", "start", "--help"]
+        )
+        assert result.exit_code == 0
+        assert "--index-name" in result.output
+        assert "--index-id" in result.output
+        assert "--task-name" in result.output
+        assert "--prompt" in result.output
+
+    def test_batch_transform_start_help(self, runner):
+        result = runner.invoke(
+            cli, ["context-grounding", "batch-transform", "start", "--help"]
+        )
+        assert result.exit_code == 0
+        assert "--columns-file" in result.output
+        assert "--task-name" in result.output
diff --git a/packages/uipath/tests/cli/integration/test_list_models_commands.py b/packages/uipath/tests/cli/integration/test_list_models_commands.py
new file mode 100644
index 000000000..c7cb9f042
--- /dev/null
+++ b/packages/uipath/tests/cli/integration/test_list_models_commands.py
@@ -0,0 +1,233 @@
+"""Integration tests for the `uipath list-models` CLI command.
+
+The command renders a rich table grouped by vendor (one column per vendor)
+for human terminal use, and falls through to the shared `format_output`
+pipeline for `--format json|csv` and `--output <file>`.
+"""
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath.platform.agenthub import LlmModel
+
+
+@pytest.fixture
+def runner():
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Provide a mocked UiPath client with an async agenthub service."""
+    with patch("uipath.platform._uipath.UiPath") as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+
+        client_instance.agenthub = MagicMock()
+        client_instance.agenthub.get_available_llm_models_async = AsyncMock()
+
+        yield client_instance
+
+
+def _make_models() -> list[LlmModel]:
+    """Build a small list of LlmModel instances spanning multiple vendors."""
+    return [
+        LlmModel(model_name="gpt-4o-mini", vendor="OpenAi"),
+        LlmModel(model_name="gpt-4.1", vendor="OpenAi"),
+        LlmModel(model_name="claude-sonnet-4-5", vendor="Anthropic"),
+        LlmModel(model_name="gemini-2.5-flash", vendor="VertexAi"),
+    ]
+
+
+class TestRichTable:
+    def test_renders_each_model_and_vendor(self, runner, mock_client, mock_env_vars):
+        """All models and vendor headers appear in the rendered table."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code == 0
+        for model in _make_models():
+            assert model.model_name in result.output
+            assert (model.vendor or "") in result.output
+        mock_client.agenthub.get_available_llm_models_async.assert_awaited_once()
+
+    def test_table_title(self, runner, mock_client, mock_env_vars):
+        """The rich table renders its title for orientation."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code == 0
+        assert "Available LLM Models" in result.output
+
+    def test_missing_vendor_grouped_under_unknown(
+        self, runner, mock_client, mock_env_vars
+    ):
+        """A model with no vendor lands in an 'Unknown' column."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = [
+            LlmModel(model_name="custom-model", vendor=None),
+        ]
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code == 0
+        assert "custom-model" in result.output
+        assert "Unknown" in result.output
+
+    def test_empty(self, runner, mock_client, mock_env_vars):
+        """An empty model list renders the title without rows or errors."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = []
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code == 0
+        assert "Available LLM Models" in result.output
+
+
+class TestMachineReadableFormats:
+    def test_json_format(self, runner, mock_client, mock_env_vars):
+        """--format json bypasses the rich table and emits parseable JSON."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list-models", "--format", "json"])
+
+        assert result.exit_code == 0
+        payload = json.loads(result.output)
+        assert isinstance(payload, list)
+        assert {m["model_name"] for m in payload} == {
+            "gpt-4o-mini",
+            "gpt-4.1",
+            "claude-sonnet-4-5",
+            "gemini-2.5-flash",
+        }
+
+    def test_csv_format(self, runner, mock_client, mock_env_vars):
+        """--format csv emits a header row and one row per model."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list-models", "--format", "csv"])
+
+        assert result.exit_code == 0
+        lines = [line for line in result.output.splitlines() if line.strip()]
+        assert "model_name" in lines[0]
+        assert "vendor" in lines[0]
+        assert any("gpt-4o-mini" in line for line in lines[1:])
+
+    def test_global_json_flag(self, runner, mock_client, mock_env_vars):
+        """The cli-group --format json is honored too."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["--format", "json", "list-models"])
+
+        assert result.exit_code == 0
+        payload = json.loads(result.output)
+        assert len(payload) == 4
+
+    def test_output_writes_through_plain_formatter(
+        self, runner, mock_client, mock_env_vars, tmp_path
+    ):
+        """--output writes through format_output (not the rich path)."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+        out_file = tmp_path / "models.json"
+
+        result = runner.invoke(
+            cli,
+            ["list-models", "--format", "json", "--output", str(out_file)],
+        )
+
+        assert result.exit_code == 0
+        assert out_file.exists()
+        payload = json.loads(out_file.read_text(encoding="utf-8"))
+        assert {m["model_name"] for m in payload} == {
+            "gpt-4o-mini",
+            "gpt-4.1",
+            "claude-sonnet-4-5",
+            "gemini-2.5-flash",
+        }
+
+    def test_output_file_alias(self, runner, mock_client, mock_env_vars, tmp_path):
+        """`--output-file` works as an alias for `--output` (matches `run`)."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+        out_file = tmp_path / "models.json"
+
+        result = runner.invoke(
+            cli,
+            ["list-models", "--format", "json", "--output-file", str(out_file)],
+        )
+
+        assert result.exit_code == 0
+        assert out_file.exists()
+        payload = json.loads(out_file.read_text(encoding="utf-8"))
+        assert len(payload) == 4
+
+
+class TestErrorPaths:
+    def test_service_error(self, runner, mock_client, mock_env_vars):
+        """Exceptions from the service are surfaced as click errors."""
+        mock_client.agenthub.get_available_llm_models_async.side_effect = RuntimeError(
+            "boom"
+        )
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code != 0
+        assert "boom" in result.output
+
+    def test_missing_url(self, runner, monkeypatch):
+        """Missing UIPATH_URL surfaces an auth-configuration error."""
+        monkeypatch.delenv("UIPATH_URL", raising=False)
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "mock_token")
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code != 0
+        assert "UIPATH_URL not configured" in result.output
+
+    def test_missing_token(self, runner, monkeypatch):
+        """Missing UIPATH_ACCESS_TOKEN surfaces an auth-configuration error."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.delenv("UIPATH_ACCESS_TOKEN", raising=False)
+
+        result = runner.invoke(cli, ["list-models"])
+
+        assert result.exit_code != 0
+        assert "Authentication required" in result.output
+
+
+class TestRegistration:
+    def test_help_text(self, runner):
+        """--help surfaces the command description and options."""
+        result = runner.invoke(cli, ["list-models", "--help"])
+
+        assert result.exit_code == 0
+        assert "List available LLM models" in result.output
+        assert "--format" in result.output
+        assert "--output" in result.output
+        assert "--output-file" in result.output
+
+    def test_registered_in_cli(self, runner):
+        """The command is wired into the top-level CLI group."""
+        result = runner.invoke(cli, ["--help"])
+
+        assert result.exit_code == 0
+        assert "list-models" in result.output
diff --git a/tests/cli/mocks/pyproject.toml b/packages/uipath/tests/cli/mocks/pyproject.toml
similarity index 77%
rename from tests/cli/mocks/pyproject.toml
rename to packages/uipath/tests/cli/mocks/pyproject.toml
index 0e85471f4..0f64ee288 100644
--- a/tests/cli/mocks/pyproject.toml
+++ b/packages/uipath/tests/cli/mocks/pyproject.toml
@@ -1,9 +1,9 @@
 [project]
-name = "project name"
+name = "project_name"
 version = "0.0.1"
 description = "project description"
 authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
 dependencies = [
     "uipath>=2.0.0",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
diff --git a/tests/cli/mocks/simple_script.py b/packages/uipath/tests/cli/mocks/simple_script.py
similarity index 81%
rename from tests/cli/mocks/simple_script.py
rename to packages/uipath/tests/cli/mocks/simple_script.py
index 1169dac98..eb3265455 100644
--- a/tests/cli/mocks/simple_script.py
+++ b/packages/uipath/tests/cli/mocks/simple_script.py
@@ -1,12 +1,11 @@
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class EchoIn:
     message: str
-    repeat: Optional[int] = 1
-    prefix: Optional[str] = None
+    repeat: int | None = 1
+    prefix: str | None = None
 
 
 @dataclass
diff --git a/tests/cli/mocks/uipath-mock.json b/packages/uipath/tests/cli/mocks/uipath-mock-legacy.json
similarity index 100%
rename from tests/cli/mocks/uipath-mock.json
rename to packages/uipath/tests/cli/mocks/uipath-mock-legacy.json
diff --git a/tests/cli/mocks/uipath-simple-script-mock.json b/packages/uipath/tests/cli/mocks/uipath-simple-script-mock.json
similarity index 100%
rename from tests/cli/mocks/uipath-simple-script-mock.json
rename to packages/uipath/tests/cli/mocks/uipath-simple-script-mock.json
diff --git a/packages/uipath/tests/cli/models/test_entrypoints.py b/packages/uipath/tests/cli/models/test_entrypoints.py
new file mode 100644
index 000000000..46c98cb5b
--- /dev/null
+++ b/packages/uipath/tests/cli/models/test_entrypoints.py
@@ -0,0 +1,116 @@
+import json
+
+from uipath._cli.models.runtime_schema import EntryPoint, EntryPoints
+
+
+class TestEntryPointModel:
+    def test_entrypoint_from_dict(self) -> None:
+        data = {
+            "filePath": "agent",
+            "uniqueId": "f620a11e-90fa-4506-8859-d8f147fdc31d",
+            "type": "agent",
+            "input": {"type": "object", "properties": {}},
+            "output": {"type": "string"},
+        }
+        ep = EntryPoint.model_validate(data)
+        assert ep.file_path == "agent"
+        assert ep.type == "agent"
+        assert ep.graph is None
+        assert ep.metadata is None
+
+    def test_entrypoint_with_graph(self) -> None:
+        data = {
+            "filePath": "agent",
+            "uniqueId": "f620a11e-90fa-4506-8859-d8f147fdc31d",
+            "type": "agent",
+            "input": {"type": "object", "properties": {}},
+            "output": {"type": "string"},
+            "graph": {
+                "nodes": [{"id": "n1", "name": "main", "type": "function"}],
+                "edges": [],
+            },
+        }
+        ep = EntryPoint.model_validate(data)
+        assert ep.graph is not None
+        assert len(ep.graph["nodes"]) == 1
+
+    def test_entrypoint_roundtrip(self) -> None:
+        data = {
+            "filePath": "func",
+            "uniqueId": "00000000-0000-0000-0000-000000000000",
+            "type": "function",
+            "input": {"type": "object", "properties": {"x": {"type": "string"}}},
+            "output": {"type": "string"},
+        }
+        ep = EntryPoint.model_validate(data)
+        dumped = ep.model_dump(by_alias=True, exclude_none=True)
+        assert dumped["filePath"] == "func"
+        assert dumped["type"] == "function"
+        assert "graph" not in dumped
+
+
+class TestEntryPointsModel:
+    def test_entrypoints_from_file_content(self) -> None:
+        content = {
+            "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+            "$id": "entry-points.json",
+            "entryPoints": [
+                {
+                    "filePath": "agent",
+                    "uniqueId": "f620a11e-90fa-4506-8859-d8f147fdc31d",
+                    "type": "agent",
+                    "input": {"type": "object", "properties": {}},
+                    "output": {"type": "string"},
+                },
+                {
+                    "filePath": "function",
+                    "uniqueId": "0c34d779-78b1-4902-8657-a0ebf65d66af",
+                    "type": "function",
+                    "input": {"type": "object", "properties": {}},
+                    "output": {"type": "string"},
+                },
+            ],
+        }
+        eps = EntryPoints.model_validate(content)
+        assert len(eps.entrypoints) == 2
+        assert eps.entrypoints[0].type == "agent"
+        assert eps.entrypoints[1].type == "function"
+
+    def test_entrypoints_roundtrip(self) -> None:
+        content = {
+            "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+            "$id": "entry-points.json",
+            "entryPoints": [
+                {
+                    "filePath": "main",
+                    "uniqueId": "00000000-0000-0000-0000-000000000000",
+                    "type": "function",
+                    "input": {"type": "object", "properties": {}},
+                    "output": {"type": "string"},
+                },
+            ],
+        }
+        eps = EntryPoints.model_validate(content)
+        dumped = eps.model_dump(by_alias=True, exclude_none=True)
+        assert dumped["$schema"] == content["$schema"]
+        assert dumped["$id"] == content["$id"]
+        assert len(dumped["entryPoints"]) == 1
+
+    def test_entrypoints_json_serialization(self) -> None:
+        content = {
+            "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+            "$id": "entry-points.json",
+            "entryPoints": [
+                {
+                    "filePath": "test",
+                    "uniqueId": "00000000-0000-0000-0000-000000000000",
+                    "type": "agent",
+                    "input": {"type": "object", "properties": {}},
+                    "output": {"type": "string"},
+                },
+            ],
+        }
+        eps = EntryPoints.model_validate(content)
+        json_str = eps.model_dump_json(by_alias=True, exclude_none=True)
+        parsed = json.loads(json_str)
+        assert parsed["entryPoints"][0]["type"] == "agent"
diff --git a/packages/uipath/tests/cli/models/test_runtime_schema.py b/packages/uipath/tests/cli/models/test_runtime_schema.py
new file mode 100644
index 000000000..6ed8fa1d1
--- /dev/null
+++ b/packages/uipath/tests/cli/models/test_runtime_schema.py
@@ -0,0 +1,141 @@
+from typing import Any
+
+from pydantic import TypeAdapter
+
+from uipath._cli.models.uipath_json_schema import UiPathJsonConfig
+
+
+def test_uipath_config_validation():
+    # Arrange
+    config: dict[str, Any] = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+        "runtimeOptions": {"isConversational": False},
+        "designOptions": {"theme": "dark", "autoSave": True},
+        "packOptions": {
+            "fileExtensionsIncluded": [".py", ".json", ".yaml", ".md"],
+            "filesIncluded": ["pyproject.toml", "README.md"],
+            "filesExcluded": ["secret.env", ".env.local"],
+            "directoriesExcluded": ["tests", "venv"],
+            "includeUvLock": True,
+        },
+        "functions": {
+            "main": "src/main.py:main",
+            "process": "src/graph.py:run",
+            "generateReport": "src/reporting.py:generate_report",
+            "cleanup": "scripts/cleanup.py:cleanup_resources",
+        },
+    }
+
+    # Act and Assert
+    TypeAdapter(UiPathJsonConfig).validate_python(config)
+
+
+def test_uipath_config_minimal():
+    """Test minimal valid configuration."""
+    # Arrange
+    config = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/uipath",
+        "runtimeOptions": {"isConversational": False},
+        "packOptions": {
+            "fileExtensionsIncluded": [],
+            "filesIncluded": [],
+            "filesExcluded": [],
+            "directoriesExcluded": [],
+            "includeUvLock": True,
+        },
+        "functions": {},
+    }
+
+    # Act and Assert
+    validated = TypeAdapter(UiPathJsonConfig).validate_python(config)
+    assert validated.runtime_options.is_conversational is False
+    assert validated.pack_options.include_uv_lock is True
+    assert validated.functions == {}
+
+
+def test_uipath_config_defaults():
+    """Test that default values work correctly."""
+    # Arrange
+    config: dict[str, Any] = {}
+
+    # Act
+    validated = TypeAdapter(UiPathJsonConfig).validate_python(config)
+
+    # Assert
+    assert validated.schema_ == "https://cloud.uipath.com/draft/2024-12/uipath"
+    assert validated.runtime_options.is_conversational is False
+    assert validated.pack_options.include_uv_lock is True
+    assert validated.functions == {}
+
+
+def test_uipath_config_functions_validation():
+    """Test functions field with various entrypoint formats."""
+    # Arrange
+    config = {
+        "functions": {
+            "main": "src/main.py:main",
+            "process": "processor.py:process_data",
+            "echo": "utils/echo.py:echo_function",
+        }
+    }
+
+    # Act
+    validated = TypeAdapter(UiPathJsonConfig).validate_python(config)
+
+    # Assert
+    assert len(validated.functions) == 3
+    assert validated.functions["main"] == "src/main.py:main"
+    assert validated.functions["process"] == "processor.py:process_data"
+    assert validated.functions["echo"] == "utils/echo.py:echo_function"
+
+
+def test_uipath_config_runtime_options():
+    """Test runtime options variations."""
+    # Arrange - conversational mode enabled
+    config = {"runtimeOptions": {"isConversational": True}}
+
+    # Act
+    validated = TypeAdapter(UiPathJsonConfig).validate_python(config)
+
+    # Assert
+    assert validated.runtime_options.is_conversational is True
+
+
+def test_uipath_config_pack_options():
+    """Test pack options with various configurations."""
+    # Arrange
+    config = {
+        "packOptions": {
+            "fileExtensionsIncluded": [".py", ".md"],
+            "filesIncluded": ["README.md", "LICENSE"],
+            "filesExcluded": [".env", "secrets.json"],
+            "directoriesExcluded": ["__pycache__", ".git"],
+            "includeUvLock": False,
+        }
+    }
+
+    # Act
+    validated = TypeAdapter(UiPathJsonConfig).validate_python(config)
+
+    # Assert
+    assert validated.pack_options.file_extensions_included == [".py", ".md"]
+    assert validated.pack_options.files_included == ["README.md", "LICENSE"]
+    assert validated.pack_options.files_excluded == [".env", "secrets.json"]
+    assert validated.pack_options.directories_excluded == ["__pycache__", ".git"]
+    assert validated.pack_options.include_uv_lock is False
+
+
+def test_uipath_config_to_json_string():
+    """Test JSON serialization."""
+    # Arrange
+    config = UiPathJsonConfig.create_default()
+    config.functions["test"] = "test.py:test_func"
+
+    # Act
+    json_output = config.to_json_string()
+
+    # Assert
+    assert '"$schema"' in json_output
+    assert '"isConversational": false' in json_output
+    assert '"includeUvLock": true' in json_output
+    assert '"test": "test.py:test_func"' in json_output
diff --git a/packages/uipath/tests/cli/test_auth.py b/packages/uipath/tests/cli/test_auth.py
new file mode 100644
index 000000000..e400b29dd
--- /dev/null
+++ b/packages/uipath/tests/cli/test_auth.py
@@ -0,0 +1,220 @@
+import os
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+
+"""
+Unit tests for the 'uipath auth' command.
+
+This test suite covers the following scenarios for the authentication logic:
+
+1.  **UIPATH_URL Environment Variable**:
+    Ensures the `auth` command correctly uses the domain from the `UIPATH_URL`
+    environment variable when no specific environment flag is used.
+
+2.  **--alpha Flag**:
+    Verifies that the `--alpha` flag correctly uses the 'alpha' environment and
+    overrides the `UIPATH_URL` environment variable if it is set.
+
+3.  **--staging Flag**:
+    Verifies that the `--staging` flag correctly uses the 'staging' environment and
+    overrides the `UIPATH_URL` environment variable if it is set.
+
+4.  **--cloud Flag**:
+    Checks that the `--cloud` flag works as expected, using the 'cloud' environment,
+    when no `UIPATH_URL` environment variable is set.
+
+5.  **Default Behavior**:
+    Confirms that the command defaults to the 'cloud' environment when no flags
+    or environment variables are provided.
+"""
+
+
+class TestAuth:
+    @pytest.mark.parametrize(
+        "scenario_name, cli_args, env_vars, expected_url_part, expected_select_tenant_return",
+        [
+            (
+                "auth_with_uipath_url_env_variable",
+                ["--force"],
+                {"UIPATH_URL": "https://custom.automationsuite.org/org/tenant"},
+                "https://custom.automationsuite.org/identity_/connect/authorize",
+                "https://custom.automationsuite.org/DefaultOrg/DefaultTenant",
+            ),
+            (
+                "auth_with_uipath_url_env_variable_with_trailing_slash",
+                ["--force"],
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"},
+                "https://custom.uipath.com/identity_/connect/authorize",
+                "https://custom.uipath.com/DefaultOrg/DefaultTenant",
+            ),
+            (
+                "auth_with_alpha_flag",
+                ["--alpha", "--force"],
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+                "https://alpha.uipath.com/identity_/connect/authorize",
+                "https://alpha.uipath.com/DefaultOrg/DefaultTenant",
+            ),
+            (
+                "auth_with_staging_flag",
+                ["--staging", "--force"],
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+                "https://staging.uipath.com/identity_/connect/authorize",
+                "https://staging.uipath.com/DefaultOrg/DefaultTenant",
+            ),
+            (
+                "auth_with_cloud_flag",
+                ["--cloud", "--force"],
+                {},
+                "https://cloud.uipath.com/identity_/connect/authorize",
+                "https://cloud.uipath.com/DefaultOrg/DefaultTenant",
+            ),
+            (
+                "auth_default_to_cloud",
+                ["--force"],
+                {},
+                "https://cloud.uipath.com/identity_/connect/authorize",
+                "https://cloud.uipath.com/DefaultOrg/DefaultTenant",
+            ),
+        ],
+        ids=[
+            "uipath_url_env",
+            "uipath_url_env_with_trailing_slash",
+            "alpha_flag_overrides_env",
+            "staging_flag_overrides_env",
+            "cloud_flag",
+            "default_to_cloud",
+        ],
+    )
+    def test_auth_scenarios(
+        self,
+        scenario_name,
+        cli_args,
+        env_vars,
+        expected_url_part,
+        expected_select_tenant_return,
+    ):
+        """
+        Test 'uipath auth' with different configurations.
+        """
+        runner = CliRunner()
+        with (
+            patch("uipath._cli._auth._auth_service.webbrowser.open") as mock_open,
+            patch("uipath._cli._auth._auth_service.HTTPServer") as mock_server,
+            patch("uipath._cli._auth._auth_service.AuthSession") as mock_auth_session,
+            patch("uipath.platform.UiPath") as mock_uipath,
+        ):
+            mock_uipath.return_value.orchestrator_setup.enable_first_run_async = (
+                AsyncMock()
+            )
+            mock_server.return_value.start = AsyncMock(
+                return_value={"access_token": "test_token"}
+            )
+            session = mock_auth_session.return_value
+            session.get_tenants_and_organizations = AsyncMock(
+                return_value={
+                    "tenants": [{"name": "DefaultTenant", "id": "tenant-id"}],
+                    "organization": {"name": "DefaultOrg", "id": "org-id"},
+                }
+            )
+            session._select_tenant = AsyncMock(
+                return_value={
+                    "tenant_id": "tenant-id",
+                    "organization_id": "org-id",
+                }
+            )
+            session.resolve_tenant_info = AsyncMock(
+                return_value={
+                    "tenant_id": "tenant-id",
+                    "organization_id": "org-id",
+                }
+            )
+            session.build_tenant_url = AsyncMock(
+                return_value=expected_select_tenant_return,
+            )
+
+            with runner.isolated_filesystem():
+                for key, value in env_vars.items():
+                    os.environ[key] = value
+
+                result = runner.invoke(cli, ["auth"] + cli_args)
+
+                for key in env_vars:
+                    del os.environ[key]
+
+                assert result.exit_code == 0, (
+                    f"Scenario '{scenario_name}' failed with exit code {result.exit_code}: {result.output}"
+                )
+                mock_open.assert_called_once()
+                call_args = mock_open.call_args[0][0]
+                assert expected_url_part in call_args
+
+    def test_auth_with_malformed_url(self):
+        """
+        Test that 'uipath auth' handles a malformed UIPATH_URL gracefully.
+        """
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            os.environ["UIPATH_URL"] = "custom.uipath.com"
+            result = runner.invoke(cli, ["auth"])
+            del os.environ["UIPATH_URL"]
+
+            assert result.exit_code == 1
+            assert "Malformed UIPATH_URL" in result.output
+            assert "custom.uipath.com" in result.output
+
+    def test_auth_with_tenant_flag(self):
+        """
+        Test that providing --tenant bypasses interactive tenant selection
+        and uses the specified tenant name.
+        """
+        runner = CliRunner()
+        with (
+            patch("uipath._cli._auth._auth_service.webbrowser.open") as mock_open,
+            patch("uipath._cli._auth._auth_service.HTTPServer") as mock_server,
+            patch("uipath._cli._auth._auth_service.AuthSession") as mock_auth_session,
+            patch(
+                "uipath._cli._auth._url_utils.resolve_domain",
+                return_value="https://alpha.uipath.com",
+            ),
+            patch("uipath.platform.UiPath") as mock_uipath,
+        ):
+            mock_uipath.return_value.orchestrator_setup.enable_first_run_async = (
+                AsyncMock()
+            )
+            mock_server.return_value.start = AsyncMock(
+                return_value={"access_token": "test_token"}
+            )
+
+            session = mock_auth_session.return_value
+            session.get_tenants_and_organizations = AsyncMock(
+                return_value={
+                    "tenants": [
+                        {"name": "MyTenantName", "id": "tenant-id"},
+                        {"name": "OtherTenant", "id": "other-id"},
+                    ],
+                    "organization": {"name": "MyOrg", "id": "org-id"},
+                }
+            )
+            session.resolve_tenant_info = AsyncMock(
+                return_value={
+                    "tenant_id": "tenant-id",
+                    "organization_id": "org-id",
+                }
+            )
+            session.build_tenant_url = AsyncMock(
+                return_value="https://alpha.uipath.com/MyOrg/MyTenantName",
+            )
+            session.selected_tenant = "MyTenantName"
+            with runner.isolated_filesystem():
+                result = runner.invoke(
+                    cli, ["auth", "--alpha", "--tenant", "MyTenantName", "--force"]
+                )
+
+                assert result.exit_code == 0, result.output
+                mock_open.assert_called_once()
+
+                session.resolve_tenant_info.assert_called_once_with("MyTenantName")
diff --git a/packages/uipath/tests/cli/test_auth_server.py b/packages/uipath/tests/cli/test_auth_server.py
new file mode 100644
index 000000000..f81d2c08b
--- /dev/null
+++ b/packages/uipath/tests/cli/test_auth_server.py
@@ -0,0 +1,138 @@
+"""Security tests for the OAuth local callback server.
+
+Covers GHSA-32xc-7x5c-8vmf: the `/set_token` and `/log` endpoints must reject
+unauthenticated POSTs (no / wrong OAuth `state`), and the server must bind to
+loopback only rather than all interfaces.
+"""
+
+import json
+import os
+import threading
+import urllib.error
+import urllib.request
+
+from uipath._cli._auth._auth_server import HTTPServer
+
+STATE = "LEGITIMATE_OAUTH_STATE_ABCDE12345"
+CODE_VERIFIER = "LEGITIMATE_PKCE_CODE_VERIFIER"
+DOMAIN = "cloud.uipath.com"
+
+ATTACKER_PAYLOAD = {
+    "access_token": "attacker-token",
+    "refresh_token": "attacker-refresh",
+    "expires_in": 3600,
+    "token_type": "Bearer",
+    "scope": "offline_access",
+}
+
+
+def _request(port, path, data, headers=None, method="POST"):
+    req = urllib.request.Request(
+        f"http://127.0.0.1:{port}{path}",
+        data=data,
+        headers=headers or {},
+        method=method,
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return resp.status, resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8")
+
+
+def _post(port, path, body, headers=None):
+    return _request(
+        port,
+        path,
+        json.dumps(body).encode("utf-8"),
+        {"Content-Type": "application/json", **(headers or {})},
+    )
+
+
+async def test_endpoints_reject_unauthenticated_posts(tmp_path, monkeypatch):
+    """Only requests carrying the matching OAuth state are accepted.
+
+    Exercises both /set_token and /log with missing, wrong, and valid state.
+    """
+    monkeypatch.chdir(tmp_path)
+
+    # Binding happens in create_server; the listen socket is up before the
+    # handler thread starts, so connections queue and no readiness sleep is
+    # needed. redirect_uri/client_id are required by the GET (index.html) path.
+    server = HTTPServer(
+        port=0, redirect_uri="http://localhost/callback", client_id="test-client"
+    )
+    httpd = server.create_server(STATE, CODE_VERIFIER, DOMAIN)
+    port = httpd.server_address[1]
+
+    results = {}
+
+    def client():
+        # DNS rebinding
+        results["rebind_get"] = _request(
+            port, "/", None, {"Host": "not-localhost.com"}, method="GET"
+        )
+        results["rebind_post"] = _post(
+            port,
+            "/set_token",
+            ATTACKER_PAYLOAD,
+            {"X-Auth-State": STATE, "Host": "evil.com"},
+        )
+        # GET serves index.html with the OAuth params substituted in.
+        results["get"] = _request(port, "/anything", None, method="GET")
+        # /set_token: missing and wrong state are rejected.
+        results["set_missing"] = _post(port, "/set_token", ATTACKER_PAYLOAD)
+        results["set_wrong"] = _post(
+            port, "/set_token", ATTACKER_PAYLOAD, {"X-Auth-State": "not-the-state"}
+        )
+        # Valid state but a non-JSON body -> graceful 400, not 500.
+        results["set_malformed"] = _request(
+            port, "/set_token", b"not json", {"X-Auth-State": STATE}
+        )
+        # Unknown path -> 404.
+        results["unknown"] = _post(port, "/nope", {"x": 1}, {"X-Auth-State": STATE})
+        # /log: missing and valid state.
+        results["log_missing"] = _post(port, "/log", {"msg": "x"})
+        results["log_valid"] = _post(
+            port, "/log", {"msg": "x"}, {"X-Auth-State": STATE}
+        )
+        # Valid /set_token last, to capture the token and unblock start().
+        results["set_valid"] = _post(
+            port, "/set_token", {"access_token": "real"}, {"X-Auth-State": STATE}
+        )
+
+    t = threading.Thread(target=client, daemon=True)
+    t.start()
+    token_data = await server.start(STATE, CODE_VERIFIER, DOMAIN)
+    t.join(timeout=5)
+
+    # DNS rebinding: forged Host is rejected on both GET and POST.
+    assert results["rebind_get"][0] == 403
+    assert results["rebind_post"][0] == 403
+
+    # GET returns the page with the real state injected, placeholder gone.
+    assert results["get"][0] == 200
+    assert STATE in results["get"][1]
+    assert "__PY_REPLACE_EXPECTED_STATE__" not in results["get"][1]
+
+    assert results["set_missing"][0] == 403
+    assert results["set_wrong"][0] == 403
+    assert results["set_malformed"][0] == 400
+    assert results["unknown"][0] == 404
+    assert results["log_missing"][0] == 403
+    assert results["log_valid"][0] == 200
+    assert results["set_valid"][0] == 200
+
+    # Only the valid, state-bearing request was accepted.
+    assert token_data == {"access_token": "real"}
+    # The state-protected /log write happened for the valid request only.
+    assert os.path.exists(tmp_path / ".uipath" / ".error_log")
+
+
+def test_server_binds_to_loopback_only():
+    server = HTTPServer(port=0)
+    httpd = server.create_server(STATE, CODE_VERIFIER, DOMAIN)
+    try:
+        assert httpd.server_address[0] == "127.0.0.1"
+    finally:
+        httpd.server_close()
diff --git a/packages/uipath/tests/cli/test_auth_session.py b/packages/uipath/tests/cli/test_auth_session.py
new file mode 100644
index 000000000..58201945b
--- /dev/null
+++ b/packages/uipath/tests/cli/test_auth_session.py
@@ -0,0 +1,504 @@
+"""Tests for AuthSession (refresh_access_token and ensure_valid_token)."""
+
+import os
+import time
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from uipath._cli._auth._auth_service import AuthService
+from uipath._cli._auth._auth_session import AuthSession
+from uipath.platform.common import TokenData
+from uipath.runtime.errors import UiPathRuntimeError
+
+
+@pytest.fixture
+def mock_auth_config():
+    return {
+        "client_id": "test_client_id",
+        "port": 8104,
+        "redirect_uri": "http://localhost:8104/callback",
+        "scope": "openid profile offline_access",
+    }
+
+
+@pytest.fixture
+def sample_token_data():
+    return TokenData(
+        access_token="new_access_token_123",
+        refresh_token="new_refresh_token_456",
+        expires_in=3600,
+        token_type="Bearer",
+        scope="openid profile offline_access",
+        id_token="id_token_789",
+    )
+
+
+class TestAuthSessionRefreshToken:
+    @pytest.mark.parametrize(
+        "environment, expected_domain",
+        [
+            ("cloud", "https://cloud.uipath.com"),
+            ("alpha", "https://alpha.uipath.com"),
+            ("staging", "https://staging.uipath.com"),
+        ],
+    )
+    async def test_refresh_different_domains(
+        self, environment, expected_domain, mock_auth_config, sample_token_data
+    ):
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+                return_value=sample_token_data,
+            ) as mock_refresh,
+        ):
+            auth_service = AuthService(environment=environment, force=False)
+            auth_session = AuthSession(auth_service._domain)
+            result = await auth_session.refresh_access_token("test_refresh_token")
+
+            mock_refresh.assert_called_once_with(
+                refresh_token="test_refresh_token",
+                client_id=mock_auth_config["client_id"],
+            )
+            assert auth_session._identity_service._domain == expected_domain
+            assert result.access_token == sample_token_data.access_token
+            assert result.refresh_token == sample_token_data.refresh_token
+
+    @pytest.mark.parametrize(
+        "env_var_url, environment, expected_domain",
+        [
+            (
+                "https://custom.automationsuite.org/org/tenant",
+                None,
+                "https://custom.automationsuite.org",
+            ),
+            (
+                "https://mycompany.uipath.com/org/tenant/",
+                None,
+                "https://mycompany.uipath.com",
+            ),
+            (
+                "https://custom.automationsuite.org/org/tenant",
+                "alpha",
+                "https://alpha.uipath.com",
+            ),
+            (
+                "https://custom.automationsuite.org/org/tenant",
+                "staging",
+                "https://staging.uipath.com",
+            ),
+            (
+                "https://custom.automationsuite.org/org/tenant",
+                "cloud",
+                "https://cloud.uipath.com",
+            ),
+        ],
+    )
+    async def test_refresh_with_uipath_url_env(
+        self,
+        env_var_url,
+        environment,
+        expected_domain,
+        mock_auth_config,
+        sample_token_data,
+    ):
+        original_env = os.environ.get("UIPATH_URL")
+        os.environ["UIPATH_URL"] = env_var_url
+
+        try:
+            with (
+                patch(
+                    "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                    new_callable=AsyncMock,
+                    return_value=mock_auth_config,
+                ),
+                patch(
+                    "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                    new_callable=AsyncMock,
+                    return_value=sample_token_data,
+                ) as mock_refresh,
+            ):
+                auth_service = AuthService(environment=environment, force=False)
+                auth_session = AuthSession(auth_service._domain)
+                result = await auth_session.refresh_access_token("test_refresh_token")
+
+                mock_refresh.assert_called_once_with(
+                    refresh_token="test_refresh_token",
+                    client_id=mock_auth_config["client_id"],
+                )
+                assert auth_session._identity_service._domain == expected_domain
+                assert result.access_token == sample_token_data.access_token
+                assert result.refresh_token == sample_token_data.refresh_token
+
+        finally:
+            if original_env is not None:
+                os.environ["UIPATH_URL"] = original_env
+            elif "UIPATH_URL" in os.environ:
+                del os.environ["UIPATH_URL"]
+
+    async def test_refresh_unauthorized(self, mock_auth_config):
+        import httpx
+
+        mock_response = Mock()
+        mock_response.status_code = 401
+        error = httpx.HTTPStatusError(
+            "unauthorized", request=Mock(), response=mock_response
+        )
+
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+                side_effect=error,
+            ),
+            patch("uipath._cli._auth._auth_session.ConsoleLogger") as mock_logger_cls,
+        ):
+            mock_console = Mock()
+            mock_console.error.side_effect = SystemExit(1)
+            mock_logger_cls.return_value = mock_console
+
+            auth_service = AuthService(environment="cloud", force=False)
+            auth_session = AuthSession(auth_service._domain)
+
+            with pytest.raises((SystemExit, Exception)):
+                await auth_session.refresh_access_token("test_refresh_token")
+
+            mock_console.error.assert_called_once_with("Unauthorized")
+
+    async def test_refresh_server_error(self, mock_auth_config):
+        import httpx
+
+        mock_response = Mock()
+        mock_response.status_code = 500
+        error = httpx.HTTPStatusError(
+            "server error", request=Mock(), response=mock_response
+        )
+
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+                side_effect=error,
+            ),
+            patch("uipath._cli._auth._auth_session.ConsoleLogger") as mock_logger_cls,
+        ):
+            mock_console = Mock()
+            mock_console.error.side_effect = SystemExit(1)
+            mock_logger_cls.return_value = mock_console
+
+            auth_service = AuthService(environment="cloud", force=False)
+            auth_session = AuthSession(auth_service._domain)
+
+            with pytest.raises((SystemExit, Exception)):
+                await auth_session.refresh_access_token("test_refresh_token")
+
+            mock_console.error.assert_called_once_with("Failed to refresh token: 500")
+
+    async def test_refresh_success_response_format(
+        self, mock_auth_config, sample_token_data
+    ):
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+                return_value=sample_token_data,
+            ),
+        ):
+            auth_service = AuthService(environment="cloud", force=False)
+            auth_session = AuthSession(auth_service._domain)
+            result = await auth_session.refresh_access_token("test_refresh_token")
+
+            assert result.access_token is not None
+            assert result.refresh_token is not None
+            assert result.expires_in is not None
+            assert result.token_type is not None
+            assert result.scope is not None
+            assert result.id_token is not None
+            assert result.access_token == sample_token_data.access_token
+            assert result.refresh_token == sample_token_data.refresh_token
+
+    async def test_refresh_malformed_domain_handling(
+        self, mock_auth_config, sample_token_data
+    ):
+        test_cases = [
+            ("https://example.uipath.com/", None, "https://example.uipath.com"),
+            ("https://example.com/", "example", "https://example.uipath.com"),
+            (
+                "https://example.com/some/path",
+                "example",
+                "https://example.uipath.com",
+            ),
+        ]
+
+        for uipath_url, environment, expected_domain in test_cases:
+            with (
+                patch(
+                    "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                    new_callable=AsyncMock,
+                    return_value=mock_auth_config,
+                ),
+                patch(
+                    "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                    new_callable=AsyncMock,
+                    return_value=sample_token_data,
+                ),
+            ):
+                os.environ["UIPATH_URL"] = uipath_url
+                auth_service = AuthService(environment=environment, force=False)
+                auth_session = AuthSession(auth_service._domain)
+                await auth_session.refresh_access_token("test_refresh_token")
+
+                assert auth_session._identity_service._domain == expected_domain
+
+    @pytest.mark.parametrize(
+        "scenario_name, env_vars, environment, expected_domain",
+        [
+            (
+                "refresh_with_uipath_url_env_variable",
+                {"UIPATH_URL": "https://custom.automationsuite.org/org/tenant"},
+                None,
+                "https://custom.automationsuite.org",
+            ),
+            (
+                "refresh_with_uipath_url_env_variable_with_trailing_slash",
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"},
+                None,
+                "https://custom.uipath.com",
+            ),
+            (
+                "refresh_with_alpha_flag_overrides_env",
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+                "alpha",
+                "https://alpha.uipath.com",
+            ),
+            (
+                "refresh_with_staging_flag_overrides_env",
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+                "staging",
+                "https://staging.uipath.com",
+            ),
+            (
+                "refresh_with_cloud_flag_overrides_env",
+                {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+                "cloud",
+                "https://cloud.uipath.com",
+            ),
+            (
+                "refresh_default_to_cloud",
+                {},
+                None,
+                "https://cloud.uipath.com",
+            ),
+        ],
+    )
+    async def test_refresh_auth_scenarios_integration(
+        self,
+        scenario_name,
+        env_vars,
+        environment,
+        expected_domain,
+        mock_auth_config,
+        sample_token_data,
+    ):
+        original_env_vars = {}
+        for key in env_vars:
+            original_env_vars[key] = os.environ.get(key)
+
+        try:
+            for key, value in env_vars.items():
+                os.environ[key] = value
+
+            with (
+                patch(
+                    "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                    new_callable=AsyncMock,
+                    return_value=mock_auth_config,
+                ),
+                patch(
+                    "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                    new_callable=AsyncMock,
+                    return_value=sample_token_data,
+                ) as mock_refresh,
+            ):
+                auth_service = AuthService(environment=environment, force=False)
+                auth_session = AuthSession(auth_service._domain)
+                result = await auth_session.refresh_access_token("test_refresh_token")
+
+                mock_refresh.assert_called_once_with(
+                    refresh_token="test_refresh_token",
+                    client_id=mock_auth_config["client_id"],
+                )
+                assert auth_session._identity_service._domain == expected_domain
+                assert result.access_token == sample_token_data.access_token
+                assert result.refresh_token == sample_token_data.refresh_token
+
+        finally:
+            for key, original_value in original_env_vars.items():
+                if original_value is not None:
+                    os.environ[key] = original_value
+                elif key in os.environ:
+                    del os.environ[key]
+
+
+class TestAuthSessionEnsureValidToken:
+    @pytest.mark.parametrize(
+        "domain, expected_domain",
+        [
+            ("https://cloud.uipath.com", "https://cloud.uipath.com"),
+            ("https://alpha.uipath.com", "https://alpha.uipath.com"),
+            ("https://staging.uipath.com", "https://staging.uipath.com"),
+            (
+                "https://custom.automationsuite.org",
+                "https://custom.automationsuite.org",
+            ),
+        ],
+    )
+    async def test_ensure_valid_token_refresh_flow_different_domains(
+        self,
+        domain,
+        expected_domain,
+        mock_auth_config,
+        sample_token_data,
+    ):
+        expired_auth_data = {
+            "access_token": "old_access_token",
+            "refresh_token": "valid_refresh_token",
+            "expires_in": 3600,
+            "token_type": "Bearer",
+            "scope": "openid profile offline_access",
+            "id_token": "old_id_token",
+        }
+
+        past_time = time.time() - 3600
+        expired_token_claims = {"exp": past_time, "prt_id": "test_prt_id"}
+
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_auth_data",
+                return_value=TokenData.model_validate(expired_auth_data),
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_parsed_token_data",
+                return_value=expired_token_claims,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.update_auth_file"
+            ) as mock_update_auth,
+            patch("uipath._cli._auth._auth_session.update_env_file"),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+                return_value=sample_token_data,
+            ) as mock_refresh,
+        ):
+            auth_session = AuthSession(domain)
+            await auth_session.ensure_valid_token()
+
+            mock_refresh.assert_called_once_with(
+                refresh_token=expired_auth_data["refresh_token"],
+                client_id=mock_auth_config["client_id"],
+            )
+            assert auth_session._identity_service._domain == expected_domain
+            mock_update_auth.assert_called_once()
+            call_args = mock_update_auth.call_args[0][0]
+            assert call_args.access_token == sample_token_data.access_token
+
+    async def test_ensure_valid_token_skips_refresh_when_not_expired(
+        self, mock_auth_config
+    ):
+        future_time = time.time() + 3600
+        valid_auth_data = {
+            "access_token": "valid_access_token",
+            "refresh_token": "valid_refresh_token",
+            "expires_in": 3600,
+            "token_type": "Bearer",
+            "scope": "openid profile offline_access",
+            "id_token": "valid_id_token",
+            "exp": future_time,
+        }
+
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_auth_data",
+                return_value=TokenData.model_validate(valid_auth_data),
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_parsed_token_data",
+                return_value=valid_auth_data,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.IdentityService.refresh_access_token_async",
+                new_callable=AsyncMock,
+            ) as mock_refresh,
+            patch("uipath._cli._auth._auth_session.update_auth_file"),
+            patch("uipath._cli._auth._auth_session.update_env_file"),
+        ):
+            auth_session = AuthSession("cloud")
+            await auth_session.ensure_valid_token()
+            mock_refresh.assert_not_called()
+
+    async def test_ensure_valid_token_missing_refresh_token_raises(
+        self, mock_auth_config
+    ):
+        auth_data_no_refresh = {
+            "access_token": "old_access_token",
+            "expires_in": 3600,
+            "token_type": "Bearer",
+            "scope": "openid profile offline_access",
+            "id_token": "old_id_token",
+        }
+
+        past_time = time.time() - 3600
+        expired_token_claims = {"exp": past_time, "prt_id": "test_prt_id"}
+
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils.get_auth_config",
+                new_callable=AsyncMock,
+                return_value=mock_auth_config,
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_auth_data",
+                return_value=TokenData.model_validate(auth_data_no_refresh),
+            ),
+            patch(
+                "uipath._cli._auth._auth_session.get_parsed_token_data",
+                return_value=expired_token_claims,
+            ),
+        ):
+            auth_session = AuthSession("cloud")
+            with pytest.raises(
+                UiPathRuntimeError, match="The refresh token could not be retrieved"
+            ):
+                await auth_session.ensure_valid_token()
diff --git a/packages/uipath/tests/cli/test_cli_telemetry.py b/packages/uipath/tests/cli/test_cli_telemetry.py
new file mode 100644
index 000000000..19a54d54d
--- /dev/null
+++ b/packages/uipath/tests/cli/test_cli_telemetry.py
@@ -0,0 +1,185 @@
+"""Tests for CLI telemetry functionality."""
+
+import os
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from uipath._cli._telemetry import (
+    CliTelemetryTracker,
+    track_command,
+)
+
+
+class TestGetEventName:
+    """Test event name generation."""
+
+    @pytest.mark.parametrize(
+        "command, expected",
+        [
+            ("pack", "Cli.Pack"),
+            ("publish", "Cli.Publish"),
+            ("run", "Cli.Run"),
+            ("initialize", "Cli.Initialize"),
+        ],
+    )
+    def test_get_event_name(self, command, expected):
+        assert CliTelemetryTracker._get_event_name(command) == expected
+
+
+class TestEnrichProperties:
+    """Test property enrichment with context information."""
+
+    @patch("uipath._cli._telemetry.version", return_value="1.0.0")
+    @patch("uipath._cli._telemetry.get_claim_from_token", return_value=None)
+    @patch("uipath._cli._telemetry._get_project_key", return_value=None)
+    def test_always_present_fields(self, mock_project_key, mock_claim, mock_version):
+        tracker = CliTelemetryTracker()
+        properties: dict[str, Any] = {}
+
+        with patch.dict(os.environ, {}, clear=True):
+            tracker._enrich_properties(properties)
+
+        assert properties["Source"] == "uipath-python-cli"
+        assert properties["ApplicationName"] == "UiPath.AgentCli"
+        assert properties["SessionId"] == "nosession"
+        assert properties["SDKVersion"] == "1.0.0"
+        assert properties["IsGithubCI"] is False
+
+    @patch("uipath._cli._telemetry.version", return_value="1.2.3")
+    @patch("uipath._cli._telemetry.get_claim_from_token", return_value="user-789")
+    @patch("uipath._cli._telemetry._get_project_key", return_value="project-key-123")
+    def test_adds_context_when_available(
+        self, mock_project_key, mock_claim, mock_version
+    ):
+        tracker = CliTelemetryTracker()
+        properties: dict[str, Any] = {}
+
+        with patch.dict(
+            os.environ,
+            {
+                "UIPATH_TENANT_ID": "tenant-abc",
+                "UIPATH_ORGANIZATION_ID": "org-456",
+            },
+        ):
+            tracker._enrich_properties(properties)
+
+        assert properties["AgentId"] == "project-key-123"
+        assert properties["CloudOrganizationId"] == "org-456"
+        assert properties["CloudTenantId"] == "tenant-abc"
+        assert properties["CloudUserId"] == "user-789"
+
+    @patch("uipath._cli._telemetry.version", side_effect=Exception("not found"))
+    @patch("uipath._cli._telemetry.get_claim_from_token", return_value=None)
+    @patch("uipath._cli._telemetry._get_project_key", return_value=None)
+    def test_skips_missing_context(self, mock_project_key, mock_claim, mock_version):
+        tracker = CliTelemetryTracker()
+        properties: dict[str, Any] = {}
+
+        with patch.dict(os.environ, {}, clear=True):
+            tracker._enrich_properties(properties)
+
+        assert "AgentId" not in properties
+        assert "CloudOrganizationId" not in properties
+        assert "CloudTenantId" not in properties
+        assert "CloudUserId" not in properties
+        assert "SDKVersion" not in properties
+        assert properties["SessionId"] == "nosession"
+        assert properties["IsGithubCI"] is False
+
+
+class TestTrackCommandDecorator:
+    """Test the track_command decorator end-to-end."""
+
+    @patch.object(CliTelemetryTracker, "_enrich_properties")
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=True)
+    def test_tracks_success(self, mock_enabled, mock_track_event, mock_enrich):
+        @track_command("publish")
+        def my_command():
+            return "result"
+
+        assert my_command() == "result"
+
+        mock_track_event.assert_called_once()
+        properties = mock_track_event.call_args[0][1]
+        assert mock_track_event.call_args[0][0] == "Cli.Publish"
+        assert properties["Command"] == "publish"
+        assert properties["Status"] == "Completed"
+        assert properties["Success"] is True
+        assert "DurationMs" in properties
+
+    @patch.object(CliTelemetryTracker, "_enrich_properties")
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=True)
+    def test_tracks_failure(self, mock_enabled, mock_track_event, mock_enrich):
+        @track_command("run")
+        def my_command():
+            raise ValueError("Test error message")
+
+        with pytest.raises(ValueError, match="Test error message"):
+            my_command()
+
+        mock_track_event.assert_called_once()
+        properties = mock_track_event.call_args[0][1]
+        assert properties["Command"] == "run"
+        assert properties["Status"] == "Failed"
+        assert properties["Success"] is False
+        assert properties["ErrorType"] == "ValueError"
+        assert "Test error message" in properties["ErrorMessage"]
+
+    @patch.object(CliTelemetryTracker, "_enrich_properties")
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=True)
+    def test_truncates_long_error_messages(
+        self, mock_enabled, mock_track_event, mock_enrich
+    ):
+        @track_command("run")
+        def my_command():
+            raise ValueError("x" * 1000)
+
+        with pytest.raises(ValueError):
+            my_command()
+
+        properties = mock_track_event.call_args[0][1]
+        assert len(properties["ErrorMessage"]) == 500
+
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=False)
+    def test_skips_when_disabled(self, mock_enabled, mock_track_event):
+        @track_command("pack")
+        def my_command():
+            return "result"
+
+        assert my_command() == "result"
+        mock_track_event.assert_not_called()
+
+    @patch.object(CliTelemetryTracker, "_enrich_properties")
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=True)
+    def test_telemetry_error_does_not_break_command(
+        self, mock_enabled, mock_track_event, mock_enrich
+    ):
+        mock_track_event.side_effect = Exception("Telemetry failed")
+
+        @track_command("pack")
+        def my_command():
+            return "result"
+
+        assert my_command() == "result"
+
+    @patch.object(CliTelemetryTracker, "_enrich_properties")
+    @patch("uipath._cli._telemetry.track_cli_event")
+    @patch("uipath._cli._telemetry.is_telemetry_enabled", return_value=True)
+    def test_command_exception_propagates_when_telemetry_fails(
+        self, mock_enabled, mock_track_event, mock_enrich
+    ):
+        mock_track_event.side_effect = Exception("Telemetry failed")
+
+        @track_command("run")
+        def my_command():
+            raise ValueError("Command error")
+
+        with pytest.raises(ValueError, match="Command error"):
+            my_command()
diff --git a/packages/uipath/tests/cli/test_create_resources.py b/packages/uipath/tests/cli/test_create_resources.py
new file mode 100644
index 000000000..aff1c7cab
--- /dev/null
+++ b/packages/uipath/tests/cli/test_create_resources.py
@@ -0,0 +1,456 @@
+"""Unit tests for cli_push.create_resources virtual-resource fallback."""
+
+import json
+import os
+from types import SimpleNamespace
+from typing import Any, List, Optional
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from uipath._cli._utils._studio_project import (
+    Status,
+    VirtualResourceResult,
+)
+from uipath.platform.errors import EnrichedException, FolderNotFoundException
+from uipath.platform.resource_catalog import ResourceType
+
+
+def _enriched_exc(
+    status_code: int = 404, body: bytes = b"not found"
+) -> EnrichedException:
+    """Build an EnrichedException backed by a real HTTPStatusError."""
+    request = httpx.Request("GET", "https://example.test/x")
+    response = httpx.Response(status_code, content=body, request=request)
+    http_err = httpx.HTTPStatusError("x", request=request, response=response)
+    return EnrichedException(http_err)
+
+
+class _AsyncIterator:
+    """Minimal async iterator with aclose() to mimic resource_catalog pagination."""
+
+    def __init__(self, items: List[Any], raise_exc: Optional[Exception] = None):
+        self._items = iter(items)
+        self._raise_exc = raise_exc
+        self.aclose = AsyncMock()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if self._raise_exc is not None:
+            raise self._raise_exc
+        try:
+            return next(self._items)
+        except StopIteration:
+            raise StopAsyncIteration from None
+
+
+def _make_bindings(resources: List[dict[str, Any]]) -> str:
+    return json.dumps({"version": "2.2", "resources": resources})
+
+
+def _asset_binding(
+    name: str = "my_asset",
+    folder_path: str = "Shared",
+    metadata: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    return {
+        "resource": "asset",
+        "key": f"binding-{name}",
+        "value": {
+            "name": {
+                "defaultValue": name,
+                "isExpression": False,
+                "displayName": "name",
+            },
+            "folderPath": {
+                "defaultValue": folder_path,
+                "isExpression": False,
+                "displayName": "folderPath",
+            },
+        },
+        "metadata": metadata,
+    }
+
+
+def _found_resource(
+    key: str = "resource-key",
+    resource_type: str = "asset",
+    resource_sub_type: str = "stringAsset",
+    folder_path: str = "Shared",
+) -> SimpleNamespace:
+    folder = SimpleNamespace(
+        key="folder-key",
+        fully_qualified_name=folder_path,
+        path=folder_path,
+    )
+    return SimpleNamespace(
+        resource_key=key,
+        resource_type=resource_type,
+        resource_sub_type=resource_sub_type,
+        folders=[folder],
+    )
+
+
+@pytest.fixture
+def bindings_file(tmp_path, monkeypatch):
+    """Write a bindings file to a tmp path and patch UiPathConfig.bindings_file_path."""
+    path = tmp_path / "bindings.json"
+
+    def _writer(content: str) -> str:
+        path.write_text(content, encoding="utf-8")
+        return str(path)
+
+    from uipath.platform.common._config import ConfigurationManager
+
+    monkeypatch.setattr(
+        ConfigurationManager,
+        "bindings_file_path",
+        property(lambda self: path),
+    )
+    return _writer
+
+
+@pytest.fixture
+def mock_uipath():
+    """Patch UiPath() in cli_push to return a mock with resource_catalog + connections.
+
+    cli_push imports `UiPath` lazily from `uipath.platform` inside create_resources,
+    so we patch the source module.
+    """
+    with patch("uipath.platform.UiPath") as mock_cls:
+        instance = MagicMock()
+        instance.resource_catalog = MagicMock()
+        instance.connections = MagicMock()
+        mock_cls.return_value = instance
+        yield instance
+
+
+@pytest.fixture
+def studio_client():
+    from uipath._cli._utils._studio_project import (
+        ResourceBuilderMetadataEntry,
+        ResourceBuilderMetadataVersion,
+    )
+
+    client = MagicMock()
+    client.create_referenced_resource = AsyncMock()
+    client.create_virtual_resource = AsyncMock()
+    supported = ResourceBuilderMetadataVersion(supportsInLineCreation=True)
+    # /metadata response — every kind our tests use supports inline creation.
+    client.get_resource_builder_metadata = AsyncMock(
+        return_value=[
+            ResourceBuilderMetadataEntry(kind="asset", versions=[supported]),
+            ResourceBuilderMetadataEntry(kind="bucket", versions=[supported]),
+            ResourceBuilderMetadataEntry(kind="queue", versions=[supported]),
+            ResourceBuilderMetadataEntry(kind="taskCatalog", versions=[supported]),
+        ]
+    )
+    return client
+
+
+async def _run_create_resources(studio_client):
+    from uipath._cli.cli_push import create_resources
+
+    await create_resources(studio_client)
+
+
+async def test_catalog_hit_calls_referenced_resource_only(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(_make_bindings([_asset_binding(metadata={"SubType": "stringAsset"})]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator(
+        [_found_resource()]
+    )
+    studio_client.create_referenced_resource.return_value = SimpleNamespace(
+        status=Status.ADDED
+    )
+
+    await _run_create_resources(studio_client)
+
+    studio_client.create_referenced_resource.assert_awaited_once()
+    studio_client.create_virtual_resource.assert_not_awaited()
+
+
+async def test_catalog_miss_with_subtype_creates_virtual_with_type(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(_make_bindings([_asset_binding(metadata={"SubType": "stringAsset"})]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator([])
+    studio_client.create_virtual_resource.return_value = VirtualResourceResult(
+        status=Status.ADDED,
+    )
+
+    await _run_create_resources(studio_client)
+
+    studio_client.create_virtual_resource.assert_awaited_once()
+    req = studio_client.create_virtual_resource.call_args.args[0]
+    assert req.kind == "asset"
+    assert req.name == "my_asset"
+    assert req.type == "stringAsset"
+    studio_client.create_referenced_resource.assert_not_awaited()
+
+
+async def test_catalog_miss_without_subtype_creates_virtual_kind_only(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(_make_bindings([_asset_binding(metadata=None)]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator([])
+    studio_client.create_virtual_resource.return_value = VirtualResourceResult(
+        status=Status.ADDED,
+    )
+
+    await _run_create_resources(studio_client)
+
+    studio_client.create_virtual_resource.assert_awaited_once()
+    req = studio_client.create_virtual_resource.call_args.args[0]
+    assert req.kind == "asset"
+    assert req.name == "my_asset"
+    assert req.type is None
+    # Body that will actually be sent excludes None → no "type" key.
+    body = req.model_dump(exclude_none=True)
+    assert "type" not in body
+
+
+async def test_catalog_miss_metadata_without_subtype_key_creates_virtual_kind_only(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(_make_bindings([_asset_binding(metadata={"Other": "x"})]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator([])
+    studio_client.create_virtual_resource.return_value = VirtualResourceResult(
+        status=Status.ADDED,
+    )
+
+    await _run_create_resources(studio_client)
+
+    req = studio_client.create_virtual_resource.call_args.args[0]
+    assert req.type is None
+
+
+async def test_unknown_resource_type_skips_catalog_and_creates_virtual(
+    bindings_file, mock_uipath, studio_client
+):
+    """Bindings with a resource kind unknown to ResourceType enum but supported
+    by the virtual endpoint (e.g. 'taskCatalog') should skip the resource
+    catalog lookup and fall through to the virtual fallback instead of raising
+    ValueError."""
+    task_catalog_binding = {
+        "resource": "taskCatalog",
+        "key": "live.good.taskcatalog.Shared",
+        "value": {
+            "name": {
+                "defaultValue": "live.good.taskcatalog",
+                "isExpression": False,
+                "displayName": "Name",
+            },
+            "folderPath": {
+                "defaultValue": "Shared",
+                "isExpression": False,
+                "displayName": "Folder Path",
+            },
+        },
+        "metadata": None,
+    }
+    bindings_file(_make_bindings([task_catalog_binding]))
+    studio_client.create_virtual_resource.return_value = VirtualResourceResult(
+        status=Status.ADDED,
+    )
+
+    await _run_create_resources(studio_client)
+
+    mock_uipath.resource_catalog.list_by_type_async.assert_not_called()
+    studio_client.create_virtual_resource.assert_awaited_once()
+    req = studio_client.create_virtual_resource.call_args.args[0]
+    assert req.kind == "taskCatalog"
+    assert req.type is None
+
+
+async def test_unsupported_virtual_kind_is_skipped_with_warning(
+    bindings_file, mock_uipath, studio_client
+):
+    """Bindings whose kind the virtual endpoint cannot materialize (e.g.
+    'choiceSet', 'webhook') should be skipped with a warning and
+    never reach create_virtual_resource."""
+    choiceset_binding = {
+        "resource": "choiceSet",
+        "key": "live.good.choiceset.Shared",
+        "value": {
+            "name": {
+                "defaultValue": "live.good.choiceset",
+                "isExpression": False,
+                "displayName": "Name",
+            },
+            "folderPath": {
+                "defaultValue": "Shared",
+                "isExpression": False,
+                "displayName": "Folder Path",
+            },
+        },
+        "metadata": None,
+    }
+    bindings_file(_make_bindings([choiceset_binding]))
+
+    await _run_create_resources(studio_client)
+
+    mock_uipath.resource_catalog.list_by_type_async.assert_not_called()
+    studio_client.create_virtual_resource.assert_not_awaited()
+    studio_client.create_referenced_resource.assert_not_awaited()
+
+
+async def test_entity_binding_catalog_hit_creates_reference(
+    bindings_file, mock_uipath, studio_client
+):
+    """Entity bindings should go through the resource catalog lookup.
+    When found, a referenced resource should be created."""
+    entity_binding = {
+        "resource": "entity",
+        "key": "live.good.entity.Shared",
+        "value": {
+            "name": {
+                "defaultValue": "live.good.entity",
+                "isExpression": False,
+                "displayName": "Name",
+            },
+            "folderPath": {
+                "defaultValue": "Shared",
+                "isExpression": False,
+                "displayName": "Folder Path",
+            },
+        },
+        "metadata": None,
+    }
+    bindings_file(_make_bindings([entity_binding]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator(
+        [_found_resource(resource_type="entity", resource_sub_type="Native")]
+    )
+    studio_client.create_referenced_resource.return_value = SimpleNamespace(
+        status=Status.ADDED
+    )
+
+    await _run_create_resources(studio_client)
+
+    mock_uipath.resource_catalog.list_by_type_async.assert_called_once_with(
+        resource_type=ResourceType.ENTITY,
+        name="live.good.entity",
+        folder_path="Shared",
+    )
+    studio_client.create_referenced_resource.assert_awaited_once()
+    studio_client.create_virtual_resource.assert_not_awaited()
+
+
+async def test_folder_not_found_falls_back_to_virtual(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(_make_bindings([_asset_binding(metadata={"SubType": "stringAsset"})]))
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator(
+        [], raise_exc=FolderNotFoundException("missing folder")
+    )
+    studio_client.create_virtual_resource.return_value = VirtualResourceResult(
+        status=Status.ADDED,
+    )
+
+    await _run_create_resources(studio_client)
+
+    studio_client.create_virtual_resource.assert_awaited_once()
+    req = studio_client.create_virtual_resource.call_args.args[0]
+    assert req.kind == "asset"
+    assert req.type == "stringAsset"
+
+
+async def test_virtual_enriched_exception_caught_and_logged_as_warning(
+    bindings_file, mock_uipath, studio_client
+):
+    bindings_file(
+        _make_bindings(
+            [
+                _asset_binding(name="first"),
+                _asset_binding(name="second"),
+            ]
+        )
+    )
+    mock_uipath.resource_catalog.list_by_type_async.return_value = _AsyncIterator([])
+    # First binding raises, second succeeds → loop must continue past the raise.
+    studio_client.create_virtual_resource.side_effect = [
+        _enriched_exc(status_code=500, body=b"boom"),
+        VirtualResourceResult(status=Status.ADDED),
+    ]
+
+    await _run_create_resources(studio_client)
+
+    assert studio_client.create_virtual_resource.await_count == 2
+
+
+async def test_connection_branch_unchanged_no_virtual_fallback(
+    bindings_file, mock_uipath, studio_client
+):
+    """Connection bindings retain old behavior: retrieve_async + warn on miss, no virtual."""
+    connection_binding = {
+        "resource": "connection",
+        "key": "binding-conn",
+        "value": {
+            "ConnectionId": {
+                "defaultValue": "missing-conn-id",
+                "isExpression": False,
+                "displayName": "ConnectionId",
+            }
+        },
+        "metadata": {"Connector": "salesforce"},
+    }
+    bindings_file(_make_bindings([connection_binding]))
+    mock_uipath.connections.retrieve_async = AsyncMock(side_effect=_enriched_exc())
+
+    await _run_create_resources(studio_client)
+
+    mock_uipath.connections.retrieve_async.assert_awaited_once()
+    studio_client.create_virtual_resource.assert_not_awaited()
+    studio_client.create_referenced_resource.assert_not_awaited()
+
+
+async def test_guardrail_binding_without_folder_path_is_skipped(
+    bindings_file, mock_uipath, studio_client
+):
+    # No folderPath in value → guardrail; should be skipped entirely.
+    guardrail_binding = {
+        "resource": "asset",
+        "key": "binding-guard",
+        "value": {
+            "name": {
+                "defaultValue": "g",
+                "isExpression": False,
+                "displayName": "name",
+            }
+        },
+        "metadata": None,
+    }
+    bindings_file(_make_bindings([guardrail_binding]))
+
+    await _run_create_resources(studio_client)
+
+    mock_uipath.resource_catalog.list_by_type_async.assert_not_called()
+    studio_client.create_virtual_resource.assert_not_awaited()
+    studio_client.create_referenced_resource.assert_not_awaited()
+
+
+# Ensure env doesn't leak solution ids between tests.
+@pytest.fixture(autouse=True)
+def _reset_solution_id():
+    from uipath.platform.common._config import ConfigurationManager
+
+    ConfigurationManager.studio_solution_id = None
+    yield
+    ConfigurationManager.studio_solution_id = None
+
+
+# Set minimal env so UiPath() construction inside create_resources (if not mocked
+# away cleanly) doesn't trip on missing creds. The mock_uipath fixture patches
+# the class, so this is defense-in-depth.
+@pytest.fixture(autouse=True)
+def _env(monkeypatch):
+    monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "mock_token")
+    yield
+    for k in ("UIPATH_URL", "UIPATH_ACCESS_TOKEN"):
+        if k in os.environ:
+            monkeypatch.delenv(k, raising=False)
diff --git a/packages/uipath/tests/cli/test_debug_bridge_selection.py b/packages/uipath/tests/cli/test_debug_bridge_selection.py
new file mode 100644
index 000000000..732461c77
--- /dev/null
+++ b/packages/uipath/tests/cli/test_debug_bridge_selection.py
@@ -0,0 +1,64 @@
+"""Tests for `get_debug_bridge()` selection matrix.
+
+Locks in the non-breaking-change contract: absence of `attach` preserves the
+legacy `job_id`-based selection. Explicit `attach` overrides that selection.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from uipath._cli._debug._bridge import (
+    ConsoleDebugBridge,
+    SignalRDebugBridge,
+    get_debug_bridge,
+)
+from uipath.runtime import UiPathRuntimeContext
+from uipath.runtime.debug import DetachedDebugBridge
+
+
+def _ctx(**overrides) -> UiPathRuntimeContext:
+    return UiPathRuntimeContext(**overrides)
+
+
+def test_attach_none_returns_detached_bridge_without_job_id():
+    bridge = get_debug_bridge(_ctx(), attach="none")
+    assert isinstance(bridge, DetachedDebugBridge)
+
+
+def test_attach_none_returns_detached_bridge_even_when_job_id_set(monkeypatch):
+    """'none' wins over job_id — this is the whole point of the flag."""
+    monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+    bridge = get_debug_bridge(_ctx(job_id="job-123"), attach="none")
+    assert isinstance(bridge, DetachedDebugBridge)
+
+
+def test_attach_signalr_forces_signalr_bridge(monkeypatch):
+    monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+    bridge = get_debug_bridge(_ctx(job_id="job-123"), attach="signalr")
+    assert isinstance(bridge, SignalRDebugBridge)
+
+
+def test_attach_console_forces_console_bridge_even_when_job_id_set(monkeypatch):
+    monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+    bridge = get_debug_bridge(_ctx(job_id="job-123"), attach="console")
+    assert isinstance(bridge, ConsoleDebugBridge)
+
+
+def test_legacy_selection_signalr_when_job_id_set_and_no_attach(monkeypatch):
+    """Non-breaking change assertion: absence of `attach` preserves today's behavior."""
+    monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com")
+    bridge = get_debug_bridge(_ctx(job_id="job-123"))
+    assert isinstance(bridge, SignalRDebugBridge)
+
+
+def test_legacy_selection_console_when_no_job_id_and_no_attach():
+    """Non-breaking change assertion: absence of `attach` preserves today's behavior."""
+    bridge = get_debug_bridge(_ctx())
+    assert isinstance(bridge, ConsoleDebugBridge)
+
+
+def test_attach_signalr_without_job_id_raises():
+    """Explicit signalr without job_id is a user error — surface it loudly."""
+    with pytest.raises(ValueError, match="UIPATH_URL and UIPATH_JOB_KEY"):
+        get_debug_bridge(_ctx(), attach="signalr")
diff --git a/packages/uipath/tests/cli/test_debug_simulation.py b/packages/uipath/tests/cli/test_debug_simulation.py
new file mode 100644
index 000000000..9e66a1a24
--- /dev/null
+++ b/packages/uipath/tests/cli/test_debug_simulation.py
@@ -0,0 +1,484 @@
+"""Tests for debug command tool simulation functionality."""
+
+import json
+from pathlib import Path
+from typing import Any
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.middlewares import MiddlewareResult
+from uipath.eval.mocks._mock_context import is_tool_simulated
+from uipath.eval.mocks._mock_runtime import (
+    clear_execution_context,
+    load_simulation_config,
+)
+from uipath.eval.mocks._types import (
+    LLMMockingStrategy,
+    MockingContext,
+)
+
+MOCK_RUNTIME_PATCH_PATH = "uipath.eval.mocks._mock_runtime"
+
+
+@pytest.fixture
+def valid_simulation_config() -> dict[str, Any]:
+    """Create a valid simulation.json configuration."""
+    return {
+        "instructions": "Always give a negative outlook on stock prospects",
+        "inputGenerationInstructions": "",
+        "simulateInput": False,
+        "enabled": True,
+        "toolsToSimulate": [
+            {"name": "Web Reader"},
+            {"name": "Web Search"},
+            {"name": "Web Summary"},
+        ],
+    }
+
+
+@pytest.fixture
+def disabled_simulation_config() -> dict[str, Any]:
+    """Create a disabled simulation.json configuration."""
+    return {
+        "instructions": "Test instructions",
+        "enabled": False,
+        "toolsToSimulate": [{"name": "Test Tool"}],
+    }
+
+
+@pytest.fixture
+def empty_tools_simulation_config() -> dict[str, Any]:
+    """Create simulation config with no tools."""
+    return {
+        "instructions": "Test instructions",
+        "enabled": True,
+        "toolsToSimulate": [],
+    }
+
+
+class TestLoadSimulationConfig:
+    """Tests for the load_simulation_config function."""
+
+    def test_returns_none_when_file_does_not_exist(self, temp_dir: str):
+        """Test that None is returned when simulation.json doesn't exist."""
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            assert result is None
+
+    def test_loads_valid_simulation_config(
+        self, temp_dir: str, valid_simulation_config: dict[str, Any]
+    ):
+        """Test loading a valid simulation configuration."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(valid_simulation_config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+
+            assert result is not None
+            assert isinstance(result, MockingContext)
+            assert result.name == "debug-simulation"
+            # Legacy format routes to local LLM mocker via strategy
+            assert result.components is None or len(result.components) == 0
+            assert isinstance(result.strategy, LLMMockingStrategy)
+            assert len(result.strategy.tools_to_simulate) == 3
+            assert result.strategy.tools_to_simulate[0].name == "Web Reader"
+            assert result.strategy.prompt == valid_simulation_config["instructions"]
+
+    def test_returns_none_when_disabled(
+        self, temp_dir: str, disabled_simulation_config: dict[str, Any]
+    ):
+        """Test that None is returned when simulation is disabled."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(disabled_simulation_config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            assert result is None
+
+    def test_returns_none_when_no_tools_to_simulate(
+        self, temp_dir: str, empty_tools_simulation_config: dict[str, Any]
+    ):
+        """Test that None is returned when toolsToSimulate is empty."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(empty_tools_simulation_config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            assert result is None
+
+    def test_handles_malformed_json(self, temp_dir: str):
+        """Test that malformed JSON is handled gracefully."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            f.write("{ invalid json }")
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            assert result is None
+
+    def test_handles_missing_required_fields(self, temp_dir: str):
+        """Test that missing required fields are handled gracefully."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump({"enabled": True}, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            # Should return None because toolsToSimulate is missing/empty
+            assert result is None
+
+    def test_creates_mocking_context_with_empty_inputs(
+        self, temp_dir: str, valid_simulation_config: dict[str, Any]
+    ):
+        """Test that MockingContext is created with empty inputs."""
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(valid_simulation_config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+
+            assert result is not None
+            assert result.inputs == {}
+
+    def test_uses_default_empty_instructions_when_missing(self, temp_dir: str):
+        """Test that empty string is used when instructions field is missing."""
+        config = {
+            "enabled": True,
+            "toolsToSimulate": [{"name": "Test Tool"}],
+        }
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+
+            assert result is not None
+            assert isinstance(result.strategy, LLMMockingStrategy)
+            assert result.strategy.prompt == ""
+
+
+class TestDebugCommandSimulationIntegration:
+    """Integration tests for debug command with simulation."""
+
+    @pytest.fixture
+    def mock_runtime(self):
+        """Create a mock runtime for testing."""
+        runtime = Mock()
+        runtime.execute = Mock(return_value=Mock(status="SUCCESSFUL", output={}))
+        runtime.dispose = Mock()
+        return runtime
+
+    @pytest.fixture
+    def mock_factory(self, mock_runtime):
+        """Create a mock factory that returns mock runtime."""
+        factory = Mock()
+        factory.new_runtime = Mock(return_value=mock_runtime)
+        factory.dispose = Mock()
+        return factory
+
+    def test_debug_without_simulation_file(self, runner: CliRunner, temp_dir: str):
+        """Test debug command when simulation.json doesn't exist."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            script_file = "entrypoint.py"
+            with open(script_file, "w") as f:
+                f.write("def main(input): return {'result': 'success'}")
+
+            # Create uipath.json
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": f"{script_file}:main"}}, f)
+
+            with patch("uipath._cli.cli_debug.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(
+                    should_continue=False,
+                    info_message="Execution succeeded",
+                    error_message=None,
+                    should_include_stacktrace=False,
+                )
+                result = runner.invoke(cli, ["debug", "main", "{}"])
+                assert result.exit_code == 0
+
+    def test_debug_always_wraps_with_mock_runtime(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """Test that debug command always wraps the debug runtime with UiPathMockRuntime."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            script_file = "entrypoint.py"
+            with open(script_file, "w") as f:
+                f.write("def main(input): return {'result': 'success'}")
+
+            # Create uipath.json
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": f"{script_file}:main"}}, f)
+
+            # Track if UiPathMockRuntime is instantiated
+            with patch(
+                "uipath._cli.cli_debug.UiPathMockRuntime",
+            ) as mock_mock_runtime_class:
+                mock_mock_runtime_instance = Mock()
+                mock_mock_runtime_instance.execute = AsyncMock(
+                    return_value=Mock(status="SUCCESSFUL", output={})
+                )
+                mock_mock_runtime_class.return_value = mock_mock_runtime_instance
+
+                with patch("uipath._cli.cli_debug.Middlewares.next") as mock_middleware:
+                    mock_middleware.return_value = MiddlewareResult(
+                        should_continue=True,
+                        info_message=None,
+                        error_message=None,
+                        should_include_stacktrace=False,
+                    )
+
+                    with patch(
+                        "uipath._cli.cli_debug.UiPathRuntimeFactoryRegistry.get"
+                    ) as mock_factory_get:
+                        mock_runtime = Mock()
+                        mock_runtime.dispose = AsyncMock()
+                        mock_runtime.get_schema = AsyncMock(
+                            return_value=Mock(metadata=None)
+                        )
+
+                        mock_factory = Mock()
+                        mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+                        mock_factory.get_settings = AsyncMock(
+                            return_value=Mock(trace_settings=None)
+                        )
+                        mock_factory.dispose = AsyncMock()
+                        mock_factory_get.return_value = mock_factory
+
+                        with patch("uipath._cli.cli_debug.get_debug_bridge"):
+                            with patch(
+                                "uipath._cli.cli_debug.UiPathDebugRuntime"
+                            ) as mock_debug_runtime_class:
+                                mock_debug_runtime = Mock()
+                                mock_debug_runtime.dispose = AsyncMock()
+                                mock_debug_runtime_class.return_value = (
+                                    mock_debug_runtime
+                                )
+
+                                runner.invoke(cli, ["debug", "main", "{}"])
+
+                                # Verify UiPathMockRuntime was instantiated
+                                assert mock_mock_runtime_class.called
+                                call_kwargs = mock_mock_runtime_class.call_args
+                                # Verify delegate wraps the debug runtime (outermost)
+                                assert (
+                                    call_kwargs.kwargs["delegate"] is mock_debug_runtime
+                                )
+
+    def test_debug_wraps_with_mock_runtime_on_error(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        """Test that UiPathMockRuntime is used even when an error occurs during execution."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            script_file = "entrypoint.py"
+            with open(script_file, "w") as f:
+                f.write("def main(input): raise Exception('Test error')")
+
+            # Create uipath.json
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": f"{script_file}:main"}}, f)
+
+            with patch(
+                "uipath._cli.cli_debug.UiPathMockRuntime",
+            ) as mock_mock_runtime_class:
+                mock_mock_runtime_instance = Mock()
+                mock_mock_runtime_instance.execute = AsyncMock(
+                    side_effect=Exception("Test error")
+                )
+                mock_mock_runtime_class.return_value = mock_mock_runtime_instance
+
+                with patch("uipath._cli.cli_debug.Middlewares.next") as mock_middleware:
+                    mock_middleware.return_value = MiddlewareResult(
+                        should_continue=True,
+                        info_message=None,
+                        error_message=None,
+                        should_include_stacktrace=False,
+                    )
+
+                    with patch(
+                        "uipath._cli.cli_debug.UiPathRuntimeFactoryRegistry.get"
+                    ) as mock_factory_get:
+                        mock_runtime = Mock()
+                        mock_runtime.dispose = AsyncMock()
+                        mock_runtime.get_schema = AsyncMock(
+                            return_value=Mock(metadata=None)
+                        )
+
+                        mock_factory = Mock()
+                        mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+                        mock_factory.get_settings = AsyncMock(
+                            return_value=Mock(trace_settings=None)
+                        )
+                        mock_factory.dispose = AsyncMock()
+                        mock_factory_get.return_value = mock_factory
+
+                        with patch("uipath._cli.cli_debug.get_debug_bridge"):
+                            with patch(
+                                "uipath._cli.cli_debug.UiPathDebugRuntime"
+                            ) as mock_debug_runtime_class:
+                                mock_debug_runtime = Mock()
+                                mock_debug_runtime.dispose = AsyncMock()
+                                mock_debug_runtime_class.return_value = (
+                                    mock_debug_runtime
+                                )
+
+                                runner.invoke(cli, ["debug", "main", "{}"])
+
+                                # Verify UiPathMockRuntime was still instantiated
+                                assert mock_mock_runtime_class.called
+
+    def test_simulation_config_enables_tool_mocking(
+        self, temp_dir: str, valid_simulation_config: dict[str, Any]
+    ):
+        """Test that tools marked in simulation config are detected as simulated."""
+        # Clear any existing context
+        clear_execution_context()
+
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(valid_simulation_config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            mocking_ctx = load_simulation_config()
+            assert mocking_ctx is not None
+
+            # Manually set context (simulating what UiPathMockRuntime does)
+            from uipath.eval._execution_context import ExecutionSpanCollector
+
+            span_collector = ExecutionSpanCollector()
+            from uipath.eval.mocks._mock_runtime import set_execution_context
+
+            set_execution_context(mocking_ctx, span_collector, "test-execution-id")
+
+            # Verify tools are detected as simulated
+            assert is_tool_simulated("Web Reader") is True
+            assert is_tool_simulated("Web Search") is True
+            assert is_tool_simulated("Web Summary") is True
+            assert is_tool_simulated("Non Simulated Tool") is False
+
+            # Clean up
+            clear_execution_context()
+
+    def test_middleware_short_circuits_before_mock_runtime(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        disabled_simulation_config: dict[str, Any],
+    ):
+        """Test that middleware short-circuit prevents UiPathMockRuntime from being created."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create disabled simulation.json
+            with open("simulation.json", "w") as f:
+                json.dump(disabled_simulation_config, f)
+
+            script_file = "entrypoint.py"
+            with open(script_file, "w") as f:
+                f.write("def main(input): return {'result': 'success'}")
+
+            # Create uipath.json
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": f"{script_file}:main"}}, f)
+
+            with patch(
+                "uipath._cli.cli_debug.UiPathMockRuntime",
+            ) as mock_mock_runtime_class:
+                with patch("uipath._cli.cli_debug.Middlewares.next") as mock_middleware:
+                    mock_middleware.return_value = MiddlewareResult(
+                        should_continue=False,
+                        info_message="Execution succeeded",
+                        error_message=None,
+                        should_include_stacktrace=False,
+                    )
+
+                    runner.invoke(cli, ["debug", "main", "{}"])
+
+                    # Verify UiPathMockRuntime was NOT instantiated
+                    assert not mock_mock_runtime_class.called
+
+
+class TestSimulationConfigFields:
+    """Test various field combinations in simulation.json."""
+
+    def test_enabled_defaults_to_true_when_missing(self, temp_dir: str):
+        """Test that 'enabled' defaults to true when not specified."""
+        config = {
+            "instructions": "Test",
+            "toolsToSimulate": [{"name": "Test Tool"}],
+        }
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+            # Should load successfully since enabled defaults to true
+            assert result is not None
+
+    def test_new_format_loads_components(self, temp_dir: str):
+        """Test that new per-component format routes to API-based mocker (components set)."""
+        config = {
+            "enabled": True,
+            "components": [
+                {
+                    "componentId": "my_tool",
+                    "componentType": "tool",
+                    "simulationStrategy": 0,
+                    "simulationInstruction": "Simulate this tool",
+                }
+            ],
+        }
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            result = load_simulation_config()
+
+            assert result is not None
+            assert isinstance(result, MockingContext)
+            # New format: components set, strategy is None
+            assert result.components is not None
+            assert len(result.components) == 1
+            assert result.components[0].component_id == "my_tool"
+            assert result.strategy is None
+
+    def test_handles_tool_name_normalization(self, temp_dir: str):
+        """Test that tool names with underscores work correctly."""
+        config = {
+            "enabled": True,
+            "instructions": "Test",
+            "toolsToSimulate": [
+                {"name": "Web_Reader"},
+                {"name": "Web Search"},
+            ],
+        }
+        simulation_path = Path(temp_dir) / "simulation.json"
+        with open(simulation_path, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+
+        with patch(f"{MOCK_RUNTIME_PATCH_PATH}.Path.cwd", return_value=Path(temp_dir)):
+            mocking_ctx = load_simulation_config()
+            assert mocking_ctx is not None
+
+            # Set context to test name normalization
+            from uipath.eval._execution_context import ExecutionSpanCollector
+            from uipath.eval.mocks._mock_runtime import set_execution_context
+
+            span_collector = ExecutionSpanCollector()
+            set_execution_context(mocking_ctx, span_collector, "test-id")
+
+            # Both underscore and space versions should be detected
+            assert is_tool_simulated("Web_Reader") is True
+            assert is_tool_simulated("Web Reader") is True
+            assert is_tool_simulated("Web Search") is True
+
+            clear_execution_context()
diff --git a/packages/uipath/tests/cli/test_determine_project_type.py b/packages/uipath/tests/cli/test_determine_project_type.py
new file mode 100644
index 000000000..af6c8b559
--- /dev/null
+++ b/packages/uipath/tests/cli/test_determine_project_type.py
@@ -0,0 +1,49 @@
+from uipath._cli._utils._common import determine_project_type
+from uipath._cli.models.runtime_schema import EntryPoint
+
+
+def _make_entrypoint(type: str) -> EntryPoint:
+    return EntryPoint(
+        file_path="test",
+        unique_id="00000000-0000-0000-0000-000000000000",
+        type=type,
+        input={"type": "object", "properties": {}},
+        output={"type": "string"},
+    )
+
+
+class TestDetermineProjectType:
+    def test_empty_entrypoints_returns_function(self) -> None:
+        assert determine_project_type([]) == "function"
+
+    def test_single_agent_entrypoint(self) -> None:
+        assert determine_project_type([_make_entrypoint("agent")]) == "agent"
+
+    def test_single_function_entrypoint(self) -> None:
+        assert determine_project_type([_make_entrypoint("function")]) == "function"
+
+    def test_multiple_same_type(self) -> None:
+        entrypoints = [_make_entrypoint("agent"), _make_entrypoint("agent")]
+        assert determine_project_type(entrypoints) == "agent"
+
+    def test_mixed_types_returns_first(self) -> None:
+        entrypoints = [_make_entrypoint("agent"), _make_entrypoint("function")]
+        assert determine_project_type(entrypoints) == "agent"
+
+    def test_mixed_types_returns_first_function(self) -> None:
+        entrypoints = [_make_entrypoint("function"), _make_entrypoint("agent")]
+        assert determine_project_type(entrypoints) == "function"
+
+    def test_mixed_types_logs_warning(self, capsys) -> None:
+        entrypoints = [_make_entrypoint("agent"), _make_entrypoint("function")]
+        determine_project_type(entrypoints)
+        captured = capsys.readouterr()
+        assert "Mixed entrypoint types detected: [agent, function]" in captured.out
+        assert '"agent"' in captured.out
+        assert "We recommend using a single type for all entrypoints" in captured.out
+
+    def test_same_types_no_warning(self, capsys) -> None:
+        entrypoints = [_make_entrypoint("agent"), _make_entrypoint("agent")]
+        determine_project_type(entrypoints)
+        captured = capsys.readouterr()
+        assert "Mixed entrypoint types detected" not in captured.out
diff --git a/packages/uipath/tests/cli/test_files_to_include.py b/packages/uipath/tests/cli/test_files_to_include.py
new file mode 100644
index 000000000..ba9f39ad8
--- /dev/null
+++ b/packages/uipath/tests/cli/test_files_to_include.py
@@ -0,0 +1,31 @@
+import os
+
+from uipath._cli._utils._project_files import files_to_include
+
+
+class TestFilesToIncludeHiddenFiles:
+    def test_hidden_files_are_excluded(self, tmp_path):
+        project_dir = str(tmp_path)
+        open(os.path.join(project_dir, "main.py"), "w").close()
+        open(os.path.join(project_dir, ".hidden_file.py"), "w").close()
+        open(os.path.join(project_dir, ".env"), "w").close()
+
+        included, _ = files_to_include(None, project_dir, include_uv_lock=False)
+        included_names = [f.file_name for f in included]
+
+        assert "main.py" in included_names
+        assert ".hidden_file.py" not in included_names
+        assert ".env" not in included_names
+
+    def test_hidden_files_in_subdirectory_are_excluded(self, tmp_path):
+        project_dir = str(tmp_path)
+        sub_dir = os.path.join(project_dir, "src")
+        os.makedirs(sub_dir)
+        open(os.path.join(sub_dir, "app.py"), "w").close()
+        open(os.path.join(sub_dir, ".secret.json"), "w").close()
+
+        included, _ = files_to_include(None, project_dir, include_uv_lock=False)
+        included_names = [f.file_name for f in included]
+
+        assert "app.py" in included_names
+        assert ".secret.json" not in included_names
diff --git a/packages/uipath/tests/cli/test_init.py b/packages/uipath/tests/cli/test_init.py
new file mode 100644
index 000000000..afa5d15fa
--- /dev/null
+++ b/packages/uipath/tests/cli/test_init.py
@@ -0,0 +1,783 @@
+import json
+import os
+import uuid
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.middlewares import MiddlewareResult
+
+
+class TestInit:
+    def _generate_pyproject(self, project_name: str | None = None):
+        with open("pyproject.toml", "w") as f:
+            f.write(
+                f'[project]\nname = "{project_name if project_name else "test-project"}"\nversion = "0.1.0"\n'
+                'description = "Test"\nauthors = [{name = "Test"}]\n'
+                'requires-python = ">=3.11"\n'
+            )
+
+    def test_init_env_file_creation(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test .env file creation scenarios."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+            # Test creation of new .env
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert "Created '.env' file" in result.output
+
+            assert os.path.exists(".env")
+
+            # Test existing .env isn't overwritten
+            original_content = "EXISTING=CONFIG"
+            with open(".env", "w") as f:
+                f.write(original_content)
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            with open(".env", "r") as f:
+                assert f.read() == original_content
+
+    def test_init_creates_empty_uipath_json(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init creates an empty uipath.json with functions structure."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("uipath.json")
+            assert "Created 'uipath.json' file" in result.output
+
+            # Verify uipath.json has correct empty structure
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+                assert "functions" in config
+                assert isinstance(config["functions"], dict)
+                assert len(config["functions"]) == 0
+
+    def test_init_mints_agent_id_in_uipath_json(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """init writes a valid id into a newly created uipath.json."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+            assert "id" in config
+            # Must be a valid UUID-shaped identifier.
+            uuid.UUID(config["id"])
+
+    def test_init_does_not_create_telemetry_file(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """init no longer writes .uipath/.telemetry.json; the id lives in uipath.json."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+
+            assert not os.path.exists(os.path.join(".uipath", ".telemetry.json"))
+            with open("uipath.json", "r") as f:
+                uuid.UUID(json.load(f)["id"])
+
+    def test_init_mints_agent_id_with_telemetry_disabled(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """id is still written when telemetry is opted out."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+            result = runner.invoke(
+                cli, ["init"], env={"UIPATH_TELEMETRY_ENABLED": "false"}
+            )
+            assert result.exit_code == 0
+
+            assert not os.path.exists(os.path.join(".uipath", ".telemetry.json"))
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+            uuid.UUID(config["id"])
+
+    def test_init_preserves_existing_agent_id(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """init keeps an id already present in uipath.json (first writer wins)."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+            with open("uipath.json", "w") as f:
+                json.dump(
+                    {
+                        "id": "existing-agent-id",
+                        "functions": {"main": "main.py:main"},
+                    },
+                    f,
+                )
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            # Existing id must not be backfilled/overwritten.
+            assert "with 'id'" not in result.output
+
+            with open("uipath.json", "r") as f:
+                assert json.load(f)["id"] == "existing-agent-id"
+
+    def test_init_backfills_agent_id_from_telemetry(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """init backfills id on an existing uipath.json, reusing the telemetry key."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": "main.py:main"}}, f)
+            os.makedirs(".uipath", exist_ok=True)
+            with open(os.path.join(".uipath", ".telemetry.json"), "w") as f:
+                json.dump({"ProjectKey": "legacy-project-key"}, f)
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert "Updated 'uipath.json' file with 'id'" in result.output
+
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+            assert config["id"] == "legacy-project-key"
+            # Existing fields are preserved.
+            assert config["functions"]["main"] == "main.py:main"
+            # The backfill is targeted: no defaulted fields are materialized.
+            assert set(config.keys()) == {"functions", "id"}
+
+    def test_init_with_existing_uipath_json(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test init when uipath.json already exists with functions."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create test script
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+
+            # Create uipath.json with functions
+            uipath_config = {"functions": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+            self._generate_pyproject()
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+
+            # Should generate entry-points.json
+            assert os.path.exists("entry-points.json")
+            assert "Created 'entry-points.json' file" in result.output
+
+            # Verify entry-points.json has correct structure
+            with open("entry-points.json", "r") as f:
+                entry_points = json.load(f)
+                assert "entryPoints" in entry_points
+                assert len(entry_points["entryPoints"]) == 1
+                assert entry_points["entryPoints"][0]["filePath"] == "main"
+                assert "uniqueId" in entry_points["entryPoints"][0]
+
+    def test_init_middleware_interaction(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test middleware integration."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                # Test middleware stopping execution with error
+                mock_middleware.return_value = MiddlewareResult(
+                    should_continue=False,
+                    error_message="Middleware error",
+                    should_include_stacktrace=False,
+                )
+                self._generate_pyproject()
+                result = runner.invoke(cli, ["init"], env={})
+                assert result.exit_code == 1
+                assert "Middleware error" in result.output
+                assert os.path.exists("uipath.json")
+
+                # Test middleware allowing execution
+                mock_middleware.return_value = MiddlewareResult(
+                    should_continue=True,
+                    error_message=None,
+                    should_include_stacktrace=False,
+                )
+
+                result = runner.invoke(cli, ["init"], env={})
+                assert result.exit_code == 0
+                assert os.path.exists("uipath.json")
+
+    def test_init_error_handling(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test error handling in init command."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create invalid Python file
+            with open("invalid.py", "w") as f:
+                f.write("def main(input: return input")  # Invalid syntax
+
+            # Create uipath.json with reference to invalid file
+            uipath_config = {"functions": {"main": "invalid.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            # Mock middleware to allow execution
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                self._generate_pyproject()
+                result = runner.invoke(cli, ["init"], env={})
+
+                # The command should fail due to invalid syntax
+                assert result.exit_code == 1, (
+                    f"Expected exit code 1, got {result.exit_code}. Output: {result.output}"
+                )
+
+    def test_init_config_generation(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test configuration file generation with different input/output schemas."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create test script with typed input/output
+            script_content = """
+from dataclasses import dataclass
+from typing import Optional
+import uuid
+@dataclass
+class Input:
+    uuid_attribute: uuid.UUID
+    message: str
+    count: Optional[int] = None
+
+@dataclass
+class Output:
+    result: str
+
+def main(input: Input) -> Output:
+    return Output(result=input.message)
+"""
+            with open("test.py", "w") as f:
+                f.write(script_content)
+
+            # Create uipath.json with function reference
+            uipath_config = {"functions": {"main": "test.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("entry-points.json")
+
+            with open("entry-points.json", "r") as f:
+                config = json.load(f)
+                entry = config["entryPoints"][0]
+
+                # Verify input schema
+                assert "input" in entry
+                input_schema = entry["input"]
+                assert "message" in input_schema["properties"]
+                assert "count" in input_schema["properties"]
+                assert "message" in input_schema["required"]
+
+                assert "uuid_attribute" in input_schema["properties"]
+                assert "uuid_attribute" in input_schema["required"]
+                assert input_schema["properties"]["uuid_attribute"]["type"] == "string"
+                assert input_schema["properties"]["uuid_attribute"]["format"] == "uuid"
+
+                # Verify output schema
+                assert "output" in entry
+                output_schema = entry["output"]
+                assert "result" in output_schema["properties"]
+
+    def test_schema_json_draft07_compliance(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that generated schemas comply with JSON Schema draft-07 specification."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a comprehensive test script with all supported types
+            script_content = """
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Dict, Optional
+from pydantic import BaseModel
+
+
+class StringEnum(str, Enum):
+    OPTION_A = "option_a"
+    OPTION_B = "option_b"
+    OPTION_C = "option_c"
+
+
+class IntEnum(int, Enum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+
+
+class FloatEnum(float, Enum):
+    PI = 3.14
+    E = 2.71
+    GOLDEN = 1.618
+
+
+class BoolEnum(int, Enum):
+    FALSE_VALUE = 0
+    TRUE_VALUE = 1
+
+
+class NestedPydanticModel(BaseModel):
+    nested_field: str
+    nested_number: int
+
+
+@dataclass
+class NestedDataclass:
+    nested_str: str
+    nested_int: int
+
+
+@dataclass
+class Input:
+    string_field: str
+    integer_field: int
+    float_field: float
+    boolean_field: bool
+    list_of_strings: List[str]
+    list_of_integers: List[int]
+    dict_field: Dict[str, str]
+    optional_string: Optional[str]
+    optional_int: Optional[int]
+    optional_list: Optional[List[str]]
+    string_enum_field: StringEnum
+    int_enum_field: IntEnum
+    float_enum_field: FloatEnum
+    bool_enum_field: BoolEnum
+    pydantic_nested: NestedPydanticModel
+    dataclass_nested: NestedDataclass
+    list_of_objects: List[NestedDataclass]
+    nested_list: List[List[str]]
+    optional_with_default: Optional[str] = None
+    int_with_default: int = 42
+
+
+@dataclass
+class Output:
+    result: str
+    success: bool
+
+
+def main(input: Input) -> Output:
+    return Output(result="test", success=True)
+"""
+            with open("comprehensive_types.py", "w") as f:
+                f.write(script_content)
+
+            # Create uipath.json with function reference
+            uipath_config = {"functions": {"main": "comprehensive_types.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+            self._generate_pyproject()
+
+            # Run init command
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("entry-points.json")
+
+            # Load and validate the generated config
+            with open("entry-points.json", "r") as f:
+                config = json.load(f)
+                entry = config["entryPoints"][0]
+                input_schema = entry["input"]
+                output_schema = entry["output"]
+
+            # Validate top-level structure
+            assert input_schema["type"] == "object"
+            assert "properties" in input_schema
+            assert "required" in input_schema
+
+            props = input_schema["properties"]
+            required = input_schema["required"]
+
+            # Test basic types
+            assert props["string_field"]["type"] == "string"
+            assert props["integer_field"]["type"] == "integer"
+            assert props["float_field"]["type"] == "number"
+            assert props["boolean_field"]["type"] == "boolean"
+
+            # Test collections
+            assert props["list_of_strings"]["type"] == "array"
+            assert props["list_of_strings"]["items"]["type"] == "string"
+            assert props["list_of_integers"]["type"] == "array"
+            assert props["list_of_integers"]["items"]["type"] == "integer"
+            assert props["dict_field"]["type"] == "object"
+
+            # Test Optional types
+            assert props["optional_string"]["type"] == "string"
+            assert props["optional_int"]["type"] == "integer"
+            assert props["optional_list"]["type"] == "array"
+
+            # Test Enum types
+            assert props["string_enum_field"]["type"] == "string"
+            assert set(props["string_enum_field"]["enum"]) == {
+                "option_a",
+                "option_b",
+                "option_c",
+            }
+            assert props["int_enum_field"]["type"] == "integer"
+            assert set(props["int_enum_field"]["enum"]) == {1, 2, 3}
+            assert props["float_enum_field"]["type"] == "number"
+            assert set(props["float_enum_field"]["enum"]) == {3.14, 2.71, 1.618}
+
+            # Test nested objects
+            assert props["pydantic_nested"]["type"] == "object"
+            assert props["dataclass_nested"]["type"] == "object"
+
+            # Test required fields
+            assert "string_field" in required
+            assert "optional_with_default" not in required
+            assert "int_with_default" not in required
+
+            # Validate output schema
+            assert output_schema["type"] == "object"
+            assert output_schema["properties"]["result"]["type"] == "string"
+            assert output_schema["properties"]["success"]["type"] == "boolean"
+
+    def test_bindings_and_entrypoints_files_creation(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that bindings.json and entry-points.json files are created correctly."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a simple Python file
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+
+            # Create uipath.json with function
+            uipath_config = {"functions": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert "Created 'bindings.json' file" in result.output
+            assert "Created 'entry-points.json' file" in result.output
+
+            assert os.path.exists("bindings.json")
+            assert os.path.exists("entry-points.json")
+
+            # Verify bindings.json has correct structure
+            with open("bindings.json", "r") as f:
+                bindings_data = json.load(f)
+                assert "version" in bindings_data
+                assert bindings_data["version"] == "2.0"
+                assert "resources" in bindings_data
+                assert isinstance(bindings_data["resources"], list)
+
+            # Verify uipath.json still has functions
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+                assert "functions" in config
+                assert config["functions"]["main"] == "main.py:main"
+
+    @pytest.mark.parametrize(
+        ("input_model", "verify_other_field"),
+        [
+            (
+                """
+# pydantic BaseModel
+
+from pydantic import BaseModel, Field
+class InputModel(BaseModel):
+    input_file: Attachment
+    other_field: int | None = Field(default=None)""",
+                True,
+            ),
+            (
+                """
+# dataclass
+
+from dataclasses import dataclass
+@dataclass
+class InputModel:
+    input_file: Attachment
+    other_field: int | None = None""",
+                True,
+            ),
+            (
+                """
+# regular class
+
+class InputModel:
+    input_file: Attachment
+    other_field: int | None = None
+
+    def __init__(self, input_file: Attachment, other_field: int | None = None):
+        self.input_file = input_file
+        self.other_field = other_field""",
+                True,
+            ),
+            (
+                """
+# attachment class itself
+
+
+from typing import TypeAlias
+InputModel: TypeAlias = Attachment
+""",
+                False,
+            ),
+        ],
+    )
+    def test_schema_generation_resolves_attachments_pydantic_dataclass(
+        self, runner: CliRunner, temp_dir: str, input_model: str, verify_other_field
+    ) -> None:
+        """Test that attachments are resolved in entry-points schema"""
+
+        def verify_attachment_schema(schema, verify_other_field):
+            assert "definitions" in schema
+            assert "job-attachment" in schema["definitions"]
+            assert schema["definitions"]["job-attachment"]["type"] == "object"
+            assert (
+                schema["definitions"]["job-attachment"]["x-uipath-resource-kind"]
+                == "JobAttachment"
+            )
+            assert all(
+                prop_name in schema["definitions"]["job-attachment"]["properties"]
+                for prop_name in ["ID", "FullName", "MimeType", "Metadata"]
+            )
+            if not verify_other_field:
+                return
+
+            assert len(schema["properties"]) == 2
+            assert all(
+                prop_name in schema["properties"]
+                for prop_name in ["input_file", "other_field"]
+            )
+            assert schema["required"] == ["input_file"]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write(f"""
+from uipath.platform.attachments import Attachment
+{input_model}
+def main(input: InputModel) -> InputModel: return input""")
+
+            uipath_config = {"functions": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+
+            assert result.exit_code == 0
+            assert "Created 'bindings.json' file" in result.output
+            assert "Created 'entry-points.json' file" in result.output
+
+            with open("entry-points.json", "r") as f:
+                entrypoints = json.load(f)
+                input_schema = entrypoints["entryPoints"][0]["input"]
+                output_schema = entrypoints["entryPoints"][0]["output"]
+
+            verify_attachment_schema(input_schema, verify_other_field)
+            verify_attachment_schema(output_schema, verify_other_field)
+
+    def test_init_creates_uiproj_with_function_type(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init creates project.uiproj with correct function type."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+
+            uipath_config = {"functions": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            self._generate_pyproject("my-project")
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("project.uiproj")
+            assert "Created 'project.uiproj' file" in result.output
+
+            with open("project.uiproj", "r") as f:
+                uiproj = json.load(f)
+                assert uiproj["ProjectType"] == "Function"
+                assert uiproj["Name"] == "my-project"
+                assert uiproj["Description"] == "Test"
+                assert uiproj["MainFile"] is None
+
+    def test_init_creates_uiproj_with_agent_type(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init creates project.uiproj with agent type."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+
+            uipath_config = {"agents": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            self._generate_pyproject("my-agent")
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("project.uiproj")
+
+            with open("project.uiproj", "r") as f:
+                uiproj = json.load(f)
+                assert uiproj["ProjectType"] == "Agent"
+                assert uiproj["Name"] == "my-agent"
+
+    def test_init_creates_uiproj_default_function_when_no_entrypoints(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init creates project.uiproj with Function type when no entrypoints."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists("project.uiproj")
+
+            with open("project.uiproj", "r") as f:
+                uiproj = json.load(f)
+                assert uiproj["ProjectType"] == "Function"
+
+    def test_init_updates_uiproj_and_warns_on_type_change(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init warns when project type changes in existing uiproj."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("main.py", "w") as f:
+                f.write("def main(input: str) -> str: return input")
+
+            # Create existing uiproj with Agent type
+            with open("project.uiproj", "w") as f:
+                json.dump(
+                    {
+                        "ProjectType": "Agent",
+                        "Name": "my-project",
+                        "Description": None,
+                        "MainFile": None,
+                    },
+                    f,
+                )
+
+            # Configure as function
+            uipath_config = {"functions": {"main": "main.py:main"}}
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert 'Project type changed from "Agent" to "Function"' in result.output
+            assert "Updated 'project.uiproj' file" in result.output
+
+            with open("project.uiproj", "r") as f:
+                uiproj = json.load(f)
+                assert uiproj["ProjectType"] == "Function"
+
+    def test_init_mixed_entrypoints_warns(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init warns when there are mixed entrypoint types."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("agent.py", "w") as f:
+                f.write("def agent_main(input: str) -> str: return input")
+
+            with open("func.py", "w") as f:
+                f.write("def func_main(input: str) -> str: return input")
+
+            uipath_config = {
+                "agents": {"my_agent": "agent.py:agent_main"},
+                "functions": {"my_func": "func.py:func_main"},
+            }
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(
+                    '[project]\nname = "mixed-project"\nversion = "0.1.0"\n'
+                    'description = "Mixed"\nauthors = [{name = "Test"}]\n'
+                    'requires-python = ">=3.11"\n'
+                )
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+            assert "Mixed entrypoint types detected: [" in result.output
+            assert (
+                "We recommend using a single type for all entrypoints" in result.output
+            )
+
+    def test_init_creates_studio_metadata_file(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init creates .uipath/studio_metadata.json with correct content."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+
+            metadata_path = os.path.join(".uipath", "studio_metadata.json")
+            assert os.path.exists(metadata_path)
+            assert "studio_metadata.json" in result.output
+
+            with open(metadata_path, "r") as f:
+                metadata = json.load(f)
+                assert "schemaVersion" in metadata
+                assert "codeVersion" in metadata
+                assert metadata["schemaVersion"] == 1
+                assert metadata["codeVersion"] == "1.0.0"
+
+    def test_init_does_not_overwrite_existing_studio_metadata(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that init does not overwrite existing studio_metadata.json."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._generate_pyproject()
+
+            # Create existing metadata with different values
+            os.makedirs(".uipath", exist_ok=True)
+            existing_metadata = {"schemaVersion": 99, "codeVersion": "5.0.0"}
+            with open(os.path.join(".uipath", "studio_metadata.json"), "w") as f:
+                json.dump(existing_metadata, f)
+
+            result = runner.invoke(cli, ["init"], env={})
+            assert result.exit_code == 0
+
+            with open(os.path.join(".uipath", "studio_metadata.json"), "r") as f:
+                metadata = json.load(f)
+                assert metadata["schemaVersion"] == 99
+                assert metadata["codeVersion"] == "5.0.0"
+
+
+class TestWriteMermaidFiles:
+    def test_mermaid_file_starts_with_header_comment(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Generated .mermaid files begin with the clarifying header comment."""
+        from uipath._cli.cli_init import MERMAID_FILE_HEADER, write_mermaid_files
+        from uipath.runtime.schema import UiPathRuntimeGraph, UiPathRuntimeSchema
+
+        ep = UiPathRuntimeSchema(
+            filePath="main.py",
+            uniqueId="main",
+            type="function",
+            input={},
+            output={},
+            graph=UiPathRuntimeGraph(),
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            paths = write_mermaid_files([ep])
+            assert len(paths) == 1
+            contents = paths[0].read_text()
+            assert contents.startswith(MERMAID_FILE_HEADER)
+            assert "AUTO-GENERATED" in contents
+            assert "uipath init" in contents
diff --git a/packages/uipath/tests/cli/test_init_agents_md.py b/packages/uipath/tests/cli/test_init_agents_md.py
new file mode 100644
index 000000000..a41502c5f
--- /dev/null
+++ b/packages/uipath/tests/cli/test_init_agents_md.py
@@ -0,0 +1,260 @@
+"""Tests for AGENTS.md generation in the init command."""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.cli_init import (
+    generate_agent_md_file,
+    generate_agent_md_files,
+)
+
+
+class TestGenerateAgentMdFile:
+    """Test the generate_agent_md_file helper function."""
+
+    def test_generate_agent_md_file_creates_file(self) -> None:
+        """Test that a single md file is created successfully."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                mock_source = (
+                    Path(__file__).parent.parent.parent
+                    / "src"
+                    / "uipath"
+                    / "_resources"
+                    / "AGENTS.md"
+                )
+
+                with (
+                    patch(
+                        "uipath._cli.cli_init.importlib.resources.files"
+                    ) as mock_files,
+                    patch(
+                        "uipath._cli.cli_init.importlib.resources.as_file"
+                    ) as mock_as_file,
+                ):
+                    mock_path = MagicMock()
+                    mock_files.return_value.joinpath.return_value = mock_path
+                    mock_as_file.return_value.__enter__.return_value = mock_source
+                    mock_as_file.return_value.__exit__.return_value = None
+
+                    generate_agent_md_file(temp_dir, "AGENTS.md", False)
+
+                    assert (Path(temp_dir) / "AGENTS.md").exists()
+            finally:
+                os.chdir(original_cwd)
+
+    def test_generate_agents_md_overwrites_existing_file(self) -> None:
+        """Test that existing AGENTS.md is overwritten."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            agents_path = Path(temp_dir) / "AGENTS.md"
+            original_content = "Original content"
+            agents_path.write_text(original_content)
+
+            mock_source = (
+                Path(__file__).parent.parent.parent
+                / "src"
+                / "uipath"
+                / "_resources"
+                / "AGENTS.md"
+            )
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+            ):
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = mock_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                generate_agent_md_file(temp_dir, "AGENTS.md", False)
+
+                assert agents_path.read_text() != original_content
+                assert agents_path.exists()
+
+    def test_generate_agents_md_handles_errors_gracefully(self) -> None:
+        """Test that errors are handled gracefully."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch("uipath._cli.cli_init.console") as mock_console,
+            ):
+                mock_files.side_effect = RuntimeError("Test error")
+
+                generate_agent_md_file(temp_dir, "AGENTS.md", False)
+
+                mock_console.warning.assert_called_once()
+                assert "Could not create AGENTS.md: Test error" in str(
+                    mock_console.warning.call_args
+                )
+
+
+class TestGenerateAgentMdFiles:
+    """Test the generate_agent_md_files function that creates multiple files."""
+
+    def test_generate_agent_md_files_creates_all_files(self) -> None:
+        """Test that all root and agent files are created in the correct locations."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+                patch("uipath._cli.cli_init.console"),
+            ):
+                temp_source = Path(temp_dir) / "temp_source.md"
+                temp_source.write_text("Test content")
+
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                generate_agent_md_files(temp_dir, False)
+
+                agent_dir = Path(temp_dir) / ".agent"
+                assert agent_dir.exists()
+                assert agent_dir.is_dir()
+
+                assert (Path(temp_dir) / "AGENTS.md").exists()
+                assert (Path(temp_dir) / "CLAUDE.md").exists()
+
+                assert (agent_dir / "CLI_REFERENCE.md").exists()
+                assert (agent_dir / "REQUIRED_STRUCTURE.md").exists()
+                assert (agent_dir / "SDK_REFERENCE.md").exists()
+
+    def test_generate_agent_md_files_overwrites_existing_files(self) -> None:
+        """Test that existing files are overwritten."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            agent_dir = Path(temp_dir) / ".agent"
+            agent_dir.mkdir()
+
+            agents_path = Path(temp_dir) / "AGENTS.md"
+            agents_content = "Original AGENTS content"
+            agents_path.write_text(agents_content)
+
+            cli_ref_path = agent_dir / "CLI_REFERENCE.md"
+            cli_ref_content = "Original CLI_REFERENCE content"
+            cli_ref_path.write_text(cli_ref_content)
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+                patch("uipath._cli.cli_init.console"),
+            ):
+                temp_source = Path(temp_dir) / "temp_source.md"
+                temp_source.write_text("Test content")
+
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                generate_agent_md_files(temp_dir, False)
+
+                assert agents_path.read_text() != agents_content
+                assert agents_path.read_text() == "Test content"
+                assert cli_ref_path.read_text() != cli_ref_content
+                assert cli_ref_path.read_text() == "Test content"
+
+
+class TestInitWithAgentsMd:
+    """Test the init command with default AGENTS.md creation."""
+
+    def _generate_pyproject(self):
+        with open("pyproject.toml", "w") as f:
+            f.write(
+                '[project]\nname = "test-project"\nversion = "0.1.0"\n'
+                'description = "Test"\nauthors = [{name = "Test"}]\n'
+                'requires-python = ">=3.11"\n'
+            )
+
+    def test_init_creates_agent_files_by_default(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that agent files are created by default during init."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a simple Python file
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            temp_source = Path(temp_dir) / "temp_source.md"
+            temp_source.write_text("Test content")
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+            ):
+                # Setup mocks
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                self._generate_pyproject()
+                result = runner.invoke(cli, ["init"])
+
+                assert result.exit_code == 0
+                assert "AGENTS.md" in result.output
+                assert "file." in result.output
+
+                assert os.path.exists("AGENTS.md")
+                assert os.path.exists("CLAUDE.md")
+
+                assert os.path.exists(".agent/CLI_REFERENCE.md")
+                assert os.path.exists(".agent/REQUIRED_STRUCTURE.md")
+                assert os.path.exists(".agent/SDK_REFERENCE.md")
+
+    def test_init_overwrites_existing_agents_md(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that existing AGENTS.md is overwritten."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a simple Python file
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create existing AGENTS.md
+            original_content = "Original AGENTS.md content"
+            with open("AGENTS.md", "w") as f:
+                f.write(original_content)
+
+            temp_source = Path(temp_dir) / "temp_source.md"
+            temp_source.write_text("Test content")
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+            ):
+                # Setup mocks
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                self._generate_pyproject()
+                # Run init (AGENTS.md creation is now default)
+                result = runner.invoke(cli, ["init"])
+
+                assert result.exit_code == 0
+
+                # Verify content was changed
+                with open("AGENTS.md", "r") as f:
+                    content = f.read()
+                    assert content != original_content
+                    assert content == "Test content"
diff --git a/packages/uipath/tests/cli/test_input_args.py b/packages/uipath/tests/cli/test_input_args.py
new file mode 100644
index 000000000..00a7d51da
--- /dev/null
+++ b/packages/uipath/tests/cli/test_input_args.py
@@ -0,0 +1,114 @@
+"""Test input args generation functionality."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from uipath.functions.schema_gen import get_type_schema
+
+
+class EventArguments(BaseModel):
+    """Test Pydantic model with aliases for testing."""
+
+    event_connector: str | None = Field(default=None, alias="UiPathEventConnector")
+    event: str | None = Field(default=None, alias="UiPathEvent")
+    event_object_type: str | None = Field(default=None, alias="UiPathEventObjectType")
+    event_object_id: str | None = Field(default=None, alias="UiPathEventObjectId")
+    additional_event_data: str | None = Field(
+        default=None, alias="UiPathAdditionalEventData"
+    )
+
+
+class RequiredFieldsModel(BaseModel):
+    """Test Pydantic model with required and optional fields."""
+
+    required_field: str
+    optional_field: str | None = None
+    aliased_required: int = Field(alias="AliasedRequired")
+    aliased_optional: int | None = Field(default=100, alias="AliasedOptional")
+
+
+@dataclass
+class SimpleDataClass:
+    """Test dataclass for comparison."""
+
+    name: str
+    value: int = 42
+
+
+class TestInputArgs:
+    def test_pydantic_model_with_aliases(self):
+        """Test that Pydantic model schemas use field aliases when defined."""
+        schema = get_type_schema(EventArguments)
+
+        assert schema["type"] == "object"
+        assert "properties" in schema
+
+        # Check that aliases are used in property names
+        expected_properties = {
+            "UiPathEventConnector",
+            "UiPathEvent",
+            "UiPathEventObjectType",
+            "UiPathEventObjectId",
+            "UiPathAdditionalEventData",
+        }
+        actual_properties = set(schema["properties"].keys())
+        assert actual_properties == expected_properties
+
+        # All fields have defaults, so none should be required
+        assert schema["required"] == []
+
+    def test_pydantic_model_required_fields(self):
+        """Test that required fields are correctly identified in Pydantic models."""
+        schema = get_type_schema(RequiredFieldsModel)
+
+        assert schema["type"] == "object"
+        assert "properties" in schema
+
+        # Check properties include both field names and aliases
+        expected_properties = {
+            "required_field",  # field name (no alias)
+            "optional_field",  # field name (no alias)
+            "AliasedRequired",  # alias
+            "AliasedOptional",  # alias
+        }
+        actual_properties = set(schema["properties"].keys())
+        assert actual_properties == expected_properties
+
+        # Check required fields (using aliases where defined)
+        expected_required = {"required_field", "AliasedRequired"}
+        actual_required = set(schema["required"])
+        assert actual_required == expected_required
+
+    def test_dataclass_still_works(self):
+        """Test that dataclass functionality is not broken."""
+        schema = get_type_schema(SimpleDataClass)
+
+        assert schema["type"] == "object"
+        assert "properties" in schema
+
+        # Dataclass should use field names (no alias support)
+        expected_properties = {"name", "value"}
+        actual_properties = set(schema["properties"].keys())
+        assert actual_properties == expected_properties
+
+        # Field with default should not be required
+        assert schema["required"] == ["name"]
+
+    def test_primitive_types(self):
+        """Test that primitive type handling still works."""
+        assert get_type_schema(str) == {"type": "string"}
+        assert get_type_schema(int) == {"type": "integer"}
+        assert get_type_schema(float) == {"type": "number"}
+        assert get_type_schema(bool) == {"type": "boolean"}
+
+    def test_optional_types(self):
+        """Test handling of Optional types."""
+        response = get_type_schema(Optional[str])
+        assert response == {"type": "string"}  # Should unwrap Optional
+
+    def test_optional_union_types(self):
+        """Test handling of Optional types."""
+        response = get_type_schema(str | None)
+        assert response == {"type": "string"}  # Should unwrap Optional
diff --git a/tests/cli/test_invoke.py b/packages/uipath/tests/cli/test_invoke.py
similarity index 93%
rename from tests/cli/test_invoke.py
rename to packages/uipath/tests/cli/test_invoke.py
index 0e1f5819d..444fd2018 100644
--- a/tests/cli/test_invoke.py
+++ b/packages/uipath/tests/cli/test_invoke.py
@@ -9,7 +9,7 @@
 from pytest_httpx import HTTPXMock
 
 from tests.cli.utils.project_details import ProjectDetails
-from uipath._cli.cli_invoke import invoke  # type: ignore
+from uipath._cli import cli
 from uipath._cli.middlewares import MiddlewareResult
 
 
@@ -34,7 +34,9 @@ def test_invoke_input_file_not_found(
             entrypoint: str,
         ):
             with runner.isolated_filesystem(temp_dir=temp_dir):
-                result = runner.invoke(invoke, [entrypoint, "--file", "not-here.json"])
+                result = runner.invoke(
+                    cli, ["invoke", entrypoint, "--file", "not-here.json"]
+                )
                 assert result.exit_code != 0
                 assert "Error: Invalid value for '-f' / '--file'" in result.output
 
@@ -49,7 +51,7 @@ def test_invoke_invalid_input_file(
                 file_path = os.path.join(temp_dir, file_name)
                 with open(file_path, "w") as f:
                     f.write("file content")
-                result = runner.invoke(invoke, [entrypoint, "--file", file_path])
+                result = runner.invoke(cli, ["invoke", entrypoint, "--file", file_path])
                 assert result.exit_code == 1
                 assert "Input file extension must be '.json'." in result.output
 
@@ -117,7 +119,7 @@ def test_invoke_successful(
                 f.write(json_content)
             with open("pyproject.toml", "w") as f:
                 f.write(project_details.to_toml())
-            result = runner.invoke(invoke, [entrypoint, "{}"])
+            result = runner.invoke(cli, ["invoke", entrypoint, "{}"])
             assert result.exit_code == 0
             assert "Starting job ..." in result.output
             assert "Job started successfully!" in result.output
@@ -138,7 +140,7 @@ def test_invoke_personal_workspace_info_error(
         # mock start job response
         httpx_mock.add_response(
             url=f"{base_url}/orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended?$expand=PersonalWorkspace",
-            status_code=401,
+            status_code=204,
         )
 
         file_name = "input.json"
@@ -160,7 +162,7 @@ def test_invoke_personal_workspace_info_error(
                     error_message=None,
                     should_include_stacktrace=False,
                 )
-                result = runner.invoke(invoke, [entrypoint, "{}"])
+                result = runner.invoke(cli, ["invoke", entrypoint, "{}"])
                 assert result.exit_code == 1
                 assert (
                     "Failed to fetch user info. Please try reauthenticating."
diff --git a/tests/cli/test_new.py b/packages/uipath/tests/cli/test_new.py
similarity index 88%
rename from tests/cli/test_new.py
rename to packages/uipath/tests/cli/test_new.py
index 8e277c2cc..41941bcee 100644
--- a/tests/cli/test_new.py
+++ b/packages/uipath/tests/cli/test_new.py
@@ -3,7 +3,7 @@
 
 from click.testing import CliRunner
 
-from uipath._cli.cli_new import new  # type: ignore
+from uipath._cli import cli
 from uipath._cli.middlewares import MiddlewareResult
 
 
@@ -12,7 +12,7 @@ def test_new_project_creation(self, runner: CliRunner, temp_dir: str) -> None:
         """Test project creation scenarios."""
         with runner.isolated_filesystem(temp_dir=temp_dir):
             # Test creating a new project
-            result = runner.invoke(new, ["my_project"])
+            result = runner.invoke(cli, ["new", "my_project"])
             assert result.exit_code == 0
             assert os.path.exists("main.py")
             assert os.path.exists("pyproject.toml")
@@ -20,7 +20,7 @@ def test_new_project_creation(self, runner: CliRunner, temp_dir: str) -> None:
     def test_new_project_without_name(self, runner: CliRunner, temp_dir: str) -> None:
         """Test creating a new project without specifying a name."""
         with runner.isolated_filesystem(temp_dir=temp_dir):
-            result = runner.invoke(new, [""])
+            result = runner.invoke(cli, ["new", ""])
             assert result.exit_code == 1
             assert "Please specify a name for your project" in result.output
 
@@ -33,7 +33,7 @@ def test_new_project_with_existing_files(
             with open("main.py", "w") as f:
                 f.write("print('Existing file')")
 
-            result = runner.invoke(new, ["my_project"])
+            result = runner.invoke(cli, ["new", "my_project"])
             assert result.exit_code == 0
             assert "Created 'main.py' file." in result.output
 
@@ -50,7 +50,7 @@ def test_new_project_middleware_interaction(
                     should_include_stacktrace=False,
                 )
 
-                result = runner.invoke(new, ["my_project"])
+                result = runner.invoke(cli, ["new", "my_project"])
                 assert result.exit_code == 1
                 assert "Middleware error" in result.output
                 assert not os.path.exists("main.py")
@@ -62,7 +62,7 @@ def test_new_project_middleware_interaction(
                     should_include_stacktrace=False,
                 )
 
-                result = runner.invoke(new, ["my_project"])
+                result = runner.invoke(cli, ["new", "my_project"])
                 assert result.exit_code == 0
                 assert os.path.exists("main.py")
 
@@ -76,6 +76,6 @@ def test_new_project_error_handling(self, runner: CliRunner, temp_dir: str) -> N
                 # Simulate an error during project creation
                 with patch("uipath._cli.cli_new.generate_script") as mock_generate:
                     mock_generate.side_effect = Exception("Generation error")
-                    result = runner.invoke(new, ["my_project"])
+                    result = runner.invoke(cli, ["new", "my_project"])
                     assert result.exit_code == 1
                     assert "Created 'main.py' file." not in result.output
diff --git a/packages/uipath/tests/cli/test_oidc_utils.py b/packages/uipath/tests/cli/test_oidc_utils.py
new file mode 100644
index 000000000..4a9ba422f
--- /dev/null
+++ b/packages/uipath/tests/cli/test_oidc_utils.py
@@ -0,0 +1,224 @@
+"""
+Unit tests for OidcUtils.get_auth_config() method.
+
+IMPORTANT: Backwards Compatibility Notice
+=========================================
+If any values in auth_config.json are changed, we MUST maintain backwards
+compatibility with release/2025.10 branches or later.
+"""
+
+import json
+import os
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from uipath._cli._auth._oidc_utils import (
+    OidcUtils,
+    _is_cloud_domain,
+    _select_config_file,
+)
+
+
+class TestOidcUtils:
+    """Test suite for OidcUtils class."""
+
+    def test_auth_config_backwards_compatibility_v2025_10(self):
+        """
+        Test that auth_config_25_10.json maintains backwards compatibility with release/v2025.10.
+
+        This test validates that the authentication configuration values remain
+        unchanged to ensure compatibility with release/v2025.10 and later branches.
+
+        CRITICAL: Any failure indicates a breaking change that requires coordination
+        across all supported release branches.
+        """
+        # Read the actual auth_config_25_10.json file
+        config_path = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "src",
+            "uipath",
+            "_cli",
+            "_auth",
+            "auth_config_25_10.json",
+        )
+
+        with open(config_path, "r") as f:
+            actual_config = json.load(f)
+
+        # Assert exact values for non-scope fields
+        assert actual_config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00", (
+            f"BACKWARDS COMPATIBILITY VIOLATION: client_id has changed! "
+            f"Expected: 36dea5b8-e8bb-423d-8e7b-c808df8f1c00, Got: {actual_config['client_id']}"
+        )
+
+        assert (
+            actual_config["redirect_uri"]
+            == "http://localhost:__PY_REPLACE_PORT__/oidc/login"
+        ), (
+            f"BACKWARDS COMPATIBILITY VIOLATION: redirect_uri has changed! "
+            f"Expected: http://localhost:__PY_REPLACE_PORT__/oidc/login, Got: {actual_config['redirect_uri']}"
+        )
+
+        assert actual_config["port"] == 8104, (
+            f"BACKWARDS COMPATIBILITY VIOLATION: port has changed! "
+            f"Expected: 8104, Got: {actual_config['port']}"
+        )
+
+        # For scopes, ensure actual scopes are a subset of the allowed scopes (no new scopes allowed)
+        allowed_scopes = set(
+            [
+                "offline_access",
+                "ProcessMining",
+                "OrchestratorApiUserAccess",
+                "StudioWebBackend",
+                "IdentityServerApi",
+                "ConnectionService",
+                "DataService",
+                "DocumentUnderstanding",
+                "Du.Digitization.Api",
+                "Du.Classification.Api",
+                "Du.Extraction.Api",
+                "Du.Validation.Api",
+                "EnterpriseContextService",
+                "Directory",
+                "JamJamApi",
+                "LLMGateway",
+                "LLMOps",
+                "OMS",
+                "RCS.FolderAuthorization",
+                "TM.Projects",
+                "TM.TestCases",
+                "TM.Requirements",
+                "TM.TestSets",
+            ]
+        )
+
+        actual_scopes = set(actual_config["scope"].split())
+
+        assert actual_scopes.issubset(allowed_scopes), (
+            f"BACKWARDS COMPATIBILITY VIOLATION: New scopes detected that are not allowed on v2025.10! "
+            f"New scopes: {actual_scopes - allowed_scopes}. "
+            f"Only subsets of the following scopes are permitted: {sorted(allowed_scopes)}"
+        )
+
+    @pytest.mark.parametrize(
+        "domain,expected",
+        [
+            ("https://alpha.uipath.com", True),
+            ("https://staging.uipath.com", True),
+            ("https://cloud.uipath.com", True),
+            ("https://ALPHA.UIPATH.COM", True),  # Test case insensitivity
+            ("https://custom.domain.com", False),
+            ("https://cloud.uipath.dev", False),
+            ("https://alpha-test.uipath.com", False),
+        ],
+    )
+    def test_is_cloud_domain(self, domain, expected):
+        """Test _is_cloud_domain correctly identifies cloud domains."""
+        assert _is_cloud_domain(domain) == expected
+
+    @pytest.mark.parametrize(
+        "domain,mock_info,expected_config",
+        [
+            # Cloud domains always use auth_config_cloud.json (no API call needed)
+            ("https://alpha.uipath.com", None, "auth_config_cloud.json"),
+            ("https://staging.uipath.com", None, "auth_config_cloud.json"),
+            ("https://cloud.uipath.com", None, "auth_config_cloud.json"),
+            # Non-ServiceFabric deployments (cloud releases) use auth_config_cloud.json
+            (
+                "https://custom.domain.com",
+                {"version": "26.3.0-s188.574", "deployment": None},
+                "auth_config_cloud.json",
+            ),
+            (
+                "https://custom.domain.com",
+                {"version": "25.10.0-s99", "deployment": "Kubernetes"},
+                "auth_config_cloud.json",
+            ),
+            # API unreachable uses auth_config_cloud.json
+            ("https://custom.domain.com", None, "auth_config_cloud.json"),
+            # ServiceFabric + 25.10.* (AS release 25.10) uses auth_config_25_10.json
+            (
+                "https://custom.domain.com",
+                {"version": "25.10.0-beta.415", "deployment": "ServiceFabric"},
+                "auth_config_25_10.json",
+            ),
+            (
+                "https://custom.domain.com",
+                {"version": "25.10.1", "deployment": "ServiceFabric"},
+                "auth_config_25_10.json",
+            ),
+            # ServiceFabric + 26.3.* (AS release 25.10.2) uses auth_config_25_10_2.json
+            (
+                "https://custom.domain.com",
+                {"version": "26.3.0-beta.188", "deployment": "ServiceFabric"},
+                "auth_config_25_10_2.json",
+            ),
+            (
+                "https://custom.domain.com",
+                {"version": "26.3.1", "deployment": "ServiceFabric"},
+                "auth_config_25_10_2.json",
+            ),
+            # ServiceFabric + unknown version falls back to latest AS config
+            (
+                "https://custom.domain.com",
+                {"version": "24.10.0", "deployment": "ServiceFabric"},
+                "auth_config_25_10_2.json",
+            ),
+            (
+                "https://custom.domain.com",
+                {"version": "26.1.0", "deployment": "ServiceFabric"},
+                "auth_config_25_10_2.json",
+            ),
+        ],
+    )
+    async def test_select_config_file(self, domain, mock_info, expected_config):
+        """Test _select_config_file selects the correct config based on domain and server info."""
+        with patch(
+            "uipath._cli._auth._oidc_utils.get_server_info_async",
+            new_callable=AsyncMock,
+            return_value=mock_info,
+        ):
+            config_file = await _select_config_file(domain)
+            assert config_file == expected_config
+
+    async def test_get_auth_config_without_domain(self):
+        """Test get_auth_config without domain parameter uses default config."""
+        with patch(
+            "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port", return_value=8104
+        ):
+            config = await OidcUtils.get_auth_config()
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104
+
+    async def test_get_auth_config_with_cloud_domain(self):
+        """Test get_auth_config with cloud domain uses auth_config_cloud.json."""
+        with patch(
+            "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port", return_value=8104
+        ):
+            config = await OidcUtils.get_auth_config("https://alpha.uipath.com")
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104
+
+    async def test_get_auth_config_with_25_10_version(self):
+        """Test get_auth_config with AS 25.10 ServiceFabric deployment uses auth_config_25_10.json."""
+        with (
+            patch(
+                "uipath._cli._auth._oidc_utils.get_server_info_async",
+                new_callable=AsyncMock,
+                return_value={
+                    "version": "25.10.0-beta.415",
+                    "deployment": "ServiceFabric",
+                },
+            ),
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port",
+                return_value=8104,
+            ),
+        ):
+            config = await OidcUtils.get_auth_config("https://custom.domain.com")
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104
diff --git a/packages/uipath/tests/cli/test_pack.py b/packages/uipath/tests/cli/test_pack.py
new file mode 100644
index 000000000..c644b3c7d
--- /dev/null
+++ b/packages/uipath/tests/cli/test_pack.py
@@ -0,0 +1,1410 @@
+# type: ignore
+import json
+import os
+import zipfile
+from unittest.mock import patch
+
+from click.testing import CliRunner
+from utils.project_details import ProjectDetails
+
+import uipath._cli.cli_pack as cli_pack
+from uipath._cli import cli
+from uipath._cli.middlewares import MiddlewareResult
+from uipath._cli.models.uipath_json_schema import RuntimeOptions, UiPathJsonConfig
+
+
+def create_bindings_file(directory: str = "."):
+    """Helper to create a default bindings.json file for tests."""
+    bindings_content = {"version": "2.0", "resources": []}
+    with open(os.path.join(directory, "bindings.json"), "w") as f:
+        json.dump(bindings_content, f, indent=4)
+
+
+def create_entry_points_file(entrypoint_type: str = "function", directory: str = "."):
+    """Helper to create a default entry-points.json file for tests."""
+    entry_points_content = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+        "$id": "entry-points.json",
+        "entryPoints": [
+            {
+                "filePath": "main",
+                "uniqueId": "00000000-0000-0000-0000-000000000000",
+                "type": entrypoint_type,
+                "input": {
+                    "type": "object",
+                    "properties": {"input": {"type": "string"}},
+                },
+                "output": {"type": "string"},
+            }
+        ],
+    }
+    with open(os.path.join(directory, "entry-points.json"), "w") as f:
+        json.dump(entry_points_content, f, indent=4)
+
+
+def create_uipath_json(
+    functions: dict[str, str] | None = None, pack_options: dict | None = None
+):
+    """Helper to create uipath.json with functions structure."""
+    if functions is None:
+        functions = {"main": "main.py:main"}
+
+    config = {"functions": functions}
+    if pack_options:
+        config["packOptions"] = pack_options
+
+    return config
+
+
+class TestPack:
+    """Test pack command."""
+
+    def test_pack_project_creation(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test project packing scenarios."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files for packing
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+
+            # Mock middleware and run init to generate entry-points.json
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+            assert os.path.exists(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+
+    def test_pyproject_missing_description(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test project packing scenarios."""
+        project_details.description = None
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                "pyproject.toml is missing the required field: project.description."
+                in result.output
+            )
+
+    def test_pyproject_missing_authors(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test project packing scenarios."""
+        project_details.authors = None
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                """Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]"""
+                in result.output
+            )
+
+    def test_pyproject_missing_requires_python(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        project_details.requires_python = None
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                "'requires-python' field cannot be empty. Please specify it in pyproject.toml"
+                in result.output
+            )
+
+    def test_pyproject_missing_project_name(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        project_details.name = ""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                "Project name cannot be empty. Please specify a name in pyproject.toml."
+                in result.output
+            )
+
+    def test_pyproject_invalid_name(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        project_details.name = "project < name"
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert """Project name contains invalid character: '<'""" in result.output
+
+    def test_pyproject_invalid_description(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        project_details.description = "invalid project description &"
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                """Project description contains invalid character: '&'"""
+                in result.output
+            )
+
+    def test_pack_without_uipath_json(
+        self, runner: CliRunner, temp_dir: str, project_details: ProjectDetails
+    ) -> None:
+        """Test packing when uipath.json is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            create_bindings_file()
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert (
+                "uipath.json not found. Please run `uipath init` in the project directory."
+                in result.output
+            )
+
+    def test_pack_without_pyproject_toml(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test packing when pyproject.toml is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            create_bindings_file()
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 1
+            assert "pyproject.toml not found" in result.output
+
+    def test_include_file_extensions(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test generating operate.json and its content."""
+        xml_file_name = "test.xml"
+        sh_file_name = "test.sh"
+        md_file_name = "README.md"
+        binary_file_name = "script.exe"
+        binary_file_not_included = "report.xlsx"
+
+        # Binary content for the exe file (simulating a simple executable)
+        binary_content = b"\x4d\x5a\x90\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00"
+
+        pack_options = {"fileExtensionsIncluded": [".xml", ".exe"]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            with open(xml_file_name, "w") as f:
+                f.write("<root><child>text</child></root>")
+            with open(sh_file_name, "w") as f:
+                f.write("#bin/sh\n echo 1")
+            with open(md_file_name, "w") as f:
+                f.write(".md file content")
+            with open(binary_file_name, "wb") as f:  # Write binary file
+                f.write(binary_content)
+            with open(binary_file_not_included, "w") as f:
+                f.write("---")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+
+            assert result.exit_code == 0
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                assert f"content/{xml_file_name}" in z.namelist()
+                assert f"content/{sh_file_name}" not in z.namelist()
+                assert f"content/{md_file_name}" in z.namelist()
+                assert f"content/{binary_file_not_included}" not in z.namelist()
+                assert f"content/{binary_file_name}" in z.namelist()
+                assert "content/pyproject.toml" in z.namelist()
+                # Verify binary content is not corrupted
+                extracted_binary_content = z.read(f"content/{binary_file_name}")
+                assert extracted_binary_content == binary_content, (
+                    "Binary file content was corrupted during packing"
+                )
+
+    def test_include_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test generating operate.json and its content."""
+        file_to_add = "file_to_add.xml"
+        random_file = "random_file.xml"
+        pack_options = {"filesIncluded": [file_to_add]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            with open(file_to_add, "w") as f:
+                f.write("<root><child>text</child></root>")
+            with open(random_file, "w") as f:
+                f.write("<root><child>text</child></root>")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+
+            assert result.exit_code == 0
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                assert f"content/{file_to_add}" in z.namelist()
+                assert f"content/{random_file}" not in z.namelist()
+
+    def test_include_subdir_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test generating operate.json and its content."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            os.mkdir("subdir")
+            with open("subdir/should_be_included.py", "w") as f:
+                f.write('print("This file should be included in the .nupkg")')
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+
+            assert result.exit_code == 0
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                assert "content/subdir/should_be_included.py" in z.namelist()
+
+    def test_successful_pack(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test error handling in pack command."""
+        functions = {"agent1": "agent1.py:main", "agent2": "agent2.py:execute"}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(functions), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create function files
+            with open("agent1.py", "w") as f:
+                f.write("def main(input): return input")
+            with open("agent2.py", "w") as f:
+                f.write("def execute(input): return input")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+
+            assert result.exit_code == 0
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                assert result.exit_code == 0
+                assert "content/agent1.py" in z.namelist()
+                assert "content/agent2.py" in z.namelist()
+                assert "Packaging project" in result.output
+                assert f"Name       : {project_details.name}" in result.output
+                assert f"Version    : {project_details.version}" in result.output
+                assert f"Description: {project_details.description}" in result.output
+                authors_dict = {
+                    author["name"]: author for author in project_details.authors
+                }
+                assert f"Authors    : {', '.join(authors_dict.keys())}" in result.output
+                assert "Project successfully packaged." in result.output
+
+    def test_dependencies_version_formats(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that all dependency version formats are parsed correctly and included in operate.json."""
+
+        # Update project details with comprehensive dependency examples
+        project_details.dependencies = [
+            # Simple package name
+            "click",
+            # Single version constraints
+            "django>=4.0",
+            "flask==2.3.0",
+            "numpy>1.20.0",
+            "pandas<=2.0.0",
+            "scipy<1.11.0",
+            "matplotlib~=3.5.0",
+            "pytest!=7.1.0",
+            # Complex version constraints
+            "tensorflow>=2.10.0,<2.13.0",
+            "torch>=1.12.0,<=1.13.1",
+            # Package with extras
+            "requests[security]>=2.28.0",
+            "sqlalchemy[postgresql,mysql]>=1.4.0",
+            # Environment markers (should be stripped)
+            "pywin32>=227; sys_platform=='win32'",
+            "uvloop>=0.17.0; python_version>='3.8' and sys_platform!='win32'",
+            # Complex combination
+            "cryptography[ssh]>=3.4.8,<4.0.0; python_version>='3.7'",
+            # Edge cases
+            "some-package_with.dots_and-dashes>=1.0.0",
+            "CamelCasePackage==2.1.0",
+        ]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            # Run pack command
+            result = runner.invoke(cli, ["pack", "./"], env={})
+
+            # Assert pack was successful
+            assert result.exit_code == 0, f"Pack failed with output: {result.output}"
+            assert "Project successfully packaged." in result.output
+
+            # Verify package was created
+            package_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(package_path)
+
+            # Extract and verify operate.json content
+            with zipfile.ZipFile(package_path, "r") as z:
+                # Read operate.json
+                operate_content = z.read("content/operate.json").decode("utf-8")
+                operate_data = json.loads(operate_content)
+
+                # Verify dependencies exist in operate.json
+                assert "dependencies" in operate_data, (
+                    "Dependencies should be present in operate.json"
+                )
+
+                dependencies = operate_data["dependencies"]
+
+                # Expected parsed dependencies (name -> version_spec)
+                expected_dependencies = {
+                    # Simple package name
+                    "click": "*",
+                    # Single version constraints
+                    "django": ">=4.0",
+                    "flask": "==2.3.0",
+                    "numpy": ">1.20.0",
+                    "pandas": "<=2.0.0",
+                    "scipy": "<1.11.0",
+                    "matplotlib": "~=3.5.0",
+                    "pytest": "!=7.1.0",
+                    # Complex version constraints
+                    "tensorflow": ">=2.10.0,<2.13.0",
+                    "torch": ">=1.12.0,<=1.13.1",
+                    # Package with extras (extras should be stripped)
+                    "requests": ">=2.28.0",
+                    "sqlalchemy": ">=1.4.0",
+                    # Environment markers (markers should be stripped)
+                    "pywin32": ">=227",
+                    "uvloop": ">=0.17.0",
+                    # Complex combination (extras and markers stripped)
+                    "cryptography": ">=3.4.8,<4.0.0",
+                    # Edge cases
+                    "some-package_with.dots_and-dashes": ">=1.0.0",
+                    "CamelCasePackage": "==2.1.0",
+                }
+
+                # Verify all expected dependencies are present
+                for package_name, expected_version in expected_dependencies.items():
+                    assert package_name in dependencies, (
+                        f"Package '{package_name}' should be in dependencies"
+                    )
+                    actual_version = dependencies[package_name]
+                    assert actual_version == expected_version, (
+                        f"Package '{package_name}' should have version '{expected_version}', "
+                        f"but got '{actual_version}'"
+                    )
+
+                # Verify no unexpected dependencies
+                for package_name in dependencies:
+                    assert package_name in expected_dependencies, (
+                        f"Unexpected package '{package_name}' found in dependencies"
+                    )
+
+                # Verify specific edge cases
+                assert len(dependencies) == len(expected_dependencies), (
+                    f"Expected {len(expected_dependencies)} dependencies, "
+                    f"but got {len(dependencies)}"
+                )
+
+                # Test that environment markers were properly stripped
+                assert "pywin32" in dependencies
+                assert dependencies["pywin32"] == ">=227"
+
+                # Test that extras were properly stripped but version preserved
+                assert "sqlalchemy" in dependencies
+                assert dependencies["sqlalchemy"] == ">=1.4.0"
+
+                # Test complex version constraints are preserved
+                assert "tensorflow" in dependencies
+                assert dependencies["tensorflow"] == ">=2.10.0,<2.13.0"
+
+                # Verify operate.json structure is still correct
+                assert (
+                    operate_data["$schema"]
+                    == "https://cloud.uipath.com/draft/2024-12/entry-point"
+                )
+                assert "projectId" in operate_data
+                assert operate_data["targetRuntime"] == "python"
+                assert operate_data["targetFramework"] == "Portable"
+
+    def test_nupkg_contains_all_necessary_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        functions = {"agent1": "agent1.py:main", "agent2": "agent2.py:execute"}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(functions), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("uv.lock", "w") as f:
+                f.write("# uv.lock content")
+
+            # Create function files
+            with open("agent1.py", "w") as f:
+                f.write("def main(input): return input")
+            with open("agent2.py", "w") as f:
+                f.write("def execute(input): return input")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            nupkg_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(nupkg_path)
+
+            # List of expected files in the package
+            expected_files = [
+                "content/uipath.json",
+                "content/pyproject.toml",
+                "content/operate.json",
+                "content/entry-points.json",
+                "content/bindings_v2.json",
+                "content/uv.lock",
+                "content/agent1.py",
+                "content/agent2.py",
+            ]
+
+            with zipfile.ZipFile(nupkg_path, "r") as z:
+                actual_files = set(z.namelist())
+                for expected in expected_files:
+                    assert expected in actual_files, f"Missing {expected} in nupkg"
+
+    def test_no_uv_lock_with_nolock(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("uv.lock", "w") as f:
+                f.write("# uv.lock content")
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./", "--nolock"], env={})
+            assert result.exit_code == 0
+
+            nupkg_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(nupkg_path)
+
+            with zipfile.ZipFile(nupkg_path, "r") as z:
+                actual_files = set(z.namelist())
+                assert "content/uv.lock" not in actual_files, (
+                    "uv.lock should not be in nupkg when --nolock is used"
+                )
+
+    def test_files_excluded(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that files mentioned in filesExcluded are excluded from the package."""
+        json_file_to_exclude = "config.json"
+        json_file_to_include = "other.json"
+
+        pack_options = {"filesExcluded": [json_file_to_exclude]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create files - .json files are included by default
+            with open(json_file_to_exclude, "w") as f:
+                f.write('{"should": "be excluded"}')
+            with open(json_file_to_include, "w") as f:
+                f.write('{"should": "be included"}')
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Excluded file should not be present
+                assert f"content/{json_file_to_exclude}" not in z.namelist()
+                # Other JSON file should still be present
+                assert f"content/{json_file_to_include}" in z.namelist()
+
+    def test_files_excluded_takes_precedence_over_included(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that filesExcluded takes precedence over filesIncluded."""
+        conflicting_file = "conflicting.txt"
+
+        pack_options = {
+            "filesIncluded": [conflicting_file],
+            "filesExcluded": [conflicting_file],
+        }
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create the conflicting file
+            with open(conflicting_file, "w") as f:
+                f.write("This file should be excluded despite being in filesIncluded")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # File should be excluded (exclusion takes precedence)
+                assert f"content/{conflicting_file}" not in z.namelist()
+
+    def test_filename_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that filename exclusion only affects root directory, path exclusion affects specific paths."""
+        pack_options = {"filesExcluded": ["config.json", "subdir2/settings.json"]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create directories
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            # Create files with same names in different locations
+            with open("config.json", "w") as f:  # Root - should be excluded
+                f.write('{"root": "config"}')
+            with open("subdir1/config.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir1": "config"}')
+            with open("subdir2/config.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir2": "config"}')
+
+            with open("settings.json", "w") as f:  # Root - should be included
+                f.write('{"root": "settings"}')
+            with open("subdir1/settings.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir1": "settings"}')
+            with open(
+                "subdir2/settings.json", "w"
+            ) as f:  # Specific path - should be excluded
+                f.write('{"subdir2": "settings"}')
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Filename exclusion: only affects root directory
+                assert "content/config.json" not in z.namelist()  # Root excluded
+                assert "content/subdir1/config.json" in z.namelist()  # Subdir included
+                assert "content/subdir2/config.json" in z.namelist()  # Subdir included
+
+                # Path exclusion: only affects specific path
+                assert "content/settings.json" in z.namelist()  # Root included
+                assert (
+                    "content/subdir1/settings.json" in z.namelist()
+                )  # Different path included
+                assert (
+                    "content/subdir2/settings.json" not in z.namelist()
+                )  # Specific path excluded
+
+    def test_filename_vs_path_inclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that filename inclusion only affects root directory, path inclusion affects specific paths."""
+        pack_options = {"filesIncluded": ["data.txt", "subdir1/config.txt"]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create directories
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            # Create .txt files (not included by default extension)
+            with open("data.txt", "w") as f:  # Root - should be included by filename
+                f.write("root data")
+            with open("subdir1/data.txt", "w") as f:  # Subdir - should NOT be included
+                f.write("subdir1 data")
+            with open(
+                "subdir2/data.txt", "w"
+            ) as f:  # Different subdir - should NOT be included
+                f.write("subdir2 data")
+
+            with open("config.txt", "w") as f:  # Root - should NOT be included
+                f.write("root config")
+            with open(
+                "subdir1/config.txt", "w"
+            ) as f:  # Specific path - should be included
+                f.write("subdir1 config")
+            with open(
+                "subdir2/config.txt", "w"
+            ) as f:  # Different path - should NOT be included
+                f.write("subdir2 config")
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Filename inclusion: only affects root directory
+                assert "content/data.txt" in z.namelist()  # Root included
+                assert (
+                    "content/subdir1/data.txt" not in z.namelist()
+                )  # Subdir not included
+                assert (
+                    "content/subdir2/data.txt" not in z.namelist()
+                )  # Subdir not included
+
+                # Path inclusion: only affects specific path
+                assert "content/config.txt" not in z.namelist()  # Root not included
+                assert (
+                    "content/subdir1/config.txt" in z.namelist()
+                )  # Specific path included
+                assert (
+                    "content/subdir2/config.txt" not in z.namelist()
+                )  # Different path not included
+
+    def test_directory_name_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that directory exclusion by name only affects root level, by path affects specific paths."""
+        pack_options = {"directoriesExcluded": ["temp", "tests/old"]}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(pack_options=pack_options), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create directory structure
+            os.makedirs("temp")  # Root level - should be excluded
+            os.makedirs("src/temp")  # Nested - should be included
+            os.makedirs("tests/old")  # Specific path - should be excluded
+            os.makedirs("tests/new")  # Different path - should be included
+            os.makedirs("old")  # Root level - should be included
+
+            # Create JSON files in each directory (included by default)
+            with open("temp/config.json", "w") as f:
+                f.write('{"location": "root temp"}')
+            with open("src/temp/config.json", "w") as f:
+                f.write('{"location": "src temp"}')
+            with open("tests/old/config.json", "w") as f:
+                f.write('{"location": "tests old"}')
+            with open("tests/new/config.json", "w") as f:
+                f.write('{"location": "tests new"}')
+            with open("old/config.json", "w") as f:
+                f.write('{"location": "root old"}')
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Directory name exclusion: only affects root level
+                assert (
+                    "content/temp/config.json" not in z.namelist()
+                )  # Root temp excluded
+                assert (
+                    "content/src/temp/config.json" in z.namelist()
+                )  # Nested temp included
+
+                # Directory path exclusion: only affects specific path
+                assert (
+                    "content/tests/old/config.json" not in z.namelist()
+                )  # Specific path excluded
+                assert (
+                    "content/tests/new/config.json" in z.namelist()
+                )  # Different path included
+                assert "content/old/config.json" in z.namelist()  # Root old included
+
+    def test_bindings_v2_naming_in_nupkg(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that bindings.json is named bindings_v2.json in the .nupkg."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files for packing
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create bindings.json with some test resources
+            bindings_content = {
+                "version": "2.0",
+                "resources": [
+                    {
+                        "resource": "asset",
+                        "key": "test-asset",
+                        "value": {
+                            "name": {
+                                "defaultValue": "test-asset",
+                                "isExpression": False,
+                                "displayName": "Asset Name",
+                            }
+                        },
+                        "metadata": {
+                            "BindingsVersion": "2.2",
+                            "ActivityName": "retrieve",
+                        },
+                    }
+                ],
+            }
+            with open("bindings.json", "w") as f:
+                json.dump(bindings_content, f, indent=4)
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            nupkg_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(nupkg_path)
+
+            with zipfile.ZipFile(nupkg_path, "r") as z:
+                # Verify bindings file is named bindings_v2.json in the package
+                assert "content/bindings_v2.json" in z.namelist()
+
+                # Verify the content is correct
+                bindings_v2_content = z.read("content/bindings_v2.json").decode("utf-8")
+                bindings_v2_data = json.loads(bindings_v2_content)
+
+                assert bindings_v2_data["version"] == "2.0"
+                assert len(bindings_v2_data["resources"]) == 1
+                assert bindings_v2_data["resources"][0]["resource"] == "asset"
+                assert bindings_v2_data["resources"][0]["key"] == "test-asset"
+
+    def test_evals_and_evaluations_directories_excluded(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that evals and evaluations directories are excluded from the nupkg."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            os.makedirs("evals")
+            os.makedirs("evaluations")
+            os.makedirs("other_dir")
+
+            with open("evals/test_eval.json", "w") as f:
+                f.write('{"eval": "data"}')
+            with open("evaluations/test_evaluation.json", "w") as f:
+                f.write('{"evaluation": "data"}')
+            with open("other_dir/included.json", "w") as f:
+                f.write('{"should": "be included"}')
+
+            # Mock middleware and run init
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            nupkg_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(nupkg_path)
+
+            with zipfile.ZipFile(nupkg_path, "r") as z:
+                assert "content/evals/test_eval.json" not in z.namelist()
+                assert "content/evaluations/test_evaluation.json" not in z.namelist()
+                assert "content/other_dir/included.json" in z.namelist()
+
+    def test_generate_operate_file(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test generating operate.json from entry-points."""
+        from uipath._cli.models.runtime_schema import EntryPoint
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            create_bindings_file()
+
+            entrypoints = [
+                EntryPoint(
+                    filePath="agent1.py",
+                    uniqueId="agent1-id",
+                    type="agent",
+                    input={"type": "object", "properties": {}},
+                    output={"type": "object", "properties": {}},
+                )
+            ]
+
+            config = UiPathJsonConfig(
+                runtimeOptions=RuntimeOptions(is_conversational=False),
+                id="00000000-0000-0000-0000-000000000001",
+            )
+            operate_data = cli_pack.generate_operate_file(entrypoints, config)
+
+            assert (
+                operate_data["$schema"]
+                == "https://cloud.uipath.com/draft/2024-12/entry-point"
+            )
+            assert operate_data["projectId"] == "00000000-0000-0000-0000-000000000001"
+            assert operate_data["main"] == "agent1.py"
+            assert operate_data["contentType"] == "agent"
+            assert operate_data["targetFramework"] == "Portable"
+            assert operate_data["targetRuntime"] == "python"
+            assert operate_data["runtimeOptions"] == {
+                "requiresUserInteraction": False,
+                "isAttended": False,
+                "isConversational": False,
+            }
+
+    def test_pack_uses_agent_id_as_project_id(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """operate.json projectId is sourced from uipath.json#id."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            config = create_uipath_json()
+            config["id"] = "00000000-0000-0000-0000-000000000001"
+            with open("uipath.json", "w") as f:
+                json.dump(config, f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                operate_data = json.loads(z.read("content/operate.json"))
+            assert operate_data["projectId"] == "00000000-0000-0000-0000-000000000001"
+
+    def test_pack_fails_when_id_is_not_a_guid(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """pack fails when uipath.json#id is set but is not a valid GUID."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            config = create_uipath_json()
+            config["id"] = "not-a-guid"
+            with open("uipath.json", "w") as f:
+                json.dump(config, f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code != 0
+            assert "must be a valid GUID" in result.output
+
+    def test_pack_falls_back_to_telemetry_project_key(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Without id, operate.json projectId falls back to the telemetry key."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # uipath.json deliberately has no id (legacy project).
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+            create_entry_points_file()
+            os.makedirs(".uipath", exist_ok=True)
+            with open(os.path.join(".uipath", ".telemetry.json"), "w") as f:
+                json.dump({"ProjectKey": "telemetry-fallback-key"}, f)
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                operate_data = json.loads(z.read("content/operate.json"))
+            assert operate_data["projectId"] == "telemetry-fallback-key"
+
+    def test_pack_telemetry_fallback_from_outside_project_dir(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """The legacy telemetry fallback resolves against the packed directory, not CWD."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs("project")
+            with open(os.path.join("project", "uipath.json"), "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open(os.path.join("project", "pyproject.toml"), "w") as f:
+                f.write(project_details.to_toml())
+            with open(os.path.join("project", "main.py"), "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file(directory="project")
+            create_entry_points_file(directory="project")
+            os.makedirs(os.path.join("project", ".uipath"), exist_ok=True)
+            with open(os.path.join("project", ".uipath", ".telemetry.json"), "w") as f:
+                json.dump({"ProjectKey": "telemetry-fallback-key"}, f)
+
+            result = runner.invoke(cli, ["pack", "./project"], env={})
+            assert result.exit_code == 0
+
+            # the package itself is written under the caller's CWD
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg",
+                "r",
+            ) as z:
+                operate_data = json.loads(z.read("content/operate.json"))
+            assert operate_data["projectId"] == "telemetry-fallback-key"
+
+    def test_generate_bindings_content(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test generating bindings content."""
+        bindings_data = cli_pack.generate_bindings_content()
+
+        assert bindings_data.version == "2.0"
+        assert bindings_data.resources == []
+
+    def test_generate_entrypoints_file(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test generating entry-points.json from entry-points structure."""
+        from uipath._cli.models.runtime_schema import EntryPoint
+
+        entrypoints = [
+            EntryPoint(
+                filePath="agent1.py",
+                uniqueId="agent1-id",
+                type="agent",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            ),
+            EntryPoint(
+                filePath="agent2.py",
+                uniqueId="agent2-id",
+                type="agent",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            ),
+        ]
+
+        entrypoints_data = cli_pack.generate_entrypoints_file(entrypoints)
+
+        assert (
+            entrypoints_data["$schema"]
+            == "https://cloud.uipath.com/draft/2024-12/entry-point"
+        )
+        assert entrypoints_data["$id"] == "entry-points.json"
+        assert len(entrypoints_data["entryPoints"]) == 2
+        assert entrypoints_data["entryPoints"][0]["filePath"] == "agent1.py"
+        assert entrypoints_data["entryPoints"][1]["filePath"] == "agent2.py"
+
+    def test_package_descriptor_content(self, runner: CliRunner, temp_dir: str) -> None:
+        """Test generating package-descriptor.json content."""
+        from uipath._cli.models.runtime_schema import EntryPoint
+
+        entrypoints = [
+            EntryPoint(
+                filePath="agent1.py",
+                uniqueId="agent1-id",
+                type="agent",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            ),
+            EntryPoint(
+                filePath="agent2.py",
+                uniqueId="agent2-id",
+                type="agent",
+                input={"type": "object", "properties": {}},
+                output={"type": "object", "properties": {}},
+            ),
+        ]
+
+        expected_files = {
+            "operate.json": "content/operate.json",
+            "entry-points.json": "content/entry-points.json",
+            "bindings.json": "content/bindings_v2.json",
+            "agent1.py": "agent1.py",
+            "agent2.py": "agent2.py",
+        }
+
+        content = cli_pack.generate_package_descriptor_content(entrypoints)
+
+        assert (
+            content["$schema"]
+            == "https://cloud.uipath.com/draft/2024-12/package-descriptor"
+        )
+        assert len(content["files"]) == 5
+        assert content["files"] == expected_files
+
+    def test_is_conversational_in_operate_json(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that is_conversational is correctly placed in operate.json runtimeOptions."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files for packing
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+            create_bindings_file()
+
+            # Mock middleware and run init to generate entry-points.json
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            # Modify uipath.json to set is_conversational to true
+            with open("uipath.json", "r") as f:
+                config = json.load(f)
+
+            # Add runtimeOptions with isConversational set to true
+            config["runtimeOptions"] = {"isConversational": True}
+
+            with open("uipath.json", "w") as f:
+                json.dump(config, f, indent=2)
+
+            # Run pack command
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+
+            # Extract and verify operate.json content
+            package_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(package_path)
+
+            with zipfile.ZipFile(package_path, "r") as z:
+                # Read operate.json
+                operate_content = z.read("content/operate.json").decode("utf-8")
+                operate_data = json.loads(operate_content)
+
+                # Verify runtimeOptions exists
+                assert "runtimeOptions" in operate_data, (
+                    "runtimeOptions should be present in operate.json"
+                )
+
+                # Verify isConversational is present and set to true
+                assert "isConversational" in operate_data["runtimeOptions"], (
+                    "isConversational should be present in runtimeOptions"
+                )
+                assert operate_data["runtimeOptions"]["isConversational"] is True, (
+                    "isConversational should be set to true"
+                )
+
+                # Verify default runtimeOptions fields are still present
+                assert (
+                    operate_data["runtimeOptions"]["requiresUserInteraction"] is False
+                )
+                assert operate_data["runtimeOptions"]["isAttended"] is False
+
+    def test_pack_warns_mixed_entrypoint_types(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+    ) -> None:
+        """Test that pack warns when there are mixed entrypoint types."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("agent.py", "w") as f:
+                f.write("def agent_main(input: str) -> str: return input")
+            with open("func.py", "w") as f:
+                f.write("def func_main(input: str) -> str: return input")
+
+            uipath_config = {
+                "agents": {"my_agent": "agent.py:agent_main"},
+                "functions": {"my_func": "func.py:func_main"},
+            }
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            create_bindings_file()
+
+            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
+                mock_middleware.return_value = MiddlewareResult(should_continue=True)
+                init_result = runner.invoke(cli, ["init"], env={})
+                assert init_result.exit_code == 0
+
+            result = runner.invoke(cli, ["pack", "./"], env={})
+            assert result.exit_code == 0
+            assert "Mixed entrypoint types detected: [" in result.output
+            assert (
+                "We recommend using a single type for all entrypoints" in result.output
+            )
diff --git a/tests/cli/test_publish.py b/packages/uipath/tests/cli/test_publish.py
similarity index 71%
rename from tests/cli/test_publish.py
rename to packages/uipath/tests/cli/test_publish.py
index c8e2d9e47..3190b876c 100644
--- a/tests/cli/test_publish.py
+++ b/packages/uipath/tests/cli/test_publish.py
@@ -7,7 +7,7 @@
 from click.testing import CliRunner
 from pytest_httpx import HTTPXMock
 
-from uipath._cli.cli_publish import publish  # type: ignore
+from uipath._cli import cli
 
 
 @pytest.fixture
@@ -35,7 +35,7 @@ def test_publish_no_env(
     ) -> None:
         """Test publish command when no env file exists."""
         with runner.isolated_filesystem(temp_dir=temp_dir):
-            result = runner.invoke(publish)
+            result = runner.invoke(cli, ["publish"])
             assert result.exit_code == 1
             assert "Missing required environment variables." in result.output
             assert "UIPATH_URL" in result.output
@@ -60,7 +60,7 @@ def test_publish_no_package(
                 mock_prompt.return_value = 0
                 _create_env_file(mock_env_vars)
                 os.makedirs(".uipath")
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
                 assert result.exit_code == 1
                 assert (
                     "No .nupkg files found. Please run `uipath pack` first."
@@ -86,17 +86,17 @@ def test_publish_invalid_feed(
                 _create_env_file(mock_env_vars)
                 # negative value
                 mock_prompt.return_value = -1
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
                 assert result.exit_code == 1
                 assert "Invalid feed selected" in result.output
                 # invalid type
                 mock_prompt.return_value = "string"
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
                 assert result.exit_code == 1
                 assert type(result.exception) is TypeError
                 # index error
                 mock_prompt.return_value = len(mock_feeds_response) + 1
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
                 assert result.exit_code == 1
                 assert "Invalid feed selected" in result.output
 
@@ -122,7 +122,7 @@ def test_publish_error(
 
             _create_env_file(mock_env_vars)
 
-            result = runner.invoke(publish, ["--tenant"])
+            result = runner.invoke(cli, ["publish", "--tenant"])
 
             assert result.exit_code == 1
             assert "Failed to publish package. Status code: 401" in result.output
@@ -149,7 +149,7 @@ def test_publish_tenant_feed_success(
 
             _create_env_file(mock_env_vars)
 
-            result = runner.invoke(publish, ["--tenant"])
+            result = runner.invoke(cli, ["publish", "--tenant"])
 
             assert result.exit_code == 0
             assert "Package published successfully!" in result.output
@@ -181,7 +181,7 @@ def test_publish_folder_feed_success(
                 patch("uipath._cli.cli_publish.console.prompt") as mock_prompt,
                 patch("uipath._cli.cli_publish.get_available_feeds") as mock_feeds,
                 patch(
-                    "uipath._cli.cli_publish.get_personal_workspace_info"
+                    "uipath._cli.cli_publish.get_personal_workspace_info_async"
                 ) as mock_workspace,
             ):
                 mock_prompt.return_value = 1  # Select second feed (index 1)
@@ -192,7 +192,7 @@ def test_publish_folder_feed_success(
                 )  # Different from our target feed
                 _create_env_file(mock_env_vars)
 
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
 
                 assert result.exit_code == 0
                 assert "Package published successfully!" in result.output
@@ -200,9 +200,7 @@ def test_publish_folder_feed_success(
                 # Verify the methods were called correctly
                 mock_prompt.assert_called_once_with("Select feed number", type=int)
                 mock_feeds.assert_called_once()
-                mock_workspace.assert_called_once_with(
-                    base_url, mock_env_vars.get("UIPATH_ACCESS_TOKEN")
-                )
+                mock_workspace.assert_called_once()
 
     def test_publish_personal_workspace_not_found(
         self,
@@ -218,12 +216,12 @@ def test_publish_personal_workspace_not_found(
                 f.write(b"dummy package content")
 
             with patch(
-                "uipath._cli.cli_publish.get_personal_workspace_info"
+                "uipath._cli.cli_publish.get_personal_workspace_info_async"
             ) as mock_workspace:
                 _create_env_file(mock_env_vars)
                 mock_workspace.return_value = (None, None)
 
-                result = runner.invoke(publish, ["--my-workspace"])
+                result = runner.invoke(cli, ["publish", "--my-workspace"])
 
                 assert result.exit_code == 1
                 assert "No personal workspace found for user" in result.output
@@ -290,7 +288,7 @@ def test_publish_my_workspace_feed_success(
 
             _create_env_file(mock_env_vars)
 
-            result = runner.invoke(publish, ["--my-workspace"])
+            result = runner.invoke(cli, ["publish", "--my-workspace"])
             expected_release_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={my_workspace_folder_id}"
             assert result.exit_code == 0
             assert "Package published successfully!" in result.output
@@ -393,7 +391,7 @@ def test_publish_my_workspace_feed_without_flag(
                 mock_prompt.return_value = 2
                 _create_env_file(mock_env_vars)
 
-                result = runner.invoke(publish)
+                result = runner.invoke(cli, ["publish"])
                 expected_release_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={my_workspace_folder_id}"
                 assert result.exit_code == 0
                 assert "Package published successfully!" in result.output
@@ -402,3 +400,141 @@ def test_publish_my_workspace_feed_without_flag(
                     "Use the link above to configure any environment variables"
                     in result.output
                 )
+
+    def test_publish_with_folder_success(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+        mock_feeds_response: list[tuple[str, str]],
+    ) -> None:
+        """Test successful publish using --folder option."""
+        base_url = mock_env_vars.get("UIPATH_URL")
+        folder_feed_name, folder_feed_id = mock_feeds_response[1]
+
+        # Mock the GetFeeds API
+        feeds_response_data = [
+            {"name": name, "id": id, "purpose": "Processes"}
+            for name, id in mock_feeds_response
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/PackageFeeds/GetFeeds",
+            status_code=200,
+            text=json.dumps(feeds_response_data),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage()?feedId={folder_feed_id}",
+            status_code=200,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs(".uipath")
+            with open(os.path.join(".uipath", "test.1.0.0.nupkg"), "wb") as f:
+                f.write(b"dummy package content")
+
+            with patch(
+                "uipath._cli.cli_publish.get_personal_workspace_info_async"
+            ) as mock_workspace:
+                mock_workspace.return_value = (
+                    "different-feed-id",
+                    "folder-id",
+                )
+                _create_env_file(mock_env_vars)
+
+                result = runner.invoke(cli, ["publish", "--folder", folder_feed_name])
+
+                assert result.exit_code == 0
+                assert "Package published successfully!" in result.output
+                assert f"Using feed: {folder_feed_name}" in result.output
+
+    def test_publish_with_folder_not_found(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+        mock_feeds_response: list[tuple[str, str]],
+    ) -> None:
+        """Test publish with non-existent folder name."""
+        base_url = mock_env_vars.get("UIPATH_URL")
+
+        # Mock the GetFeeds API
+        feeds_response_data = [
+            {"name": name, "id": id, "purpose": "Processes"}
+            for name, id in mock_feeds_response
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/PackageFeeds/GetFeeds",
+            status_code=200,
+            text=json.dumps(feeds_response_data),
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs(".uipath")
+            with open(os.path.join(".uipath", "test.1.0.0.nupkg"), "wb") as f:
+                f.write(b"dummy package content")
+
+            _create_env_file(mock_env_vars)
+
+            result = runner.invoke(cli, ["publish", "--folder", "NonExistentFolder"])
+
+            assert result.exit_code == 1  # Exits with error when folder not found
+            assert "Folder 'NonExistentFolder' not found" in result.output
+            assert "Available feeds:" in result.output
+
+    def test_publish_with_folder_core_name_match(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test publish using --folder with core name (without Orchestrator prefix and Feed suffix)."""
+        base_url = mock_env_vars.get("UIPATH_URL")
+
+        # Create a realistic feed name like "Orchestrator Ion Folder Feed Feed"
+        folder_feed_name = "Orchestrator Ion Folder Feed Feed"
+        folder_feed_id = "ion-folder-feed-id"
+
+        # Mock the GetFeeds API
+        feeds_response_data = [
+            {
+                "name": "Orchestrator Tenant Processes Feed",
+                "id": "tenant_feed_id",
+                "purpose": "Processes",
+            },
+            {"name": folder_feed_name, "id": folder_feed_id, "purpose": "Processes"},
+        ]
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/PackageFeeds/GetFeeds",
+            status_code=200,
+            text=json.dumps(feeds_response_data),
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage()?feedId={folder_feed_id}",
+            status_code=200,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            os.makedirs(".uipath")
+            with open(os.path.join(".uipath", "test.1.0.0.nupkg"), "wb") as f:
+                f.write(b"dummy package content")
+
+            with patch(
+                "uipath._cli.cli_publish.get_personal_workspace_info_async"
+            ) as mock_workspace:
+                mock_workspace.return_value = (
+                    "different-feed-id",
+                    "folder-id",
+                )
+                _create_env_file(mock_env_vars)
+
+                # Test with just the core folder name "Ion Folder Feed"
+                result = runner.invoke(cli, ["publish", "--folder", "Ion Folder Feed"])
+
+                assert result.exit_code == 0
+                assert "Package published successfully!" in result.output
+                assert f"Using feed: {folder_feed_name}" in result.output
diff --git a/packages/uipath/tests/cli/test_pull.py b/packages/uipath/tests/cli/test_pull.py
new file mode 100644
index 000000000..7b3aebd1a
--- /dev/null
+++ b/packages/uipath/tests/cli/test_pull.py
@@ -0,0 +1,754 @@
+# type: ignore
+import json
+import os
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from click.testing import CliRunner
+from pytest_httpx import HTTPXMock
+from utils.project_details import ProjectDetails
+
+from tests.cli.utils.common import configure_env_vars
+from uipath._cli import cli
+from uipath._cli._utils._common import may_override_files
+from uipath._cli._utils._studio_project import StudioProjectMetadata
+from uipath.platform.errors import EnrichedException
+
+
+def create_uipath_json(functions: dict[str, str] | None = None):
+    """Helper to create uipath.json with functions structure."""
+    if functions is None:
+        functions = {"main": "main.py:main"}
+    return {"functions": functions}
+
+
+class TestPull:
+    """Test pull command."""
+
+    def test_pull_without_project_id(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+    ) -> None:
+        """Test pull when UIPATH_PROJECT_ID is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            result = runner.invoke(cli, ["pull", "./"], catch_exceptions=False, env={})
+            assert result.exit_code == 1
+            assert "UIPATH_PROJECT_ID environment variable not found." in result.output
+
+    def test_successful_pull(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test successful project pull with various file operations."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure response
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [
+                {
+                    "id": "evaluations-folder-id",
+                    "name": "evaluations",
+                    "folders": [
+                        {
+                            "id": "eval-sets-id",
+                            "name": "eval-sets",
+                            "files": [
+                                {
+                                    "id": "eval-sets-file-id",
+                                    "name": "test-set.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                        {
+                            "id": "evaluators-id",
+                            "name": "evaluators",
+                            "files": [
+                                {
+                                    "id": "evaluators-file-id",
+                                    "name": "test-evaluator.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                    ],
+                    "files": [],
+                },
+            ],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "789",
+                    "name": "uipath.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        # Mock file download responses
+        # For main.py
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/123",
+            content=b"print('Hello World')",
+        )
+
+        # For pyproject.toml
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/456",
+            content=project_details.to_toml().encode(),
+        )
+
+        # For uipath.json
+        uipath_json_content = create_uipath_json({"main": "main.py:main"})
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/789",
+            content=json.dumps(uipath_json_content).encode(),
+        )
+
+        # For eval-sets/test-set.json
+        test_set_content = {
+            "id": "02424d08-f482-4777-ac4d-233add24ee06",
+            "fileName": "evaluation-set-1752568767335.json",
+            "evaluatorRefs": [
+                "429d73a2-a748-4554-83d7-e32dec345931",
+                "bdb9f7c9-2d9e-4595-81c8-ef2a60216cb9",
+            ],
+            "evaluations": [],
+            "name": "Evaluation Set 2",
+            "batchSize": 10,
+            "timeoutMinutes": 20,
+            "modelSettings": [],
+            "createdAt": "2025-07-15T08:39:27.335Z",
+            "updatedAt": "2025-07-15T08:39:27.335Z",
+        }
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/eval-sets-file-id",
+            content=json.dumps(test_set_content, indent=2).encode(),
+        )
+
+        # For evaluators/test-evaluator.json
+        test_evaluator_content = {
+            "fileName": "evaluator-1752568815245.json",
+            "id": "52b716b1-c8ef-4da8-af31-fb218d0d5499",
+            "name": "Evaluator 3",
+            "description": "An evaluator that judges the agent based on its run history and expected behavior",
+            "type": 7,
+            "category": 3,
+            "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+            "targetOutputKey": "*",
+            "createdAt": "2025-07-15T08:40:15.245Z",
+            "updatedAt": "2025-07-15T08:40:15.245Z",
+        }
+
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/evaluators-file-id",
+            content=json.dumps(test_evaluator_content, indent=2).encode(),
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Set environment variables
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            # Run pull
+            result = runner.invoke(cli, ["pull", "./"])
+            assert result.exit_code == 0
+
+            # Verify source code files
+            assert "Downloaded 'main.py'" in result.output
+            assert "Downloaded 'pyproject.toml'" in result.output
+            assert "Downloaded 'uipath.json'" in result.output
+
+            # Verify source code file contents
+            with open("main.py", "r") as f:
+                assert f.read() == "print('Hello World')"
+            with open("pyproject.toml", "r") as f:
+                assert f.read() == project_details.to_toml()
+            with open("uipath.json", "r") as f:
+                assert json.load(f) == uipath_json_content
+
+            # Verify evals folder structure exists
+            assert os.path.isdir("evaluations")
+            assert os.path.isdir("evaluations/eval-sets")
+            assert os.path.isdir("evaluations/evaluators")
+
+            # Verify eval files exist and have correct content
+            with open("evaluations/eval-sets/test-set.json", "r") as f:
+                assert json.load(f) == test_set_content
+            with open("evaluations/evaluators/test-evaluator.json", "r") as f:
+                assert json.load(f) == test_evaluator_content
+
+    def test_pull_with_existing_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+        monkeypatch: Any,
+    ) -> None:
+        """Test pull when local files exist and differ from remote."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure response
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        # Mock file download response
+        remote_content = "print('Remote version')"
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/123",
+            content=remote_content.encode(),
+        )
+
+        remote_content_toml = "toml content"
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/456",
+            content=remote_content_toml.encode(),
+        )
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create local file with different content
+            local_content = "print('Local version')"
+            with open("main.py", "w") as f:
+                f.write(local_content)
+
+            # Set environment variables
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            # Mock user input to confirm override
+            monkeypatch.setattr("click.confirm", lambda *args, **kwargs: True)
+
+            # Run pull
+            result = runner.invoke(cli, ["pull", "./"])
+            assert result.exit_code == 0
+            # assert "differs from remote version" in result.output
+            assert "Updated 'main.py'" in result.output
+
+            # Verify file was updated
+            with open("main.py", "r") as f:
+                assert f.read() == remote_content
+
+    def test_pull_with_api_error(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test pull when API request fails."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock API error response
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            status_code=401,
+            json={"message": "Unauthorized"},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Set environment variables
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["pull", "./"])
+            assert result.exit_code == 1
+            assert isinstance(result.exception, EnrichedException)
+            assert result.exception.status_code == 401
+
+    def test_pull_non_coded_agent_project(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test pull when the project is not a coded agent project (missing pyproject.toml)."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock a project structure WITHOUT pyproject.toml (not a coded agent project)
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "789",
+                    "name": "uipath.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "main.xaml",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["pull", "./"])
+            assert result.exit_code == 1
+            assert (
+                "The targeted Studio Web project is not of type coded agent"
+                in result.output
+            )
+            assert (
+                "Please check the UIPATH_PROJECT_ID environment variable"
+                in result.output
+            )
+
+    def test_pull_multiple_eval_folders(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that pull command uses evaluations folder instead of evals."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure with evaluations folder
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [
+                {
+                    "id": "evaluations-id",
+                    "name": "evaluations",
+                    "folders": [
+                        {
+                            "id": "evaluators-id",
+                            "name": "evaluators",
+                            "files": [
+                                {
+                                    "id": "evaluator-1-id",
+                                    "name": "contains.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                        {
+                            "id": "eval-sets-id",
+                            "name": "eval-sets",
+                            "files": [
+                                {
+                                    "id": "eval-set-1-id",
+                                    "name": "default.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                    ],
+                    "files": [],
+                },
+                {
+                    "id": "evals-id-legacy",
+                    "name": "evals",
+                    "folders": [
+                        {
+                            "id": "evaluators-id",
+                            "name": "evaluators",
+                            "files": [
+                                {
+                                    "id": "evaluator-1-id-legacy",
+                                    "name": "contains.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                        {
+                            "id": "eval-sets-id",
+                            "name": "eval-sets",
+                            "files": [
+                                {
+                                    "id": "eval-set-1-id-legacy",
+                                    "name": "default.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                }
+                            ],
+                            "folders": [],
+                        },
+                    ],
+                    "files": [],
+                },
+            ],
+            "files": [
+                {
+                    "id": "main-py-id",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        # Mock file downloads
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/main-py-id",
+            content=b"print('test')",
+        )
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/456",
+            content=b"toml content",
+        )
+
+        evaluator_content = {"version": "1.0", "name": "Contains Evaluator"}
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/evaluator-1-id",
+            content=json.dumps(evaluator_content, indent=2).encode(),
+        )
+
+        eval_set_content = {"version": "1.0", "name": "Default Eval Set"}
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/eval-set-1-id",
+            content=json.dumps(eval_set_content, indent=2).encode(),
+        )
+
+        evaluator_content_legacy = {
+            "version": "1.0",
+            "name": "Contains Evaluator legacy",
+        }
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/evaluator-1-id-legacy",
+            content=json.dumps(evaluator_content_legacy, indent=2).encode(),
+        )
+
+        eval_set_content_legacy = {"version": "1.0", "name": "Default Eval Set legacy"}
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/File/eval-set-1-id-legacy",
+            content=json.dumps(eval_set_content_legacy, indent=2).encode(),
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["pull", "./"])
+            assert result.exit_code == 0
+
+            # Verify files from evaluations are downloaded to evaluations/ directory
+            assert os.path.exists("evaluations/evaluators/contains.json")
+            assert os.path.exists("evaluations/eval-sets/default.json")
+
+            # Verify content
+            with open("evaluations/evaluators/contains.json", "r") as f:
+                assert json.load(f) == evaluator_content
+            with open("evaluations/eval-sets/default.json", "r") as f:
+                assert json.load(f) == eval_set_content
+
+            # Verify files from evals are downloaded to evals/ directory
+            assert os.path.exists("evals/evaluators/contains.json")
+            assert os.path.exists("evals/eval-sets/default.json")
+
+            # Verify content
+            with open("evals/evaluators/contains.json", "r") as f:
+                assert json.load(f) == evaluator_content_legacy
+            with open("evals/eval-sets/default.json", "r") as f:
+                assert json.load(f) == eval_set_content_legacy
+
+
+class TestMayOverrideFiles:
+    """Test may_override_files function for pull scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_no_remote_metadata_returns_true(self):
+        """Test that when remote metadata doesn't exist, returns True without prompting."""
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = None
+
+        result = await may_override_files(mock_studio_client, "local")
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_no_local_metadata_prompts_user_confirms(self, tmp_path, monkeypatch):
+        """Test that when local metadata doesn't exist, prompts user and returns True on confirm."""
+        # Create mock remote metadata
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Mock UiPathConfig to return non-existent path
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = (
+                tmp_path / ".uipath" / "metadata.json"
+            )
+
+            # Mock console.confirm to return True
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = True
+
+                result = await may_override_files(mock_studio_client, "local")
+                assert result is True
+                mock_console.warning.assert_called_once()
+                mock_console.confirm.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_no_local_metadata_prompts_user_denies(self, tmp_path):
+        """Test that when local metadata doesn't exist, prompts user and returns False on deny."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = (
+                tmp_path / ".uipath" / "metadata.json"
+            )
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = False
+
+                result = await may_override_files(mock_studio_client, "local")
+                assert result is False
+
+    @pytest.mark.asyncio
+    async def test_local_version_greater_than_remote_returns_true(self, tmp_path):
+        """Test that when local version >= remote version, returns True without prompting."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with higher version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-19T10:00:00.000000+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "2.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            result = await may_override_files(mock_studio_client, "local")
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_local_version_less_than_remote_prompts_user(self, tmp_path):
+        """Test that when local version < remote version, prompts user."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="2.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with lower version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-17T10:00:00.000000+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "1.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = True
+
+                result = await may_override_files(mock_studio_client, "local")
+                assert result is True
+                mock_console.warning.assert_called_once()
+                mock_console.confirm.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_local_version_equal_to_remote_returns_true(self, tmp_path):
+        """Test that when local version == remote version, returns True without prompting."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with same version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-18T17:18:06.809284+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "1.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            result = await may_override_files(mock_studio_client, "local")
+            assert result is True
diff --git a/packages/uipath/tests/cli/test_push.py b/packages/uipath/tests/cli/test_push.py
new file mode 100644
index 000000000..d4d30a166
--- /dev/null
+++ b/packages/uipath/tests/cli/test_push.py
@@ -0,0 +1,2754 @@
+# type: ignore
+import json
+import os
+import re
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from click.testing import CliRunner
+from httpx import Request
+from pytest_httpx import HTTPXMock
+from utils.project_details import ProjectDetails
+
+from tests.cli.utils.common import configure_env_vars
+from uipath._cli import cli
+from uipath._cli._utils._common import may_override_files
+from uipath._cli._utils._studio_project import StudioProjectMetadata
+from uipath.platform.errors import EnrichedException
+
+
+def create_uipath_json(
+    functions: dict[str, str] | None = None, pack_options: dict | None = None
+):
+    """Helper to create uipath.json with functions structure."""
+    if functions is None:
+        functions = {"main": "main.py:main"}
+
+    config = {"functions": functions}
+    if pack_options:
+        config["packOptions"] = pack_options
+
+    return config
+
+
+def extract_metadata_json_from_modified_resources(
+    request: Request, *, metadata_file_id: str | None = None
+) -> dict[str, Any]:
+    """Extract studio_metadata.json content from ModifiedResources in StructuralMigration payload."""
+    match = re.search(
+        rb"boundary=([-._0-9A-Za-z]+)", request.headers.get("Content-Type", "").encode()
+    )
+    if match is None:
+        match = re.search(rb"--([-._0-9A-Za-z]+)", request.content)
+    assert match is not None, "Could not detect multipart boundary"
+    boundary = match.group(1)
+    parts = request.content.split(b"--" + boundary)
+
+    assert metadata_file_id is not None, (
+        "metadata_file_id is required to extract studio_metadata.json from ModifiedResources"
+    )
+    target_index: str | None = None
+    for part in parts:
+        if (
+            b"Content-Disposition: form-data;" in part
+            and b"ModifiedResources[" in part
+            and b"].Id" in part
+        ):
+            body = part.split(b"\r\n\r\n", 1)
+            if len(body) == 2:
+                value = body[1].strip().strip(b"\r\n")
+                if value.decode(errors="ignore") == metadata_file_id:
+                    m = re.search(rb"ModifiedResources\[(\d+)\]\.Id", part)
+                    if m:
+                        target_index = m.group(1).decode()
+                        break
+
+    if target_index is not None:
+        for part in parts:
+            if (
+                b"Content-Disposition: form-data;" in part
+                and f"ModifiedResources[{target_index}].Content".encode() in part
+            ):
+                content_bytes = part.split(b"\r\n\r\n", 1)[1].split(b"\r\n")[0]
+                return json.loads(content_bytes.decode())
+
+    raise AssertionError(
+        "studio_metadata.json content not found in ModifiedResources of StructuralMigration payload"
+    )
+
+
+def extract_metadata_json_from_added_resources(request: Request) -> dict[str, Any]:
+    """Extract studio_metadata.json content from AddedResources in StructuralMigration payload."""
+    match = re.search(
+        rb"boundary=([-._0-9A-Za-z]+)", request.headers.get("Content-Type", "").encode()
+    )
+    if match is None:
+        match = re.search(rb"--([-._0-9A-Za-z]+)", request.content)
+    assert match is not None, "Could not detect multipart boundary"
+    boundary = match.group(1)
+    parts = request.content.split(b"--" + boundary)
+
+    for part in parts:
+        if (
+            b"Content-Disposition: form-data;" in part
+            and b"AddedResources[" in part
+            and b"].Content" in part
+            and b'filename="studio_metadata.json"' in part
+        ):
+            content_bytes = part.split(b"\r\n\r\n", 1)[1].split(b"\r\n")[0]
+            return json.loads(content_bytes.decode())
+
+    raise AssertionError(
+        "studio_metadata.json content not found in AddedResources of StructuralMigration payload"
+    )
+
+
+class TestPush:
+    """Test push command."""
+
+    base_url = "https://cloud.uipath.com/organization"
+    project_id = "test-project-id"
+
+    def _mock_file_download(
+        self,
+        httpx_mock,
+        file_id: str,
+        *,
+        file_content: str | None = None,
+        times: int = 1,
+    ):
+        for _ in range(times):
+            httpx_mock.add_response(
+                method="GET",
+                url=f"{TestPush.base_url}/studio_/backend/api/Project/{TestPush.project_id}/FileOperations/File/{file_id}",
+                status_code=200,
+                text="Remote file content" if not file_content else file_content,
+            )
+
+    def _create_required_files(self, exclude: list[str] | None = None):
+        required_files = ["uipath.json", "bindings.json", "entry-points.json"]
+        for file in required_files:
+            if exclude and file in exclude:
+                continue
+            with open(file, "w") as f:
+                f.write("{}")
+
+    def test_push_without_uipath_json(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+    ) -> None:
+        """Test push when uipath.json is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = "123"
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+            assert (
+                "uipath.json not found. Please run `uipath init` in the project directory."
+                in result.output
+            )
+
+    def test_push_without_required_files_shows_specific_missing(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+    ) -> None:
+        """Test push shows specific missing files when uipath.json and .uipath are missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = "123"
+
+            self._create_required_files(exclude=["bindings.json", "entry-points.json"])
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+            # Should show exactly which file is missing
+            assert (
+                "Missing required files: 'bindings.json', 'entry-points.json'"
+                in result.output
+            )
+            assert "Please run 'uipath init'" in result.output
+
+    def test_push_with_only_enty_points_json_missing(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+    ) -> None:
+        """Test push when .uipath directory exists but uipath.json is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["entry-points.json"])
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = "123"
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+            # Should show exactly which file is missing
+            assert "Missing required files: 'entry-points.json'" in result.output
+            assert "Please run 'uipath init'" in result.output
+
+    def test_push_without_project_id(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+    ) -> None:
+        """Test push when UIPATH_PROJECT_ID is missing."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+            configure_env_vars(mock_env_vars)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+            assert "UIPATH_PROJECT_ID environment variable not found." in result.output
+
+    def test_successful_push(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test successful project push with various file operations."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [
+                {
+                    "id": "uipath-folder",
+                    "name": ".uipath",
+                    "folders": [],
+                    "files": [
+                        {
+                            "id": "246",
+                            "name": "studio_metadata.json",
+                            "isMain": False,
+                            "fileType": "1",
+                            "isEntryPoint": False,
+                            "ignoredFromPublish": False,
+                        },
+                    ],
+                },
+            ],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "789",
+                    "name": "uipath.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "898",
+                    "name": "entry-points.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "123")
+        self._mock_file_download(httpx_mock, "456")
+        self._mock_file_download(httpx_mock, "789")
+
+        # metadata file should be retrieved twice
+        self._mock_file_download(
+            httpx_mock,
+            "246",
+            file_content=json.dumps(
+                {
+                    "schemaVersion": 1,
+                    "lastPushDate": "2025-11-20T13:07:31.515084+00:00",
+                    "lastPushAuthor": "john.doe@mail.com",
+                    "codeVersion": "1.0.3",
+                }
+            ),
+            times=2,
+        )
+
+        self._mock_file_download(httpx_mock, "898")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        # Mock empty folder cleanup - get structure again after migration
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            with open("uv.lock", "w") as f:
+                f.write('version = 1 \n requires-python = ">=3.11"')
+
+            os.mkdir(".uipath")
+            with open(os.path.join(".uipath", "studio_metadata.json"), "w") as f:
+                json.dump(
+                    {
+                        "schemaVersion": 1,
+                        "lastPushDate": "2025-11-20T13:07:31.515084+00:00",
+                        "lastPushAuthor": "john.doe@mail.com",
+                        "codeVersion": "1.0.3",
+                    },
+                    f,
+                )
+
+            # Set environment variables
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+            assert "Updating 'main.py'" in result.output
+            assert "Updating 'pyproject.toml'" in result.output
+            assert "Updating 'uipath.json'" in result.output
+            assert "Uploading 'uv.lock'" in result.output
+            assert "Updating '.uipath/studio_metadata.json'" in result.output
+            assert "Updating 'entry-points.json'" in result.output
+
+            structural_migration_request = httpx_mock.get_request(
+                method="POST",
+                url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            )
+            assert structural_migration_request is not None
+            metadata_json_content = extract_metadata_json_from_modified_resources(
+                structural_migration_request, metadata_file_id="246"
+            )
+
+            expected_code_version = "1.0.4"
+            actual_code_version = metadata_json_content.get("codeVersion")
+            assert actual_code_version == expected_code_version, (
+                f"Unexpected codeVersion. Expected: {expected_code_version}, Got: {actual_code_version}"
+            )
+
+    def test_successful_push_new_project(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test successful project push with various file operations."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure response
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        # Mock empty folder cleanup - get structure again after migration
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files
+            self._create_required_files(exclude=["entry-points.json"])
+
+            # Create entry-points.json with proper structure
+            with open("entry-points.json", "w") as f:
+                json.dump(
+                    {
+                        "entryPoints": [
+                            {
+                                "filePath": "main.py",
+                                "uniqueId": "main-id",
+                                "type": "agent",
+                                "input": {"type": "object", "properties": {}},
+                                "output": {"type": "object", "properties": {}},
+                            }
+                        ]
+                    },
+                    f,
+                )
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            with open("uv.lock", "w") as f:
+                f.write('version = 1 \n requires-python = ">=3.11"')
+
+            # Set environment variables
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+            assert "Uploading 'main.py'" in result.output
+            assert "Updating 'pyproject.toml'" in result.output
+            assert "Uploading 'uipath.json'" in result.output
+            assert "Uploading 'uv.lock'" in result.output
+            assert "Uploading '.uipath/studio_metadata.json'" in result.output
+            assert "Uploading 'entry-points.json'" in result.output
+
+            structural_migration_request = httpx_mock.get_request(
+                method="POST",
+                url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            )
+            assert structural_migration_request is not None
+            metadata_json_content = extract_metadata_json_from_added_resources(
+                structural_migration_request
+            )
+
+            expected_code_version = "1.0.0"
+            actual_code_version = metadata_json_content.get("codeVersion")
+            assert actual_code_version == expected_code_version, (
+                f"Unexpected codeVersion. Expected: {expected_code_version}, Got: {actual_code_version}"
+            )
+
+    def test_first_push_with_minimal_studio_metadata_from_init(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test first push when studio_metadata.json was created by init (minimal fields).
+
+        When `uipath init` creates studio_metadata.json it only includes
+        schemaVersion and codeVersion. The push command must backfill
+        lastPushAuthor and lastPushDate before uploading.
+        """
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Remote has no studio_metadata.json (first push)
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["entry-points.json"])
+
+            with open("entry-points.json", "w") as f:
+                json.dump(
+                    {
+                        "entryPoints": [
+                            {
+                                "filePath": "main.py",
+                                "uniqueId": "main-id",
+                                "type": "agent",
+                                "input": {"type": "object", "properties": {}},
+                                "output": {"type": "object", "properties": {}},
+                            }
+                        ]
+                    },
+                    f,
+                )
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            with open("uv.lock", "w") as f:
+                f.write('version = 1 \n requires-python = ">=3.11"')
+
+            # Create minimal studio_metadata.json as init would
+            os.mkdir(".uipath")
+            with open(os.path.join(".uipath", "studio_metadata.json"), "w") as f:
+                json.dump(
+                    {
+                        "schemaVersion": 1,
+                        "codeVersion": "1.0.0",
+                    },
+                    f,
+                )
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+            assert "Uploading '.uipath/studio_metadata.json'" in result.output
+
+            structural_migration_request = httpx_mock.get_request(
+                method="POST",
+                url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            )
+            assert structural_migration_request is not None
+            metadata_json_content = extract_metadata_json_from_added_resources(
+                structural_migration_request
+            )
+
+            # Must have backfilled the push-related fields
+            assert metadata_json_content["codeVersion"] == "1.0.0"
+            assert metadata_json_content["schemaVersion"] == 1
+            assert "lastPushAuthor" in metadata_json_content, (
+                "lastPushAuthor should be backfilled on first push"
+            )
+            assert "lastPushDate" in metadata_json_content, (
+                "lastPushDate should be backfilled on first push"
+            )
+
+    def test_push_with_api_error(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test push when API request fails."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            status_code=401,
+            json={"message": "Unauthorized"},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("uv.lock", "w") as f:
+                f.write("")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+
+            assert isinstance(result.exception, EnrichedException)
+            assert result.exception.status_code == 401
+
+    def test_push_non_coded_agent_project(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test push when the project is not a coded agent project (missing pyproject.toml)."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "789",
+                    "name": "uipath.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "main.xaml",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 1
+            assert (
+                "The targeted Studio Web project is not of type coded agent"
+                in result.output
+            )
+            assert (
+                "Please check the UIPATH_PROJECT_ID environment variable"
+                in result.output
+            )
+
+    def test_push_with_nolock_flag(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test push command with --nolock flag."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "789",
+                    "name": "uipath.json",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+        self._mock_file_download(httpx_mock, "789")
+        self._mock_file_download(httpx_mock, "456")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            with open("uv.lock", "w") as f:
+                f.write("")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(
+                cli, ["push", "./", "--ignore-resources", "--nolock"]
+            )
+            assert result.exit_code == 0
+            assert "Updating 'main.py'" in result.output
+            assert "Updating 'pyproject.toml'" in result.output
+            assert "Updating 'uipath.json'" in result.output
+            assert "uv.lock" not in result.output
+
+    def _mock_lock_retrieval(
+        self, httpx_mock: HTTPXMock, base_url: str, project_id: str, times: int
+    ):
+        for _ in range(times):
+            httpx_mock.add_response(
+                url=f"{base_url}/studio_/backend/api/Project/{project_id}/Lock",
+                json={
+                    "projectLockKey": "test-lock-key",
+                    "solutionLockKey": "test-solution-lock-key",
+                },
+            )
+
+    def test_push_files_excluded(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that files mentioned in filesExcluded are excluded from push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "123")
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+
+            # Create uipath.json with filesExcluded
+            uipath_config = create_uipath_json(
+                pack_options={"filesExcluded": ["config.json"]}
+            )
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("config.json", "w") as f:
+                f.write('{"should": "be excluded"}')
+            with open("other.json", "w") as f:
+                f.write('{"should": "be included"}')
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            assert "config.json" not in result.output
+            assert "Uploading 'other.json'" in result.output
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_files_excluded_takes_precedence_over_included(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that filesExcluded takes precedence over filesIncluded in push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+
+            uipath_config = create_uipath_json(
+                pack_options={
+                    "filesIncluded": ["conflicting.txt"],
+                    "filesExcluded": ["conflicting.txt"],
+                }
+            )
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("conflicting.txt", "w") as f:
+                f.write("This file should be excluded despite being in filesIncluded")
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            assert "conflicting.txt" not in result.output
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_filename_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that filename exclusion only affects root directory, path exclusion affects specific paths in push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+
+            uipath_config = create_uipath_json(
+                pack_options={"filesExcluded": ["config.json", "subdir2/settings.json"]}
+            )
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            with open("config.json", "w") as f:
+                f.write('{"root": "config"}')
+            with open("subdir1/config.json", "w") as f:
+                f.write('{"subdir1": "config"}')
+            with open("subdir2/config.json", "w") as f:
+                f.write('{"subdir2": "config"}')
+
+            with open("settings.json", "w") as f:
+                f.write('{"root": "settings"}')
+            with open("subdir1/settings.json", "w") as f:
+                f.write('{"subdir1": "settings"}')
+            with open("subdir2/settings.json", "w") as f:
+                f.write('{"subdir2": "settings"}')
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            assert "settings.json" in result.output
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_filename_vs_path_inclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that filename inclusion only affects root directory, path inclusion affects specific paths in push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+
+            uipath_config = create_uipath_json(
+                pack_options={"filesIncluded": ["data.txt", "subdir1/config.txt"]}
+            )
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create directories
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            # Create .txt files (not included by default extension)
+            with open("data.txt", "w") as f:  # Root - should be included by filename
+                f.write("root data")
+            with open("subdir1/data.txt", "w") as f:  # Subdir - should NOT be included
+                f.write("subdir1 data")
+            with open(
+                "subdir2/data.txt", "w"
+            ) as f:  # Different subdir - should NOT be included
+                f.write("subdir2 data")
+
+            with open("config.txt", "w") as f:  # Root - should NOT be included
+                f.write("root config")
+            with open(
+                "subdir1/config.txt", "w"
+            ) as f:  # Specific path - should be included
+                f.write("subdir1 config")
+            with open(
+                "subdir2/config.txt", "w"
+            ) as f:  # Different path - should NOT be included
+                f.write("subdir2 config")
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Filename inclusion should only affect root directory
+            # data.txt in root should be included, but not in subdirectories
+
+            # Path inclusion should only affect specific path
+            # subdir1/config.txt should be included, but not root or subdir2
+
+            assert (
+                "data.txt" in result.output or "config.txt" in result.output
+            )  # At least one should be present
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_directory_name_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that directory exclusion by name only affects root level, by path affects specific paths in push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+        self._mock_file_download(httpx_mock, "123")
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files(exclude=["uipath.json"])
+
+            uipath_config = create_uipath_json(
+                pack_options={"directoriesExcluded": ["temp", "tests/old"]}
+            )
+            with open("uipath.json", "w") as f:
+                json.dump(uipath_config, f)
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create directory structure
+            os.makedirs("temp")  # Root level - should be excluded
+            os.makedirs("src/temp")  # Nested - should be included
+            os.makedirs("tests/old")  # Specific path - should be excluded
+            os.makedirs("tests/new")  # Different path - should be included
+            os.makedirs("old")  # Root level - should be included
+
+            # Create JSON files in each directory (included by default)
+            with open("temp/config.json", "w") as f:
+                f.write('{"location": "root temp"}')
+            with open("src/temp/config.json", "w") as f:
+                f.write('{"location": "src temp"}')
+            with open("tests/old/config.json", "w") as f:
+                f.write('{"location": "tests old"}')
+            with open("tests/new/config.json", "w") as f:
+                f.write('{"location": "tests new"}')
+            with open("old/config.json", "w") as f:
+                f.write('{"location": "root old"}')
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Directory name exclusion should only affect root level
+            # temp/ directory should be excluded, so temp/config.json shouldn't appear
+            # but src/temp/config.json should be uploaded
+
+            # Directory path exclusion should only affect specific path
+            # tests/old/ should be excluded, but tests/new/ and old/ should be uploaded
+
+            # Since we exclude root temp/, its files shouldn't appear
+            # Since we exclude tests/old/, its files shouldn't appear
+            # Other directories should have their files uploaded
+
+            assert (
+                "config.json" in result.output
+            )  # Some config.json should be present from allowed directories
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_detects_source_file_conflicts(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+        monkeypatch: Any,
+    ) -> None:
+        """Test that push detects conflicts when remote files differ from local files."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure with existing files
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "123")
+        self._mock_file_download(httpx_mock, "456")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("print('Local version')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+            # Should detect conflict
+            assert "Updating 'main.py'" in result.output
+
+    def test_push_shows_up_to_date_for_unchanged_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that push shows 'up to date' message for files that haven't changed."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        local_main_content = "print('Same version')"
+        local_helper_content = "def helper(): pass"
+
+        # Mock the project structure with existing files
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "456",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "789",
+                    "name": "helper.py",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "123")
+        # Mock file downloads - return same content as local files
+        self._mock_file_download(httpx_mock, "456", file_content=local_main_content)
+        self._mock_file_download(httpx_mock, "789", file_content=local_helper_content)
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write(local_main_content)
+            with open("helper.py", "w") as f:
+                f.write(local_helper_content)
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+            # Files should show as up to date since content matches
+            assert "File 'main.py' is up to date" in result.output
+            assert "File 'helper.py' is up to date" in result.output
+            # Should not show updating messages
+            assert "Updating 'main.py'" not in result.output
+            assert "Updating 'helper.py'" not in result.output
+
+    def test_push_skips_root_evals_folder_files(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that files in root evals folder are skipped during push."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            # Create evals folder structure
+            os.makedirs("evals")
+            os.makedirs("evals/eval-sets")
+            os.makedirs("evals/evaluators")
+
+            # Create files in root evals folder (should be skipped)
+            with open("evals/root_file1.json", "w") as f:
+                f.write('{"should": "be skipped"}')
+            with open("evals/root_file2.py", "w") as f:
+                f.write("print('should be skipped')")
+
+            # Create files in eval-sets (should be included)
+            with open("evals/eval-sets/test_eval.json", "w") as f:
+                f.write('{"should": "be included"}')
+
+            # Create files in evaluators (should be included)
+            with open("evals/evaluators/test_evaluator.py", "w") as f:
+                f.write("def evaluate(): pass")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Verify root evals files are skipped
+            assert "Skipping 'evals/root_file1.json' (evals folder)" in result.output
+            assert "Skipping 'evals/root_file2.py' (evals folder)" in result.output
+
+            # Verify eval-sets and evaluators files are uploaded
+            assert "Uploading 'test_eval.json'" in result.output
+            assert "Uploading 'test_evaluator.py'" in result.output
+
+            # Verify main.py is uploaded
+            assert "Uploading 'main.py'" in result.output
+
+    def test_push_skips_only_root_evals_files_not_subdirectories(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that only files directly in evals folder are skipped, not files in subdirectories."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create evals folder with various subdirectories
+            os.makedirs("evals/eval-sets")
+            os.makedirs("evals/evaluators")
+            os.makedirs("evals/custom-subfolder")
+
+            # Files directly in evals (should be skipped)
+            with open("evals/config.json", "w") as f:
+                f.write('{"root": "file"}')
+
+            # Files in subdirectories (should be included)
+            with open("evals/eval-sets/test.json", "w") as f:
+                f.write('{"eval": "set"}')
+            with open("evals/evaluators/eval.py", "w") as f:
+                f.write("def evaluate(): pass")
+            with open("evals/custom-subfolder/data.json", "w") as f:
+                f.write('{"custom": "data"}')
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Verify root file is skipped
+            assert "Skipping 'evals/config.json' (evals folder)" in result.output
+
+            # Verify subdirectory files are included
+            assert "Uploading 'test.json'" in result.output
+            assert "Uploading 'eval.py'" in result.output
+            assert "Uploading 'data.json'" in result.output
+
+    def test_push_logs_skipped_files_count(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that push logs the count of skipped files from root evals folder."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create evals folder with multiple files
+            os.makedirs("evals")
+
+            # Create 3 files in root evals
+            with open("evals/file1.json", "w") as f:
+                f.write("{}")
+            with open("evals/file2.py", "w") as f:
+                f.write("pass")
+            with open("evals/file3.yaml", "w") as f:
+                f.write("key: value")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Verify individual files are skipped
+            assert "Skipping 'evals/file1.json' (evals folder)" in result.output
+            assert "Skipping 'evals/file2.py' (evals folder)" in result.output
+            assert "Skipping 'evals/file3.yaml' (evals folder)" in result.output
+
+    def test_push_preserves_remote_evals_when_no_local_evals(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that remote evaluations files are not deleted when no local evals folder exists."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        # Mock the project structure with existing evaluations folder and files
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [
+                {
+                    "id": "evaluations-folder-id",
+                    "name": "evaluations",
+                    "folders": [
+                        {
+                            "id": "evaluators-folder-id",
+                            "name": "evaluators",
+                            "files": [
+                                {
+                                    "id": "evaluator-file-1",
+                                    "name": "evaluator-1.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                },
+                            ],
+                            "folders": [],
+                        },
+                        {
+                            "id": "eval-sets-folder-id",
+                            "name": "eval-sets",
+                            "files": [
+                                {
+                                    "id": "eval-set-file-1",
+                                    "name": "eval-set-1.json",
+                                    "isMain": False,
+                                    "fileType": "1",
+                                    "isEntryPoint": False,
+                                    "ignoredFromPublish": False,
+                                },
+                            ],
+                            "folders": [],
+                        },
+                    ],
+                    "files": [],
+                },
+            ],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+                {
+                    "id": "main-456",
+                    "name": "main.py",
+                    "isMain": True,
+                    "fileType": "1",
+                    "isEntryPoint": True,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        self._mock_lock_retrieval(httpx_mock, base_url, project_id, times=1)
+
+        self._mock_file_download(httpx_mock, "main-456")
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            self._create_required_files()
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            # Importantly: Do NOT create any evals folder or files locally
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Verify that no deletion messages appear for evaluations files
+            assert (
+                "Deleting evaluations/evaluators/evaluator-1.json" not in result.output
+            )
+            assert "Deleting evaluations/eval-sets/eval-set-1.json" not in result.output
+
+            # Get the StructuralMigration request to verify no deletions were sent
+            structural_migration_request = httpx_mock.get_request(
+                method="POST",
+                url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            )
+            assert structural_migration_request is not None
+
+            # Parse the multipart form data to check deleted_resources
+            # The deleted_resources should not include the evaluations files
+            content = structural_migration_request.content
+
+            # Check that the deleted resource IDs are not present in the request
+            assert b"evaluator-file-1" not in content
+            assert b"eval-set-file-1" not in content
+
+
+class TestResourceCreation:
+    """Test resource creation and import functionality during push."""
+
+    base_url = "https://cloud.uipath.com/organization"
+    project_id = "test-project-id"
+
+    @pytest.fixture(autouse=True)
+    def clear_solution_id_cache(self):
+        """Clear the studio_solution_id cache before each test."""
+        from uipath.platform.common import UiPathConfig
+
+        # Clear cache before test
+        UiPathConfig.studio_solution_id = None
+        yield
+        # Clear cache after test
+        UiPathConfig.studio_solution_id = None
+
+    def _mock_file_download(
+        self,
+        httpx_mock,
+        file_id: str,
+        *,
+        file_content: str | None = None,
+        times: int = 1,
+    ):
+        for _ in range(times):
+            httpx_mock.add_response(
+                method="GET",
+                url=f"{TestResourceCreation.base_url}/studio_/backend/api/Project/{TestResourceCreation.project_id}/FileOperations/File/{file_id}",
+                status_code=200,
+                text="Remote file content" if not file_content else file_content,
+            )
+
+    def test_push_with_resources_imports_referenced_resources(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that push without --ignore-resources flag imports referenced resources to the solution."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+        solution_id = "test-solution-id"
+        tenant_id = "test-tenant-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/Lock",
+            json={
+                "projectLockKey": "test-lock-key",
+                "solutionLockKey": "test-solution-lock-key",
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/metadata",
+            json=[
+                {"kind": "asset", "versions": [{"supportsInLineCreation": True}]},
+            ],
+        )
+
+        # Mock getting the solution ID
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}",
+            json={"solutionId": solution_id},
+        )
+
+        # Mock creating referenced resource (status: ADDED)
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/reference",
+            json={
+                "status": "Added",
+                "resource": {
+                    "folders": [
+                        {"fullyQualifiedName": "Default", "path": "folder-path-123"}
+                    ],
+                    "key": "resource-key-123",
+                    "name": "test.asset",
+                    "description": "Test asset description",
+                    "kind": "asset",
+                    "type": "stringAsset",
+                    "apiVersion": "orchestrator.uipath.com/v1",
+                },
+                "saved": True,
+            },
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create required files
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+
+            with open("bindings.json", "w") as f:
+                json.dump(
+                    {
+                        "version": "2.0",
+                        "resources": [
+                            {
+                                "resource": "asset",
+                                "key": "asset_name.folder_key",
+                                "value": {
+                                    "name": {
+                                        "defaultValue": "test.asset",
+                                        "isExpression": False,
+                                        "displayName": "Name",
+                                    },
+                                    "folderPath": {
+                                        "defaultValue": "Default",
+                                        "isExpression": False,
+                                        "displayName": "Folder Path",
+                                    },
+                                },
+                                "metadata": {
+                                    "ActivityName": "retrieve_async",
+                                    "BindingsVersion": "2.2",
+                                    "DisplayLabel": "FullName",
+                                },
+                            }
+                        ],
+                    },
+                    f,
+                )
+
+            with open("entry-points.json", "w") as f:
+                f.write("{}")
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+            os.environ["UIPATH_TENANT_ID"] = tenant_id
+
+            # Mock resource catalog list_by_type_async
+            from uipath.platform.resource_catalog import Folder, Resource
+
+            mock_resource = Resource(
+                resource_key="resource-key-123",
+                name="test.asset",
+                description="Test asset description",
+                resource_type="asset",
+                resource_sub_type="stringAsset",
+                folders=[
+                    Folder(
+                        id=1,
+                        key="folder-key-123",
+                        display_name="Default",
+                        code="DEFAULT",
+                        fully_qualified_name="Default",
+                        timestamp="2025-11-20T12:00:00Z",
+                        tenant_key="tenant-key",
+                        account_key="account-key",
+                        type="Standard",
+                        path="folder-path-123",
+                        permissions=[],
+                    )
+                ],
+                scope="Folder",
+                search_state="Indexed",
+                timestamp="2025-11-20T12:00:00Z",
+                account_key="account-key",
+                linked_folders_count=1,
+                folder_keys=["folder-key-123"],
+            )
+
+            async def mock_list_by_type_async(*args, **kwargs):
+                yield mock_resource
+
+            with patch("uipath.platform.UiPath") as MockUiPath:
+                mock_uipath_instance = MockUiPath.return_value
+                mock_resource_catalog = AsyncMock()
+                mock_resource_catalog.list_by_type_async = mock_list_by_type_async
+                mock_uipath_instance.resource_catalog = mock_resource_catalog
+                mock_uipath_instance.connections = AsyncMock()
+
+                # Run push without --ignore-resources to trigger resource import
+                result = runner.invoke(cli, ["push", "./"])
+                assert result.exit_code == 0
+
+            # Check that resource import was attempted
+            assert (
+                "Importing referenced resources to Studio Web project" in result.output
+            )
+            assert "Created reference for resource: test.asset" in result.output
+            assert "Resource import summary:" in result.output
+            assert "1 created" in result.output
+
+    def test_push_with_ignore_resources_flag_skips_resource_import(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that push with --ignore-resources flag skips resource import."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/Lock",
+            json={
+                "projectLockKey": "test-lock-key",
+                "solutionLockKey": "test-solution-lock-key",
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create required files
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+
+            with open("bindings.json", "w") as f:
+                json.dump(
+                    {
+                        "version": "2.0",
+                        "resources": [
+                            {
+                                "resource": "asset",
+                                "key": "asset_name.folder_key",
+                                "value": {
+                                    "name": {
+                                        "defaultValue": "test.asset",
+                                        "isExpression": False,
+                                        "displayName": "Name",
+                                    },
+                                    "folderPath": {
+                                        "defaultValue": "Default",
+                                        "isExpression": False,
+                                        "displayName": "Folder Path",
+                                    },
+                                },
+                                "metadata": {
+                                    "ActivityName": "retrieve_async",
+                                    "BindingsVersion": "2.2",
+                                    "DisplayLabel": "FullName",
+                                },
+                            }
+                        ],
+                    },
+                    f,
+                )
+
+            with open("entry-points.json", "w") as f:
+                f.write("{}")
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+
+            # Run push with --ignore-resources flag
+            result = runner.invoke(cli, ["push", "./", "--ignore-resources"])
+            assert result.exit_code == 0
+
+            # Check that resource import was NOT attempted
+            assert "Importing referenced resources" not in result.output
+            assert "Created reference for resource" not in result.output
+            assert "Resource import summary" not in result.output
+
+    def test_push_with_resource_not_found_creates_virtual(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """When catalog lookup misses, push creates a virtual resource placeholder."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+        solution_id = "test-solution-id"
+        tenant_id = "test-tenant-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+        self._mock_file_download(httpx_mock, "123")
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/Lock",
+            json={
+                "projectLockKey": "test-lock-key",
+                "solutionLockKey": "test-solution-lock-key",
+            },
+        )
+
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        # Resource Builder metadata — declares which kinds support inline creation.
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/metadata",
+            json=[
+                {"kind": "asset", "versions": [{"supportsInLineCreation": True}]},
+            ],
+        )
+
+        # Solution ID lookup for the virtual-resource fallback
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}",
+            json={"solutionId": solution_id},
+        )
+
+        # Existing resources in the solution (empty → no conflict with our new virtual)
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/solutions/{solution_id}/entities",
+            json={"resources": []},
+        )
+
+        # Virtual resource POST
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/virtual",
+            json={"key": "virtual-resource-key-123"},
+        )
+
+        # Configuration PATCH after virtual creation
+        httpx_mock.add_response(
+            method="PATCH",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/virtual-resource-key-123/configuration",
+            json={},
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create required files
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+
+            with open("bindings.json", "w") as f:
+                json.dump(
+                    {
+                        "version": "2.0",
+                        "resources": [
+                            {
+                                "resource": "asset",
+                                "key": "missing.asset.Default",
+                                "value": {
+                                    "name": {
+                                        "defaultValue": "missing.asset",
+                                        "isExpression": False,
+                                        "displayName": "Name",
+                                    },
+                                    "folderPath": {
+                                        "defaultValue": "Default",
+                                        "isExpression": False,
+                                        "displayName": "Folder Path",
+                                    },
+                                },
+                                "metadata": {
+                                    "ActivityName": "retrieve_async",
+                                    "BindingsVersion": "2.2",
+                                    "DisplayLabel": "FullName",
+                                    "SubType": "stringAsset",
+                                },
+                            }
+                        ],
+                    },
+                    f,
+                )
+
+            with open("entry-points.json", "w") as f:
+                f.write("{}")
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+            os.environ["UIPATH_TENANT_ID"] = tenant_id
+
+            # Mock resource catalog list_by_type_async to return no resources
+            async def mock_list_by_type_async_empty(*args, **kwargs):
+                # Return empty generator (no resources found)
+                return
+                yield  # This makes it a generator but never yields anything
+
+            with patch("uipath.platform.UiPath") as MockUiPath:
+                mock_uipath_instance = MockUiPath.return_value
+                mock_resource_catalog = AsyncMock()
+                mock_resource_catalog.list_by_type_async = mock_list_by_type_async_empty
+                mock_uipath_instance.resource_catalog = mock_resource_catalog
+                mock_uipath_instance.connections = AsyncMock()
+
+                # Run push without --ignore-resources
+                result = runner.invoke(cli, ["push", "./"])
+                assert result.exit_code == 0
+
+            # Check that the virtual-resource fallback ran and succeeded
+            assert (
+                "Importing referenced resources to Studio Web project" in result.output
+            )
+            assert "missing.asset" in result.output
+            assert "created successfully" in result.output
+            assert "Resource import summary:" in result.output
+            assert "1 virtual-created" in result.output
+
+    def test_push_with_resource_already_exists_shows_unchanged(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        mock_env_vars: dict[str, str],
+        httpx_mock: HTTPXMock,
+    ) -> None:
+        """Test that push shows unchanged message when referenced resource already exists."""
+        base_url = "https://cloud.uipath.com/organization"
+        project_id = "test-project-id"
+        solution_id = "test-solution-id"
+        tenant_id = "test-tenant-id"
+
+        mock_structure = {
+            "id": "root",
+            "name": "root",
+            "folders": [],
+            "files": [
+                {
+                    "id": "123",
+                    "name": "pyproject.toml",
+                    "isMain": False,
+                    "fileType": "1",
+                    "isEntryPoint": False,
+                    "ignoredFromPublish": False,
+                },
+            ],
+            "folderType": "0",
+        }
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/Lock",
+            json={
+                "projectLockKey": "test-lock-key",
+                "solutionLockKey": "test-solution-lock-key",
+            },
+        )
+
+        self._mock_file_download(httpx_mock, "123")
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/StructuralMigration",
+            status_code=200,
+            json={"success": True},
+        )
+
+        httpx_mock.add_response(
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure",
+            json=mock_structure,
+        )
+
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/metadata",
+            json=[
+                {"kind": "asset", "versions": [{"supportsInLineCreation": True}]},
+            ],
+        )
+
+        # Mock getting the solution ID
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base_url}/studio_/backend/api/Project/{project_id}",
+            json={"solutionId": solution_id},
+        )
+
+        # Mock creating referenced resource (status: UNCHANGED)
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{base_url}/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/reference",
+            json={
+                "status": "Unchanged",
+                "resource": {
+                    "folders": [
+                        {"fullyQualifiedName": "Default", "path": "folder-path-123"}
+                    ],
+                    "key": "resource-key-123",
+                    "name": "existing.asset",
+                    "description": "Existing asset",
+                    "kind": "asset",
+                    "type": "stringAsset",
+                    "apiVersion": "orchestrator.uipath.com/v1",
+                },
+                "saved": False,
+            },
+        )
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create required files
+            with open("uipath.json", "w") as f:
+                json.dump(create_uipath_json(), f)
+
+            with open("bindings.json", "w") as f:
+                json.dump(
+                    {
+                        "version": "2.0",
+                        "resources": [
+                            {
+                                "resource": "asset",
+                                "key": "existing.asset.Default",
+                                "value": {
+                                    "name": {
+                                        "defaultValue": "existing.asset",
+                                        "isExpression": False,
+                                        "displayName": "Name",
+                                    },
+                                    "folderPath": {
+                                        "defaultValue": "Default",
+                                        "isExpression": False,
+                                        "displayName": "Folder Path",
+                                    },
+                                },
+                                "metadata": {
+                                    "ActivityName": "retrieve_async",
+                                    "BindingsVersion": "2.2",
+                                    "DisplayLabel": "FullName",
+                                },
+                            }
+                        ],
+                    },
+                    f,
+                )
+
+            with open("entry-points.json", "w") as f:
+                f.write("{}")
+
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            with open("main.py", "w") as f:
+                f.write("print('Hello World')")
+
+            configure_env_vars(mock_env_vars)
+            os.environ["UIPATH_PROJECT_ID"] = project_id
+            os.environ["UIPATH_TENANT_ID"] = tenant_id
+
+            # Mock resource catalog list_by_type_async
+            from uipath.platform.resource_catalog import Folder, Resource
+
+            mock_resource = Resource(
+                resource_key="resource-key-123",
+                name="existing.asset",
+                description="Existing asset",
+                resource_type="asset",
+                resource_sub_type="stringAsset",
+                folders=[
+                    Folder(
+                        id=1,
+                        key="folder-key-123",
+                        display_name="Default",
+                        code="DEFAULT",
+                        fully_qualified_name="Default",
+                        timestamp="2025-11-20T12:00:00Z",
+                        tenant_key="tenant-key",
+                        account_key="account-key",
+                        type="Standard",
+                        path="folder-path-123",
+                        permissions=[],
+                    )
+                ],
+                scope="Folder",
+                search_state="Indexed",
+                timestamp="2025-11-20T12:00:00Z",
+                account_key="account-key",
+                linked_folders_count=1,
+                folder_keys=["folder-key-123"],
+            )
+
+            async def mock_list_by_type_async(*args, **kwargs):
+                yield mock_resource
+
+            with patch("uipath.platform.UiPath") as MockUiPath:
+                mock_uipath_instance = MockUiPath.return_value
+                mock_resource_catalog = AsyncMock()
+                mock_resource_catalog.list_by_type_async = mock_list_by_type_async
+                mock_uipath_instance.resource_catalog = mock_resource_catalog
+                mock_uipath_instance.connections = AsyncMock()
+
+                # Run push without --ignore-resources
+                result = runner.invoke(cli, ["push", "./"])
+                assert result.exit_code == 0
+
+            # Check that unchanged message was shown
+            assert (
+                "Importing referenced resources to Studio Web project" in result.output
+            )
+            assert (
+                "Resource reference already exists (unchanged): existing.asset"
+                in result.output
+            )
+            assert "Resource import summary:" in result.output
+            assert "1 unchanged" in result.output
+
+
+class TestMayOverrideFilesForPush:
+    """Test may_override_files function for push scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_no_remote_metadata_returns_true(self):
+        """Test that when remote metadata doesn't exist, returns True without prompting."""
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = None
+
+        result = await may_override_files(mock_studio_client, "remote")
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_no_local_metadata_prompts_user_confirms(self, tmp_path):
+        """Test that when local metadata doesn't exist, prompts user and returns True on confirm."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = (
+                tmp_path / ".uipath" / "metadata.json"
+            )
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = True
+
+                result = await may_override_files(mock_studio_client, "remote")
+                assert result is True
+                mock_console.warning.assert_called_once()
+                mock_console.confirm.assert_called_once()
+                # Verify the confirm message mentions "remote"
+                confirm_call_args = mock_console.confirm.call_args[0][0]
+                assert "remote" in confirm_call_args
+
+    @pytest.mark.asyncio
+    async def test_no_local_metadata_prompts_user_denies(self, tmp_path):
+        """Test that when local metadata doesn't exist, prompts user and returns False on deny."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = (
+                tmp_path / ".uipath" / "metadata.json"
+            )
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = False
+
+                result = await may_override_files(mock_studio_client, "remote")
+                assert result is False
+
+    @pytest.mark.asyncio
+    async def test_local_version_greater_than_remote_returns_true(self, tmp_path):
+        """Test that when local version >= remote version, returns True without prompting."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with higher version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-19T10:00:00.000000+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "2.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            result = await may_override_files(mock_studio_client, "remote")
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_local_version_less_than_remote_prompts_user(self, tmp_path):
+        """Test that when local version < remote version, prompts user."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="2.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with lower version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-17T10:00:00.000000+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "1.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = True
+
+                result = await may_override_files(mock_studio_client, "remote")
+                assert result is True
+                mock_console.warning.assert_called_once()
+                mock_console.confirm.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_local_version_equal_to_remote_returns_true(self, tmp_path):
+        """Test that when local version == remote version, returns True without prompting."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="1.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        # Create local metadata file with same version
+        metadata_dir = tmp_path / ".uipath"
+        metadata_dir.mkdir(parents=True)
+        metadata_file = metadata_dir / "metadata.json"
+        local_metadata = {
+            "schemaVersion": "1.0",
+            "lastPushDate": "2025-11-18T17:18:06.809284+00:00",
+            "lastPushAuthor": "local-user",
+            "codeVersion": "1.0.0",
+        }
+        metadata_file.write_text(json.dumps(local_metadata))
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = metadata_file
+
+            result = await may_override_files(mock_studio_client, "remote")
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_date_formatting_in_warning(self, tmp_path):
+        """Test that the push date is formatted nicely in the warning message."""
+        remote_metadata = StudioProjectMetadata(
+            schema_version="1.0",
+            last_push_date="2025-11-18T17:18:06.809284+00:00",
+            last_push_author="test-user",
+            code_version="2.0.0",
+        )
+
+        mock_studio_client = AsyncMock()
+        mock_studio_client.get_project_metadata_async.return_value = remote_metadata
+
+        with patch("uipath._cli._utils._common.UiPathConfig") as mock_config:
+            mock_config.studio_metadata_file_path = (
+                tmp_path / ".uipath" / "metadata.json"
+            )
+
+            with patch(
+                "uipath._cli._utils._common.ConsoleLogger"
+            ) as mock_console_class:
+                mock_console = mock_console_class.return_value
+                mock_console.confirm.return_value = True
+
+                await may_override_files(mock_studio_client, "remote")
+
+                # Check that info was called with formatted date
+                info_calls = [str(call) for call in mock_console.info.call_args_list]
+                # Should contain formatted date like "Nov 18, 2025 at 05:18 PM UTC"
+                date_call = [c for c in info_calls if "Last push date" in c]
+                assert len(date_call) > 0
diff --git a/packages/uipath/tests/cli/test_run.py b/packages/uipath/tests/cli/test_run.py
new file mode 100644
index 000000000..aa182c7c5
--- /dev/null
+++ b/packages/uipath/tests/cli/test_run.py
@@ -0,0 +1,561 @@
+# type: ignore
+import json
+import os
+from contextlib import asynccontextmanager
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.middlewares import MiddlewareResult
+
+
+def _middleware_continue():
+    return MiddlewareResult(
+        should_continue=True,
+        error_message=None,
+        should_include_stacktrace=False,
+    )
+
+
+async def _empty_async_gen(*args, **kwargs):
+    """An async generator that yields nothing (simulates empty runtime.stream)."""
+    if False:  # pragma: no cover
+        yield
+
+
+def _make_mock_factory(entrypoints: list[str]):
+    """Create a mock runtime factory with given entrypoints."""
+    mock_factory = Mock()
+    mock_factory.discover_entrypoints.return_value = entrypoints
+    mock_factory.get_settings = AsyncMock(return_value=None)
+    mock_factory.dispose = AsyncMock()
+
+    mock_runtime = Mock()
+    mock_runtime.execute = AsyncMock(return_value=Mock(status="SUCCESSFUL"))
+    mock_runtime.stream = Mock(side_effect=_empty_async_gen)
+    mock_runtime.dispose = AsyncMock()
+    mock_factory.new_runtime = AsyncMock(return_value=mock_runtime)
+
+    return mock_factory
+
+
+@asynccontextmanager
+async def _mock_resource_overwrites_context(*args, **kwargs):
+    yield
+
+
+@pytest.fixture
+def entrypoint():
+    return "main"
+
+
+@pytest.fixture
+def simple_script() -> str:
+    if os.path.isfile("mocks/simple_script.py"):
+        with open("mocks/simple_script.py", "r") as file:
+            data = file.read()
+    else:
+        with open("tests/cli/mocks/simple_script.py", "r") as file:
+            data = file.read()
+    return data
+
+
+@pytest.fixture
+def mock_env_vars():
+    return {
+        "UIPATH_CONFIG_PATH": "test_config.json",
+        "UIPATH_JOB_KEY": "test-job-id",
+        "UIPATH_TRACE_ID": "test-trace-id",
+        "UIPATH_TRACING_ENABLED": "true",
+        "UIPATH_PARENT_SPAN_ID": "test-parent-span",
+        "UIPATH_ROOT_SPAN_ID": "test-root-span",
+        "UIPATH_ORGANIZATION_ID": "test-org-id",
+        "UIPATH_TENANT_ID": "test-tenant-id",
+        "UIPATH_PROCESS_UUID": "test-process-id",
+        "UIPATH_FOLDER_KEY": "test-folder-key",
+        "LOG_LEVEL": "DEBUG",
+    }
+
+
+def create_uipath_json(script_path: str, entrypoint_name: str = "main"):
+    """Helper to create uipath.json with functions."""
+    return {"functions": {entrypoint_name: f"{script_path}:main"}}
+
+
+class TestRun:
+    class TestFileInput:
+        def test_run_input_file_not_found(
+            self,
+            runner: CliRunner,
+            temp_dir: str,
+            entrypoint: str,
+        ):
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                script_file = "entrypoint.py"
+                file_path = os.path.join(temp_dir, script_file)
+                with open(file_path, "w") as f:
+                    f.write("def main(input): return input")
+
+                # Create uipath.json
+                with open("uipath.json", "w") as f:
+                    import json
+
+                    json.dump(create_uipath_json(script_file), f)
+
+                result = runner.invoke(
+                    cli, ["run", entrypoint, "--file", "not-here.json"]
+                )
+                assert result.exit_code != 0
+                assert "Error: Invalid value for '-f' / '--file'" in result.output
+
+        def test_run_invalid_input_file(
+            self,
+            runner: CliRunner,
+            temp_dir: str,
+            entrypoint: str,
+        ):
+            file_name = "not-json.txt"
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                script_file = "entrypoint.py"
+                script_file_path = os.path.join(temp_dir, script_file)
+                with open(script_file_path, "w") as f:
+                    f.write("def main(input): return input")
+
+                file_path = os.path.join(temp_dir, file_name)
+                with open(file_path, "w") as f:
+                    f.write("file content")
+
+                # Create uipath.json
+                with open("uipath.json", "w") as f:
+                    import json
+
+                    json.dump(create_uipath_json(script_file_path), f)
+
+                result = runner.invoke(cli, ["run", "main", "--file", file_path])
+                assert result.exit_code == 1
+                assert "Invalid Input File Extension" in result.output
+
+        def test_run_input_file_success(
+            self,
+            runner: CliRunner,
+            temp_dir: str,
+            entrypoint: str,
+        ):
+            file_name = "input.json"
+            json_content = """
+            {
+                "input_key": "input_value"
+            }"""
+
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                script_file = "entrypoint.py"
+                script_file_path = os.path.join(temp_dir, script_file)
+                with open(script_file_path, "w") as f:
+                    f.write("def main(input): return input")
+
+                file_path = os.path.join(temp_dir, file_name)
+                with open(file_path, "w") as f:
+                    f.write(json_content)
+
+                # Create uipath.json
+                with open("uipath.json", "w") as f:
+                    import json
+
+                    json.dump(create_uipath_json(script_file), f)
+
+                with patch("uipath._cli.cli_run.Middlewares.next") as mock_middleware:
+                    mock_middleware.return_value = MiddlewareResult(
+                        should_continue=False,
+                        info_message="Execution succeeded",
+                        error_message=None,
+                        should_include_stacktrace=False,
+                    )
+                    result = runner.invoke(
+                        cli, ["run", entrypoint, "--file", file_path]
+                    )
+                    assert result.exit_code == 0
+                    assert "Successful execution." in result.output
+
+    class TestMiddleware:
+        def test_autodiscover_entrypoint(self, runner: CliRunner, temp_dir: str):
+            """When exactly one entrypoint exists, it is auto-resolved."""
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                mock_factory = _make_mock_factory(["my_agent"])
+
+                with (
+                    patch(
+                        "uipath._cli.cli_run.Middlewares.next",
+                        return_value=_middleware_continue(),
+                    ),
+                    patch(
+                        "uipath._cli.cli_run.UiPathRuntimeFactoryRegistry.get",
+                        return_value=mock_factory,
+                    ),
+                    patch(
+                        "uipath._cli.cli_run.ResourceOverwritesContext",
+                        side_effect=_mock_resource_overwrites_context,
+                    ),
+                ):
+                    result = runner.invoke(cli, ["run"])
+
+                assert result.exit_code == 0, (
+                    f"output: {result.output!r}, exception: {result.exception}"
+                )
+                assert "Successful execution." in result.output
+                mock_factory.new_runtime.assert_awaited_once()
+                assert mock_factory.new_runtime.call_args[0][0] == "my_agent"
+
+        def test_no_entrypoint_multiple_available(
+            self, runner: CliRunner, temp_dir: str
+        ):
+            """When multiple entrypoints exist and none specified, show usage help."""
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                mock_factory = _make_mock_factory(["agent_a", "agent_b"])
+
+                with (
+                    patch(
+                        "uipath._cli.cli_run.Middlewares.next",
+                        return_value=_middleware_continue(),
+                    ),
+                    patch(
+                        "uipath._cli.cli_run.UiPathRuntimeFactoryRegistry.get",
+                        return_value=mock_factory,
+                    ),
+                ):
+                    result = runner.invoke(cli, ["run"])
+
+                assert result.exit_code == 0
+                assert "Available entrypoints:" in result.output
+                assert "agent_a" in result.output
+                assert "agent_b" in result.output
+                assert "Usage: uipath run" in result.output
+                mock_factory.new_runtime.assert_not_awaited()
+
+        def test_no_entrypoint_none_available(self, runner: CliRunner, temp_dir: str):
+            """When no entrypoints exist and none specified, show usage help."""
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                mock_factory = _make_mock_factory([])
+
+                with (
+                    patch(
+                        "uipath._cli.cli_run.Middlewares.next",
+                        return_value=_middleware_continue(),
+                    ),
+                    patch(
+                        "uipath._cli.cli_run.UiPathRuntimeFactoryRegistry.get",
+                        return_value=mock_factory,
+                    ),
+                ):
+                    result = runner.invoke(cli, ["run"])
+
+                assert result.exit_code == 0
+                assert "No entrypoints found" in result.output
+                assert "Usage: uipath run" in result.output
+                mock_factory.new_runtime.assert_not_awaited()
+
+        def test_script_not_found(
+            self, runner: CliRunner, temp_dir: str, entrypoint: str
+        ):
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                # Create uipath.json but no actual script file
+                with open("uipath.json", "w") as f:
+                    import json
+
+                    json.dump(create_uipath_json("nonexistent.py"), f)
+
+                result = runner.invoke(cli, ["run", entrypoint])
+                assert result.exit_code == 1
+                assert "not found" in result.output.lower()
+
+        def test_successful_execution(
+            self,
+            runner: CliRunner,
+            temp_dir: str,
+            entrypoint: str,
+            mock_env_vars: dict,
+            simple_script: str,
+        ):
+            input_file_name = "input.json"
+            output_file_name = "output.json"
+            input_json_content = """
+            {
+                "message": "Hello world",
+                "repeat": 2
+            }"""
+            with runner.isolated_filesystem(temp_dir=temp_dir):
+                # create input file
+                input_file_path = os.path.join(temp_dir, input_file_name)
+                output_file_path = os.path.join(temp_dir, output_file_name)
+                with open(input_file_path, "w") as f:
+                    f.write(input_json_content)
+
+                # Create test script
+                script_file = "entrypoint.py"
+                script_file_path = os.path.join(temp_dir, script_file)
+                with open(script_file_path, "w") as f:
+                    f.write(simple_script)
+
+                # create uipath.json
+                with open("uipath.json", "w") as f:
+                    import json
+
+                    json.dump(create_uipath_json(script_file_path), f)
+
+                result = runner.invoke(
+                    cli,
+                    [
+                        "run",
+                        "main",
+                        "--input-file",
+                        input_file_path,
+                        "--output-file",
+                        output_file_path,
+                    ],
+                )
+                assert result.exit_code == 0
+                assert "Successful execution." in result.output
+                assert result.output.count("Hello world") >= 2
+                assert os.path.exists(output_file_path)
+                with open(output_file_path, "r") as f:
+                    output = f.read()
+                    assert output.count("Hello world") >= 2
+
+    def test_no_main_function_found(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        entrypoint: str,
+        mock_env_vars: dict,
+    ):
+        input_file_name = "input.json"
+        input_json_content = """
+                {
+                    "message": "Hello world",
+                    "repeat": 2
+                }"""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # create input file
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            # Create test script without main function
+            script_file = "entrypoint.py"
+            script_file_path = os.path.join(temp_dir, script_file)
+            with open(script_file_path, "w") as f:
+                f.write("print(0)")
+
+            # create uipath.json
+            with open("uipath.json", "w") as f:
+                import json
+
+                json.dump(create_uipath_json(script_file), f)
+
+            result = runner.invoke(cli, ["run", entrypoint, "{}"])
+            assert result.exit_code == 1
+            assert (
+                "not found" in result.output.lower()
+                or "missing" in result.output.lower()
+            )
+
+    def test_pydantic_model_execution(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        entrypoint: str,
+        mock_env_vars: dict,
+    ):
+        """Test successful execution with Pydantic models."""
+        pydantic_script = """
+from pydantic import BaseModel, Field
+
+
+class PersonIn(BaseModel):
+    name: str
+    age: int
+    email: str | None = None
+
+
+class PersonOut(BaseModel):
+    name: str
+    age: int
+    email: str | None = None
+    is_adult: bool
+    greeting: str
+
+
+def main(input_data: PersonIn) -> PersonOut:
+    return PersonOut(
+        name=input_data.name,
+        age=input_data.age,
+        email=input_data.email,
+        is_adult=input_data.age >= 18,
+        greeting=f"Hello, {input_data.name}!"
+    )
+"""
+
+        input_file_name = "input.json"
+        output_file_name = "output.json"
+        input_json_content = """
+        {
+            "name": "John Doe",
+            "age": 25,
+            "email": "john@example.com"
+        }"""
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # create input file
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            output_file_path = os.path.join(temp_dir, output_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            # Create test script
+            script_file = "entrypoint.py"
+            script_file_path = os.path.join(temp_dir, script_file)
+            with open(script_file_path, "w") as f:
+                f.write(pydantic_script)
+
+            # create uipath.json
+            with open("uipath.json", "w") as f:
+                import json
+
+                json.dump(create_uipath_json(script_file_path), f)
+
+            result = runner.invoke(
+                cli,
+                [
+                    "run",
+                    "main",
+                    "--input-file",
+                    input_file_path,
+                    "--output-file",
+                    output_file_path,
+                ],
+            )
+
+            assert result.exit_code == 0
+            assert "Successful execution." in result.output
+            assert os.path.exists(output_file_path)
+
+            with open(output_file_path, "r") as f:
+                import json
+
+                output_data = json.load(f)
+                assert output_data["name"] == "John Doe"
+                assert output_data["age"] == 25
+                assert output_data["email"] == "john@example.com"
+                assert output_data["is_adult"] is True
+                assert output_data["greeting"] == "Hello, John Doe!"
+
+
+_SIMULATION_JSON = {
+    "enabled": True,
+    "toolsToSimulate": [{"name": "check_syntax"}, {"name": "check_style"}],
+    "instructions": "Simulate.",
+}
+
+
+class TestRunSimulation:
+    """Tests for the --simulation flag on the run command."""
+
+    def _make_factory(self):
+        factory = Mock()
+        runtime = Mock()
+        runtime.stream = Mock(side_effect=_empty_async_gen)
+        runtime.dispose = AsyncMock()
+        runtime.get_schema = AsyncMock(return_value=Mock(metadata=None))
+        factory.discover_entrypoints.return_value = ["main"]
+        factory.get_settings = AsyncMock(return_value=None)
+        factory.dispose = AsyncMock()
+        factory.new_runtime = AsyncMock(return_value=runtime)
+        return factory, runtime
+
+    def test_invalid_simulation_json_exits_with_error(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": "main.py:main"}}, f)
+            with open("main.py", "w") as f:
+                f.write("async def main(input): return {}")
+
+            result = runner.invoke(
+                cli, ["run", "main", "--simulation", "{ not valid json }"]
+            )
+        assert result.exit_code == 1
+        assert "Invalid JSON" in result.output
+
+    def test_simulation_wraps_runtime_with_mock_runtime(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        factory, _ = self._make_factory()
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": "main.py:main"}}, f)
+            with open("main.py", "w") as f:
+                f.write("async def main(input): return {}")
+
+            with (
+                patch(
+                    "uipath._cli.cli_run.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_run.UiPathRuntimeFactoryRegistry.get",
+                    return_value=factory,
+                ),
+                patch(
+                    "uipath._cli.cli_run.ResourceOverwritesContext",
+                    side_effect=_mock_resource_overwrites_context,
+                ),
+                patch("uipath._cli.cli_run.UiPathMockRuntime") as mock_cls,
+            ):
+                mock_cls.return_value = Mock(
+                    stream=Mock(side_effect=_empty_async_gen),
+                    dispose=AsyncMock(),
+                    get_schema=AsyncMock(return_value=Mock(metadata=None)),
+                )
+                runner.invoke(
+                    cli,
+                    ["run", "main", "--simulation", json.dumps(_SIMULATION_JSON)],
+                )
+
+        assert mock_cls.called
+        assert mock_cls.call_args.kwargs["mocking_context"] is not None
+
+    def test_simulation_disabled_does_not_wrap_runtime(
+        self, runner: CliRunner, temp_dir: str
+    ):
+        factory, _ = self._make_factory()
+        disabled = {**_SIMULATION_JSON, "enabled": False}
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                json.dump({"functions": {"main": "main.py:main"}}, f)
+            with open("main.py", "w") as f:
+                f.write("async def main(input): return {}")
+
+            with (
+                patch(
+                    "uipath._cli.cli_run.Middlewares.next",
+                    return_value=_middleware_continue(),
+                ),
+                patch(
+                    "uipath._cli.cli_run.UiPathRuntimeFactoryRegistry.get",
+                    return_value=factory,
+                ),
+                patch(
+                    "uipath._cli.cli_run.ResourceOverwritesContext",
+                    side_effect=_mock_resource_overwrites_context,
+                ),
+                patch("uipath._cli.cli_run.UiPathMockRuntime") as mock_cls,
+            ):
+                runner.invoke(
+                    cli, ["run", "main", "--simulation", json.dumps(disabled)]
+                )
+
+        assert not mock_cls.called
diff --git a/packages/uipath/tests/cli/test_server.py b/packages/uipath/tests/cli/test_server.py
new file mode 100644
index 000000000..185979924
--- /dev/null
+++ b/packages/uipath/tests/cli/test_server.py
@@ -0,0 +1,371 @@
+import asyncio
+import json
+import os
+import threading
+import time
+from typing import Any
+
+import aiohttp
+import pytest
+
+from uipath._cli.cli_server import start_tcp_server
+
+
+def create_uipath_json(script_path: str, entrypoint_name: str = "main"):
+    """Helper to create uipath.json with functions."""
+    return {"functions": {entrypoint_name: f"{script_path}:main"}}
+
+
+async def start_job(
+    port: int, job_key: str, command: str, args: list[str]
+) -> dict[str, Any]:
+    """Start a job on the server."""
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"http://127.0.0.1:{port}/jobs/{job_key}/start",
+            json={"command": command, "args": args},
+        ) as response:
+            return await response.json()
+
+
+async def start_job_with_env(
+    port: int,
+    job_key: str,
+    command: str,
+    args: list[str],
+    env_vars: dict[str, str],
+) -> dict[str, Any]:
+    """Start a job on the server with environment variables."""
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"http://127.0.0.1:{port}/jobs/{job_key}/start",
+            json={
+                "command": command,
+                "args": args,
+                "environmentVariables": env_vars,
+            },
+        ) as response:
+            return await response.json()
+
+
+class TestServer:
+    @pytest.fixture
+    def server_port(self):
+        """Use a random available port for testing."""
+        import socket
+
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("127.0.0.1", 0))
+            return s.getsockname()[1]
+
+    @pytest.fixture
+    def server(self, server_port):
+        """Start the server in a background thread."""
+
+        def run_server():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                loop.run_until_complete(start_tcp_server("127.0.0.1", server_port))
+            except asyncio.CancelledError:
+                pass
+            finally:
+                loop.close()
+
+        thread = threading.Thread(target=run_server, daemon=True)
+        thread.start()
+        time.sleep(0.5)
+
+        yield server_port
+
+    @pytest.fixture
+    def simple_script(self) -> str:
+        return """
+from dataclasses import dataclass
+
+@dataclass
+class Input:
+    message: str
+    repeat: int = 1
+
+def main(input: Input) -> str:
+    return (input.message + " ") * input.repeat
+"""
+
+    def test_start_job_success(self, server, temp_dir, simple_script):
+        """Test starting a job through the server."""
+        port = server
+        job_key = "test-job-123"
+
+        with pytest.MonkeyPatch().context() as mp:
+            mp.chdir(temp_dir)
+
+            script_file = "entrypoint.py"
+            script_path = os.path.join(temp_dir, script_file)
+            with open(script_path, "w") as f:
+                f.write(simple_script)
+
+            with open(os.path.join(temp_dir, "uipath.json"), "w") as f:
+                json.dump(create_uipath_json(script_file), f)
+
+            input_file = os.path.join(temp_dir, "input.json")
+            with open(input_file, "w") as f:
+                json.dump({"message": "Hello", "repeat": 3}, f)
+
+            output_file = os.path.join(temp_dir, "output.json")
+
+            response = asyncio.run(
+                start_job(
+                    port,
+                    job_key,
+                    "run",
+                    ["main", "--input-file", input_file, "--output-file", output_file],
+                )
+            )
+
+            assert response["success"] is True
+            assert response["job_key"] == job_key
+            assert os.path.exists(output_file)
+
+            with open(output_file, "r") as f:
+                output = f.read()
+                assert "Hello" in output
+
+    def test_start_job_unknown_command(self, server):
+        """Test starting a job with unknown command."""
+        port = server
+
+        response = asyncio.run(start_job(port, "job-123", "unknown_command", []))
+
+        assert response["success"] is False
+        assert "Unknown command" in response["error"]
+
+    def test_start_job_missing_command(self, server):
+        """Test starting a job without command field."""
+        port = server
+
+        async def send_invalid():
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"http://127.0.0.1:{port}/jobs/job-123/start",
+                    json={"args": ["some", "args"]},
+                ) as response:
+                    return await response.json()
+
+        response = asyncio.run(send_invalid())
+
+        assert response["success"] is False
+        assert "command" in response["error"]
+
+    def test_start_job_invalid_json(self, server):
+        """Test starting a job with invalid JSON."""
+        port = server
+
+        async def send_invalid():
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"http://127.0.0.1:{port}/jobs/job-123/start",
+                    data="not valid json",
+                    headers={"Content-Type": "application/json"},
+                ) as response:
+                    return await response.json()
+
+        response = asyncio.run(send_invalid())
+
+        assert response["success"] is False
+        assert "Invalid JSON" in response["error"]
+
+    def test_rejects_invalid_host_header(self, server):
+        """Test that requests with non-localhost Host header are rejected (DNS rebinding protection)."""
+        port = server
+
+        async def send_with_host(host: str):
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"http://127.0.0.1:{port}/health",
+                    headers={"Host": host},
+                ) as response:
+                    return response.status, await response.json()
+
+        # Attacker-controlled domain should be rejected
+        status, body = asyncio.run(send_with_host("attacker.example.com"))
+        assert status == 403
+        assert "Forbidden" in body["error"]
+
+        # Attacker domain with port should also be rejected
+        status, body = asyncio.run(send_with_host(f"evil.com:{port}"))
+        assert status == 403
+        assert "Forbidden" in body["error"]
+
+    def test_allows_localhost_host_header(self, server):
+        """Test that requests with valid localhost Host headers are accepted."""
+        port = server
+
+        async def send_with_host(host: str):
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"http://127.0.0.1:{port}/health",
+                    headers={"Host": host},
+                ) as response:
+                    return response.status, await response.text()
+
+        # localhost variants should all be accepted
+        for host in [
+            "127.0.0.1",
+            f"127.0.0.1:{port}",
+            "localhost",
+            f"localhost:{port}",
+            "[::1]",
+            f"[::1]:{port}",
+            "LOCALHOST",
+            f"LOCALHOST:{port}",
+            "LocalHost",
+            "127.0.0.1.",
+            f"localhost.:{port}",
+        ]:
+            status, body = asyncio.run(send_with_host(host))
+            assert status == 200, f"Host '{host}' should be allowed but got {status}"
+            assert body == "OK"
+
+
+class TestServerEnvIsolation:
+    """Test that environment variables are isolated between sequential server requests."""
+
+    @pytest.fixture
+    def server_port(self):
+        import socket
+
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("127.0.0.1", 0))
+            return s.getsockname()[1]
+
+    @pytest.fixture
+    def env_snapshots(self):
+        return []
+
+    @pytest.fixture
+    def server_with_spy(self, server_port, env_snapshots):
+        """Start server with a spy command that captures os.environ."""
+        import click
+
+        from uipath._cli import cli_server
+
+        @click.command()
+        def spy_cmd():
+            env_snapshots.append(dict(os.environ))
+
+        original_commands = cli_server.COMMANDS.copy()
+        cli_server.COMMANDS["spy"] = spy_cmd
+
+        def run_server():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                loop.run_until_complete(start_tcp_server("127.0.0.1", server_port))
+            except asyncio.CancelledError:
+                pass
+            finally:
+                loop.close()
+
+        thread = threading.Thread(target=run_server, daemon=True)
+        thread.start()
+        time.sleep(0.5)
+
+        yield server_port
+
+        cli_server.COMMANDS.clear()
+        cli_server.COMMANDS.update(original_commands)
+
+    def test_env_vars_do_not_leak_between_requests(
+        self, server_with_spy, env_snapshots
+    ):
+        """Env vars from request 1 must not be visible in request 2."""
+        port = server_with_spy
+
+        # Request 1: set TEST_VAR_A
+        asyncio.run(
+            start_job_with_env(
+                port,
+                "job-1",
+                "spy",
+                [],
+                {"TEST_VAR_A": "value_a"},
+            )
+        )
+
+        # Request 2: set TEST_VAR_B (but NOT TEST_VAR_A)
+        asyncio.run(
+            start_job_with_env(
+                port,
+                "job-2",
+                "spy",
+                [],
+                {"TEST_VAR_B": "value_b"},
+            )
+        )
+
+        assert len(env_snapshots) == 2
+
+        env_run1 = env_snapshots[0]
+        env_run2 = env_snapshots[1]
+
+        # Run 1 should have TEST_VAR_A
+        assert env_run1["TEST_VAR_A"] == "value_a"
+        assert "TEST_VAR_B" not in env_run1
+
+        # Run 2 should have TEST_VAR_B but NOT TEST_VAR_A
+        assert env_run2["TEST_VAR_B"] == "value_b"
+        assert "TEST_VAR_A" not in env_run2
+
+    def test_server_baseline_env_preserved(self, server_with_spy, env_snapshots):
+        """Server baseline env vars (like PATH) should be available during command execution."""
+        from uipath._cli import cli_server
+
+        port = server_with_spy
+
+        asyncio.run(
+            start_job_with_env(
+                port,
+                "job-1",
+                "spy",
+                [],
+                {"CUSTOM_VAR": "custom_value"},
+            )
+        )
+
+        assert len(env_snapshots) == 1
+        env_run = env_snapshots[0]
+
+        # Baseline is captured at server start, not import time
+        baseline = cli_server._state.baseline_env
+        assert baseline is not None
+
+        # Baseline env vars should be present
+        assert env_run.get("PATH") == baseline.get("PATH")
+
+        # Request env var should override/add
+        assert env_run["CUSTOM_VAR"] == "custom_value"
+
+    def test_env_restored_after_request(self, server_with_spy):
+        """os.environ should be restored to baseline after each request."""
+        from uipath._cli import cli_server
+
+        port = server_with_spy
+
+        asyncio.run(
+            start_job_with_env(
+                port,
+                "job-1",
+                "spy",
+                [],
+                {"SHOULD_NOT_PERSIST": "temporary"},
+            )
+        )
+
+        baseline = cli_server._state.baseline_env
+        assert baseline is not None
+
+        # After the request, os.environ should match baseline
+        assert "SHOULD_NOT_PERSIST" not in os.environ
+        for key in baseline:
+            assert os.environ.get(key) == baseline[key]
diff --git a/tests/cli/test_utils.py b/packages/uipath/tests/cli/test_utils.py
similarity index 62%
rename from tests/cli/test_utils.py
rename to packages/uipath/tests/cli/test_utils.py
index 77cb4e787..19aeeb7ab 100644
--- a/tests/cli/test_utils.py
+++ b/packages/uipath/tests/cli/test_utils.py
@@ -1,28 +1,33 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
-from uipath._cli._utils._common import serialize_object
+from uipath.core.serialization import serialize_object
+from uipath.runtime.errors import (
+    UiPathErrorCategory,
+    UiPathErrorCode,
+    UiPathRuntimeError,
+)
 
 
-class TestPydanticModel(BaseModel):
-    """Test Pydantic model for serialization testing."""
+class SamplePydanticModel(BaseModel):
+    """Sample Pydantic model for serialization testing."""
 
     name: str
     age: int
-    tags: List[str]
-    metadata: Optional[Dict[str, Any]] = None
+    tags: list[str]
+    metadata: dict[str, Any] | None = None
 
 
 @dataclass
-class TestDataClass:
-    """Test dataclass for serialization testing."""
+class SampleDataClass:
+    """Sample dataclass for serialization testing."""
 
     value: str
-    numbers: List[int]
+    numbers: list[int]
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {"value": self.value, "numbers": self.numbers}
 
 
@@ -61,7 +66,7 @@ def test_serialize_dict() -> None:
 
 def test_serialize_pydantic_model() -> None:
     """Test serialization of Pydantic models with nested structures."""
-    model = TestPydanticModel(
+    model = SamplePydanticModel(
         name="test", age=25, tags=["tag1", "tag2"], metadata={"key": "value"}
     )
     expected = {
@@ -75,7 +80,7 @@ def test_serialize_pydantic_model() -> None:
 
 def test_serialize_dataclass() -> None:
     """Test serialization of dataclass with to_dict method."""
-    data = TestDataClass(value="test", numbers=[1, 2, 3])
+    data = SampleDataClass(value="test", numbers=[1, 2, 3])
     expected = {"value": "test", "numbers": [1, 2, 3]}
     assert serialize_object(data) == expected
 
@@ -91,13 +96,14 @@ def test_serialize_iterable() -> None:
 def test_serialize_complex_nested_structure() -> None:
     """Test serialization of complex nested structure with mixed types."""
     complex_structure = {
-        "model": TestPydanticModel(
+        "model": SamplePydanticModel(
             name="test", age=25, tags=["tag1", "tag2"], metadata={"nested": True}
         ),
-        "dataclass": TestDataClass(value="test", numbers=[1, 2, 3]),
+        "dataclass": SampleDataClass(value="test", numbers=[1, 2, 3]),
+        "error": RuntimeError("something failed"),
         "list": [
             {"key": "value"},
-            TestPydanticModel(name="nested", age=30, tags=["tag3"]),
+            SamplePydanticModel(name="nested", age=30, tags=["tag3"]),
             [1, 2, 3],
         ],
     }
@@ -110,6 +116,7 @@ def test_serialize_complex_nested_structure() -> None:
             "metadata": {"nested": True},
         },
         "dataclass": {"value": "test", "numbers": [1, 2, 3]},
+        "error": "something failed",
         "list": [
             {"key": "value"},
             {"name": "nested", "age": 30, "tags": ["tag3"], "metadata": None},
@@ -117,3 +124,29 @@ def test_serialize_complex_nested_structure() -> None:
         ],
     }
     assert serialize_object(complex_structure) == expected
+
+
+def test_serialize_uipath_runtime_error() -> None:
+    """Test serialization of UiPathBaseRuntimeError-like objects with as_dict property."""
+
+    error = UiPathRuntimeError(
+        code=UiPathErrorCode.INPUT_INVALID_JSON,
+        title="Test error title",
+        detail="Something went wrong",
+        category=UiPathErrorCategory.USER,
+        prefix="Test",
+        include_traceback=False,
+    )
+    result = serialize_object(error)
+
+    assert result["code"] == "Test.INPUT_INVALID_JSON"
+    assert result["title"] == "Test error title"
+    assert result["detail"] == "Something went wrong"
+    assert result["category"] == "User"
+
+
+def test_serialize_exception() -> None:
+    """Test serialization of a plain exception returns its message."""
+    error = ValueError("something broke")
+    result = serialize_object(error)
+    assert result == "something broke"
diff --git a/packages/uipath/tests/cli/unit/test_buckets_migration.py b/packages/uipath/tests/cli/unit/test_buckets_migration.py
new file mode 100644
index 000000000..11eceaf8b
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_buckets_migration.py
@@ -0,0 +1,347 @@
+"""Unit tests for migrated buckets CLI commands.
+
+Tests cover:
+- Command structure and existence
+- Provenance tracking for auto-generated, overridden, and manual commands
+- Backward compatibility with original CLI interface
+- Command signatures and options
+"""
+
+import click
+from click.testing import CliRunner
+
+from uipath._cli._utils._service_cli_generator import GeneratorType
+from uipath._cli.services.cli_buckets import buckets
+
+__all__ = [
+    "TestBucketsMigrationStructure",
+    "TestBucketsProvenance",
+    "TestBucketsBackwardCompatibility",
+    "TestBucketsCommandSignatures",
+]
+
+
+class TestBucketsMigrationStructure:
+    """Test that buckets CLI has correct structure after migration."""
+
+    def test_buckets_group_exists(self):
+        """Test that buckets group is created."""
+        assert buckets is not None
+        assert buckets.name == "buckets"
+
+    def test_standard_crud_commands_exist(self):
+        """Test that standard CRUD commands are present."""
+        command_names = [cmd.name for cmd in buckets.commands.values()]
+
+        # Auto-generated commands
+        assert "list" in command_names
+        assert "create" in command_names
+        assert "delete" in command_names
+        assert "exists" in command_names
+
+        # Overridden command
+        assert "retrieve" in command_names
+
+    def test_files_nested_group_exists(self):
+        """Test that files nested group is present."""
+        command_names = [cmd.name for cmd in buckets.commands.values()]
+        assert "files" in command_names
+
+        files_group = buckets.commands["files"]
+        assert isinstance(files_group, click.Group)
+        files_command_names = [cmd.name for cmd in files_group.commands.values()]
+
+        # All file commands should be present
+        assert "list" in files_command_names
+        assert "search" in files_command_names
+        assert "upload" in files_command_names
+        assert "download" in files_command_names
+        assert "delete" in files_command_names
+        assert "exists" in files_command_names
+
+    def test_total_command_count(self):
+        """Test that we have expected number of commands."""
+        # 5 bucket commands + 1 files group
+        assert len(buckets.commands) == 6
+
+        # 6 file commands
+        files_group = buckets.commands["files"]
+        assert isinstance(files_group, click.Group)
+        assert len(files_group.commands) == 6
+
+
+class TestBucketsProvenance:
+    """Test provenance tracking for migrated commands."""
+
+    def test_auto_generated_list_command_provenance(self):
+        """Test that list command has correct auto-generated provenance."""
+        list_cmd = buckets.commands["list"]
+
+        assert hasattr(list_cmd, "__provenance__")
+        provenance = list_cmd.__provenance__
+
+        assert provenance["generator"] == GeneratorType.AUTO.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert provenance["command_function"] == "list_cmd"
+
+    def test_auto_generated_create_command_provenance(self):
+        """Test that create command has correct auto-generated provenance."""
+        create_cmd = buckets.commands["create"]
+
+        assert hasattr(create_cmd, "__provenance__")
+        provenance = create_cmd.__provenance__
+
+        assert provenance["generator"] == GeneratorType.AUTO.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert provenance["command_function"] == "create_cmd"
+
+    def test_auto_generated_delete_command_provenance(self):
+        """Test that delete command has correct override provenance."""
+        delete_cmd = buckets.commands["delete"]
+
+        assert hasattr(delete_cmd, "__provenance__")
+        provenance = delete_cmd.__provenance__
+
+        assert provenance["generator"] == GeneratorType.OVERRIDE.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert provenance["original_generator"] == GeneratorType.AUTO.value
+
+    def test_auto_generated_exists_command_provenance(self):
+        """Test that exists command has correct auto-generated provenance."""
+        exists_cmd = buckets.commands["exists"]
+
+        assert hasattr(exists_cmd, "__provenance__")
+        provenance = exists_cmd.__provenance__
+
+        assert provenance["generator"] == GeneratorType.AUTO.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert provenance["command_function"] == "exists_cmd"
+
+    def test_overridden_retrieve_command_provenance(self):
+        """Test that retrieve command has correct override provenance."""
+        retrieve_cmd = buckets.commands["retrieve"]
+
+        assert hasattr(retrieve_cmd, "__provenance__")
+        provenance = retrieve_cmd.__provenance__
+
+        assert provenance["generator"] == GeneratorType.OVERRIDE.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert "original_generator" in provenance
+        assert provenance["original_generator"] == GeneratorType.AUTO.value
+
+    def test_manual_files_nested_group_provenance(self):
+        """Test that files nested group has correct manual provenance."""
+        files_group = buckets.commands["files"]
+
+        assert hasattr(files_group, "__provenance__")
+        provenance = files_group.__provenance__
+
+        assert provenance["generator"] == GeneratorType.MANUAL.value
+        assert provenance["service_name"] == "buckets"
+        assert provenance["type"] == "nested_group"
+
+
+class TestBucketsBackwardCompatibility:
+    """Test backward compatibility of migrated commands."""
+
+    def test_list_command_help_accessible(self):
+        """Test that list command help is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["list", "--help"])
+
+        assert result.exit_code == 0
+        assert "List" in result.output or "list" in result.output.lower()
+
+    def test_create_command_has_description_option(self):
+        """Test that create command has --description option."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["create", "--help"])
+
+        assert result.exit_code == 0
+        assert "Create" in result.output or "create" in result.output.lower()
+        assert "--description" in result.output
+
+    def test_retrieve_command_has_name_and_key_options(self):
+        """Test that retrieve command has both --name and --key options."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["retrieve", "--help"])
+
+        assert result.exit_code == 0
+        assert "Retrieve" in result.output or "retrieve" in result.output.lower()
+        assert "--name" in result.output
+        assert "--key" in result.output
+
+    def test_delete_command_has_confirmation_options(self):
+        """Test that delete command has --confirm and --dry-run options."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["delete", "--help"])
+
+        assert result.exit_code == 0
+        assert "Delete" in result.output or "delete" in result.output.lower()
+        assert "--confirm" in result.output
+        assert "--dry-run" in result.output
+
+    def test_exists_command_help_accessible(self):
+        """Test that exists command help is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["exists", "--help"])
+
+        assert result.exit_code == 0
+        # Exists command should have help text
+        assert len(result.output) > 0
+
+    def test_files_list_command_accessible(self):
+        """Test that files list command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "list", "--help"])
+
+        assert result.exit_code == 0
+        assert "List" in result.output or "list" in result.output.lower()
+        assert "bucket" in result.output.lower()
+
+    def test_files_search_command_accessible(self):
+        """Test that files search command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "search", "--help"])
+
+        assert result.exit_code == 0
+        assert "Search" in result.output or "search" in result.output.lower()
+
+    def test_files_upload_command_accessible(self):
+        """Test that files upload command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "upload", "--help"])
+
+        assert result.exit_code == 0
+        assert "Upload" in result.output or "upload" in result.output.lower()
+
+    def test_files_download_command_accessible(self):
+        """Test that files download command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "download", "--help"])
+
+        assert result.exit_code == 0
+        assert "Download" in result.output or "download" in result.output.lower()
+
+    def test_files_delete_command_accessible(self):
+        """Test that files delete command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "delete", "--help"])
+
+        assert result.exit_code == 0
+        assert "Delete" in result.output or "delete" in result.output.lower()
+
+    def test_files_exists_command_accessible(self):
+        """Test that files exists command is accessible."""
+        runner = CliRunner()
+        result = runner.invoke(buckets, ["files", "exists", "--help"])
+
+        assert result.exit_code == 0
+        # Exists command should have help text
+        assert len(result.output) > 0
+
+
+class TestBucketsCommandSignatures:
+    """Test that command signatures match expectations."""
+
+    def test_list_command_has_standard_options(self):
+        """Test list command has standard service options."""
+        list_cmd = buckets.commands["list"]
+        option_names = [param.name for param in list_cmd.params]
+
+        # Standard service options
+        assert "folder_path" in option_names
+        assert "folder_key" in option_names
+        assert "format" in option_names
+        assert "output" in option_names
+
+        # List-specific options
+        assert "limit" in option_names
+        assert "offset" in option_names
+
+    def test_create_command_has_required_parameters(self):
+        """Test create command has name and description parameters."""
+        create_cmd = buckets.commands["create"]
+        option_names = [param.name for param in create_cmd.params]
+
+        assert "name" in option_names  # Positional argument
+        assert "description" in option_names
+        assert "folder_path" in option_names
+        assert "folder_key" in option_names
+        assert "format" in option_names
+        assert "output" in option_names
+
+    def test_retrieve_command_has_dual_options(self):
+        """Test retrieve command has both --name and --key options."""
+        retrieve_cmd = buckets.commands["retrieve"]
+        option_names = [param.name for param in retrieve_cmd.params]
+
+        # Dual identifier options
+        assert "name" in option_names
+        assert "key" in option_names
+
+        # Standard service options
+        assert "folder_path" in option_names
+        assert "folder_key" in option_names
+        assert "format" in option_names
+        assert "output" in option_names
+
+    def test_delete_command_has_confirmation_parameters(self):
+        """Test delete command has confirmation and dry-run parameters."""
+        delete_cmd = buckets.commands["delete"]
+        option_names = [param.name for param in delete_cmd.params]
+
+        assert "name" in option_names
+        assert "confirm" in option_names
+        assert "dry_run" in option_names
+        assert "folder_path" in option_names
+        assert "folder_key" in option_names
+
+    def test_exists_command_has_name_parameter(self):
+        """Test exists command has name parameter."""
+        exists_cmd = buckets.commands["exists"]
+        option_names = [param.name for param in exists_cmd.params]
+
+        assert "name" in option_names
+        assert "folder_path" in option_names
+        assert "folder_key" in option_names
+
+    def test_files_list_has_bucket_name_and_options(self):
+        """Test files list command has bucket_name and filtering options."""
+        files_group = buckets.commands["files"]
+        assert isinstance(files_group, click.Group)
+        list_files_cmd = files_group.commands["list"]
+        option_names = [param.name for param in list_files_cmd.params]
+
+        assert "bucket_name" in option_names
+        assert "prefix" in option_names
+        assert "limit" in option_names
+        assert "offset" in option_names
+        assert "fetch_all" in option_names
+
+    def test_files_upload_has_required_paths(self):
+        """Test files upload command has local_path and remote_path."""
+        files_group = buckets.commands["files"]
+        assert isinstance(files_group, click.Group)
+        upload_cmd = files_group.commands["upload"]
+        option_names = [param.name for param in upload_cmd.params]
+
+        assert "bucket_name" in option_names
+        assert "local_path" in option_names
+        assert "remote_path" in option_names
+
+    def test_files_download_has_required_paths(self):
+        """Test files download command has remote_path and local_path."""
+        files_group = buckets.commands["files"]
+        assert isinstance(files_group, click.Group)
+        download_cmd = files_group.commands["download"]
+        option_names = [param.name for param in download_cmd.params]
+
+        assert "bucket_name" in option_names
+        assert "remote_path" in option_names
+        assert "local_path" in option_names
diff --git a/packages/uipath/tests/cli/unit/test_context.py b/packages/uipath/tests/cli/unit/test_context.py
new file mode 100644
index 000000000..cb482c45d
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_context.py
@@ -0,0 +1,76 @@
+"""Unit tests for type-safe context management.
+
+Tests the CliContext dataclass and get_cli_context() helper.
+"""
+
+import click
+from click.testing import CliRunner
+
+from uipath._cli._utils._context import CliContext, get_cli_context
+
+
+def test_cli_context_default_values():
+    """Test that CliContext has sensible default values."""
+    ctx = CliContext()
+
+    assert ctx.output_format == "table"
+    assert ctx.debug is False
+    assert ctx._client is None
+
+
+def test_cli_context_with_values():
+    """Test that CliContext accepts custom values."""
+    ctx = CliContext(
+        output_format="json",
+        debug=True,
+    )
+
+    assert ctx.output_format == "json"
+    assert ctx.debug is True
+
+
+def test_get_cli_context_returns_typed_object():
+    """Test that get_cli_context returns a typed CliContext object."""
+
+    @click.command()
+    @click.pass_context
+    def test_cmd(ctx):
+        cli_ctx = get_cli_context(ctx)
+        assert isinstance(cli_ctx, CliContext)
+        assert hasattr(cli_ctx, "output_format")
+        assert hasattr(cli_ctx, "debug")
+
+    # Create a Click context with CliContext
+    runner = CliRunner()
+    ctx_obj = CliContext(output_format="json")
+
+    with runner.isolated_filesystem():
+        result = runner.invoke(test_cmd, obj=ctx_obj)
+        assert result.exit_code == 0
+
+
+def test_cli_context_is_dataclass():
+    """Test that CliContext is a proper dataclass."""
+    import dataclasses
+
+    assert dataclasses.is_dataclass(CliContext)
+
+    # Test that we can use dataclass features
+    ctx1 = CliContext(output_format="json", debug=True)
+    ctx2 = CliContext(output_format="json", debug=True)
+
+    # Dataclasses with same values should be equal
+    assert ctx1 == ctx2
+
+
+def test_cli_context_client_cache():
+    """Test that _client field is properly initialized."""
+    ctx = CliContext()
+
+    # Should start as None
+    assert ctx._client is None
+
+    # Should be able to set it
+    mock_client = object()
+    ctx._client = mock_client
+    assert ctx._client is mock_client
diff --git a/packages/uipath/tests/cli/unit/test_formatters.py b/packages/uipath/tests/cli/unit/test_formatters.py
new file mode 100644
index 000000000..44891277e
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_formatters.py
@@ -0,0 +1,209 @@
+"""Unit tests for output formatters.
+
+Tests JSON, table, and CSV formatting with various data types.
+"""
+
+import json
+from typing import Any
+
+from uipath._cli._utils._formatters import (
+    _format_csv,
+    _format_json,
+    _format_table,
+)
+
+
+def test_format_json_simple_dict():
+    """Test JSON formatting with a simple dictionary."""
+    data = {"name": "test", "value": 123}
+    result = _format_json(data)
+
+    # Should be valid JSON
+    parsed = json.loads(result)
+    assert parsed == data
+
+
+def test_format_json_list_of_dicts():
+    """Test JSON formatting with list of dictionaries."""
+    data = [{"id": 1, "name": "first"}, {"id": 2, "name": "second"}]
+    result = _format_json(data)
+
+    parsed = json.loads(result)
+    assert len(parsed) == 2
+    assert parsed[0]["name"] == "first"
+
+
+def test_format_table_single_item():
+    """Test Rich table formatting with a single item."""
+    data = {"name": "test", "value": "123"}
+    result = _format_table(data, no_color=True)
+
+    # Should contain column headers
+    assert "name" in result
+    assert "value" in result
+
+    # Should contain data
+    assert "test" in result
+    assert "123" in result
+
+
+def test_format_table_list():
+    """Test Rich table formatting with a list."""
+    data = [{"id": 1, "name": "first"}, {"id": 2, "name": "second"}]
+    result = _format_table(data, no_color=True)
+
+    # Should contain headers
+    assert "id" in result
+    assert "name" in result
+
+    # Should contain all data
+    assert "first" in result
+    assert "second" in result
+
+
+def test_format_table_empty_list():
+    """Test Rich table formatting with empty list."""
+    data: list[Any] = []
+    result = _format_table(data, no_color=True)
+
+    assert result == "No results"
+
+
+def test_format_csv_single_item():
+    """Test CSV formatting with a single item."""
+    data = {"name": "test", "value": "123"}
+    result = _format_csv(data)
+
+    # Should have header
+    assert "name,value" in result or "value,name" in result
+
+    # Should have data row
+    assert "test" in result
+    assert "123" in result
+
+
+def test_format_csv_list():
+    """Test CSV formatting with a list."""
+    data = [{"id": "1", "name": "first"}, {"id": "2", "name": "second"}]
+    result = _format_csv(data)
+
+    lines = result.strip().split("\n")
+
+    # Should have header + 2 data rows
+    assert len(lines) == 3
+
+
+def test_format_csv_empty_list():
+    """Test CSV formatting with empty list."""
+    data: list[Any] = []
+    result = _format_csv(data)
+
+    assert result == ""
+
+
+def test_format_output_handles_pydantic_models():
+    """Test that format_output can handle Pydantic models."""
+    from pydantic import BaseModel
+
+    class TestModel(BaseModel):
+        name: str
+        value: int
+
+    model = TestModel(name="test", value=123)
+
+    # Should not raise an error
+    result = _format_json(model.model_dump())
+    parsed = json.loads(result)
+    assert parsed["name"] == "test"
+    assert parsed["value"] == 123
+
+
+def test_format_output_handles_generators():
+    """Test that format_output handles generators properly."""
+
+    def generate_items():
+        yield {"id": 1}
+        yield {"id": 2}
+        yield {"id": 3}
+
+    # Note: The actual format_output function handles this,
+    # but the internal formatters expect lists
+    items = list(generate_items())
+    result = _format_json(items)
+
+    parsed = json.loads(result)
+    assert len(parsed) == 3
+
+
+def test_format_json_with_special_types():
+    """Test JSON formatting with datetime, UUID, etc."""
+    from datetime import datetime
+    from uuid import uuid4
+
+    data = {
+        "timestamp": datetime(2025, 1, 1, 12, 0, 0),
+        "uuid": uuid4(),
+        "none_value": None,
+    }
+
+    result = _format_json(data)
+
+    # Should handle special types via default=str
+    parsed = json.loads(result)
+    assert "timestamp" in parsed
+    assert "uuid" in parsed
+    assert parsed["none_value"] is None
+
+
+def test_format_output_handles_pydantic_in_generators():
+    """Test that format_output handles Pydantic models inside generators."""
+    from pydantic import BaseModel
+
+    class TestModel(BaseModel):
+        name: str
+        value: int
+
+    def generate_models():
+        yield TestModel(name="test1", value=1)
+        yield TestModel(name="test2", value=2)
+
+    # Convert to list to use _format_json (format_output would consume the generator)
+    items = list(generate_models())
+    # Manually convert Pydantic models to dicts as format_output does
+    items_dicts = [item.model_dump() for item in items]
+
+    result = _format_json(items_dicts)
+    parsed = json.loads(result)
+
+    assert len(parsed) == 2
+    assert parsed[0]["name"] == "test1"
+    assert parsed[1]["name"] == "test2"
+
+
+def test_format_table_with_rich_fallback():
+    """Test table formatting falls back gracefully when rich is unavailable."""
+    # We can't easily test ImportError without mocking, but we can test the code path
+    # by directly calling the function which has the try/except
+    data = [{"id": "1", "name": "first"}, {"id": "2", "name": "second"}]
+    result = _format_table(data, no_color=True)
+
+    # Should contain the data regardless of rich availability
+    assert "1" in result
+    assert "first" in result
+    assert "2" in result
+    assert "second" in result
+
+
+def test_format_output_forces_no_color_for_file_output(tmp_path):
+    """Test that table output to file is colorless."""
+    from uipath._cli._utils._formatters import format_output
+
+    data = [{"name": "test"}]
+    output_file = tmp_path / "output.txt"
+
+    format_output(data, fmt="table", output=str(output_file), no_color=False)
+
+    content = output_file.read_text(encoding="utf-8")
+    # Verify no ANSI escape codes in output
+    assert "\x1b[" not in content  # ANSI escape sequence start
+    assert "test" in content
diff --git a/packages/uipath/tests/cli/unit/test_service_cli_generator.py b/packages/uipath/tests/cli/unit/test_service_cli_generator.py
new file mode 100644
index 000000000..531a48a63
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_service_cli_generator.py
@@ -0,0 +1,913 @@
+"""Unit tests for ServiceCLIGenerator.
+
+Tests cover:
+- Generator initialization and validation
+- register() method creating CRUD commands
+- Command generation for list, retrieve, create, delete, exists
+- Parameter handling and type resolution
+- Confirmation and dry-run support
+- Error handling
+- Provenance tracking
+"""
+
+import click
+import pytest
+
+from uipath._cli._utils._service_cli_generator import ServiceCLIGenerator
+from uipath._cli._utils._service_metadata import (
+    CreateParameter,
+    DeleteCommandConfig,
+    ExistsCommandConfig,
+    ServiceMetadata,
+)
+
+
+class TestServiceCLIGeneratorInitialization:
+    """Test ServiceCLIGenerator initialization."""
+
+    def test_generator_initialization_valid_metadata(self):
+        """Test generator initializes with valid metadata."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        assert generator.metadata == metadata
+        assert isinstance(generator._command_names, set)
+        assert len(generator._command_names) == 0  # No commands registered yet
+        assert isinstance(generator._provenance, dict)
+
+    def test_generator_initialization_with_create_params(self):
+        """Test generator initializes with create parameters."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Bucket description",
+                ),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        assert generator.metadata == metadata
+        assert "description" in generator.metadata.create_params
+
+    def test_generator_initialization_validates_types(self):
+        """Test generator validates parameter types during initialization."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            create_params={
+                "invalid": CreateParameter(type="InvalidType", required=False),
+            },
+        )
+
+        with pytest.raises(ValueError) as exc_info:
+            ServiceCLIGenerator(metadata)
+
+        error_msg = str(exc_info.value)
+        assert "InvalidType" in error_msg
+        assert "invalid" in error_msg
+
+
+class TestServiceCLIGeneratorRegister:
+    """Test register() method."""
+
+    def test_register_creates_service_group(self):
+        """Test that register creates a service group."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        # Create parent group
+        @click.group()
+        def cli():
+            pass
+
+        # Register service
+        service_group = generator.register(cli)
+
+        # Verify group was created
+        assert service_group is not None
+        assert service_group.name == "buckets"
+        assert service_group.help == "Manage Buckets"
+
+        # Verify group was added to parent
+        assert "buckets" in cli.commands
+
+    def test_register_creates_crud_commands(self):
+        """Test that register creates all CRUD commands."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Verify all CRUD commands were created
+        assert "list" in service_group.commands
+        assert "retrieve" in service_group.commands
+        assert "create" in service_group.commands
+        assert "delete" in service_group.commands
+        assert "exists" in service_group.commands
+
+    def test_register_tracks_command_names(self):
+        """Test that register tracks generated command names."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        generator.register(cli)
+
+        # Verify command names were tracked
+        command_names = generator.get_command_names()
+        assert "list" in command_names
+        assert "retrieve" in command_names
+        assert "create" in command_names
+        assert "delete" in command_names
+        assert "exists" in command_names
+
+
+class TestGeneratedListCommand:
+    """Test generated list command."""
+
+    def test_list_command_has_correct_options(self):
+        """Test list command has folder options."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        list_cmd = service_group.commands["list"]
+
+        # Check that command has folder-path and folder-key options
+        param_names = [p.name for p in list_cmd.params]
+        assert "folder_path" in param_names
+        assert "folder_key" in param_names
+
+    def test_list_command_exists(self):
+        """Test list command is created successfully."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            resource_plural="Buckets",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        list_cmd = service_group.commands["list"]
+
+        # Verify command exists and is callable
+        assert list_cmd is not None
+        assert callable(list_cmd.callback)
+
+
+class TestGeneratedRetrieveCommand:
+    """Test generated retrieve command."""
+
+    def test_retrieve_command_has_name_argument(self):
+        """Test retrieve command has NAME argument."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        retrieve_cmd = service_group.commands["retrieve"]
+
+        # Check for NAME argument
+        param_names = [p.name for p in retrieve_cmd.params]
+        assert "name" in param_names
+
+        # Verify it's an argument, not an option
+        name_param = next(p for p in retrieve_cmd.params if p.name == "name")
+        assert isinstance(name_param, click.Argument)
+
+    def test_retrieve_command_has_folder_options(self):
+        """Test retrieve command has folder options."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        retrieve_cmd = service_group.commands["retrieve"]
+
+        param_names = [p.name for p in retrieve_cmd.params]
+        assert "folder_path" in param_names
+        assert "folder_key" in param_names
+
+
+class TestGeneratedCreateCommand:
+    """Test generated create command."""
+
+    def test_create_command_has_name_argument(self):
+        """Test create command has NAME argument."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        create_cmd = service_group.commands["create"]
+
+        param_names = [p.name for p in create_cmd.params]
+        assert "name" in param_names
+
+    def test_create_command_has_custom_parameters(self):
+        """Test create command includes custom parameters from metadata."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Bucket description",
+                ),
+                "max_size": CreateParameter(
+                    type="int",
+                    required=False,
+                    help="Maximum size in MB",
+                    default=1000,
+                ),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        create_cmd = service_group.commands["create"]
+
+        param_names = [p.name for p in create_cmd.params]
+        assert "description" in param_names
+        assert "max_size" in param_names
+
+    def test_create_command_parameter_types(self):
+        """Test create command parameters have correct types."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            create_params={
+                "count": CreateParameter(type="int", required=False),
+                "enabled": CreateParameter(type="bool", required=False),
+                "ratio": CreateParameter(type="float", required=False),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        create_cmd = service_group.commands["create"]
+
+        # Find parameter objects
+        count_param = next(p for p in create_cmd.params if p.name == "count")
+        enabled_param = next(p for p in create_cmd.params if p.name == "enabled")
+        ratio_param = next(p for p in create_cmd.params if p.name == "ratio")
+
+        # Verify types (Click uses lowercase names - int=integer, bool=boolean)
+        assert (
+            count_param.type.name.lower() == "integer" or count_param.type.name == "INT"
+        )
+        assert enabled_param.type.name.lower() in ("bool", "boolean")
+        assert ratio_param.type.name.lower() == "float"
+
+    def test_create_command_required_parameters(self):
+        """Test create command respects required flag."""
+        metadata = ServiceMetadata(
+            service_name="assets",
+            service_attr="assets",
+            resource_type="Asset",
+            create_params={
+                "value": CreateParameter(
+                    type="str",
+                    required=True,
+                    help="Asset value",
+                ),
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Asset description",
+                ),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        create_cmd = service_group.commands["create"]
+
+        # Find parameter objects
+        value_param = next(p for p in create_cmd.params if p.name == "value")
+        description_param = next(
+            p for p in create_cmd.params if p.name == "description"
+        )
+
+        # Verify required flags
+        assert value_param.required is True
+        assert description_param.required is False
+
+
+class TestGeneratedDeleteCommand:
+    """Test generated delete command."""
+
+    def test_delete_command_has_name_argument(self):
+        """Test delete command has NAME argument."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        delete_cmd = service_group.commands["delete"]
+
+        param_names = [p.name for p in delete_cmd.params]
+        assert "name" in param_names
+
+    def test_delete_command_has_confirm_option_by_default(self):
+        """Test delete command has --confirm option by default."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        delete_cmd = service_group.commands["delete"]
+
+        param_names = [p.name for p in delete_cmd.params]
+        assert "confirm" in param_names
+
+    def test_delete_command_has_dry_run_option_by_default(self):
+        """Test delete command has --dry-run option by default."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        delete_cmd = service_group.commands["delete"]
+
+        param_names = [p.name for p in delete_cmd.params]
+        assert "dry_run" in param_names
+
+    def test_delete_command_without_confirmation(self):
+        """Test delete command can disable confirmation."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            delete_cmd=DeleteCommandConfig(
+                confirmation_required=False,
+                dry_run_supported=True,
+            ),
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        delete_cmd = service_group.commands["delete"]
+
+        param_names = [p.name for p in delete_cmd.params]
+        assert "confirm" not in param_names
+        assert "dry_run" in param_names  # Still has dry-run
+
+    def test_delete_command_without_dry_run(self):
+        """Test delete command can disable dry-run."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            delete_cmd=DeleteCommandConfig(
+                confirmation_required=True,
+                dry_run_supported=False,
+            ),
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        delete_cmd = service_group.commands["delete"]
+
+        param_names = [p.name for p in delete_cmd.params]
+        assert "confirm" in param_names
+        assert "dry_run" not in param_names
+
+
+class TestGeneratedExistsCommand:
+    """Test generated exists command."""
+
+    def test_exists_command_has_name_argument(self):
+        """Test exists command has NAME argument."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        exists_cmd = service_group.commands["exists"]
+
+        param_names = [p.name for p in exists_cmd.params]
+        assert "name" in param_names
+
+    def test_exists_command_custom_identifier(self):
+        """Test exists command with custom identifier argument."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            exists_cmd=ExistsCommandConfig(
+                identifier_arg_name="key",
+                return_format="bool",
+            ),
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+        exists_cmd = service_group.commands["exists"]
+
+        param_names = [p.name for p in exists_cmd.params]
+        assert "key" in param_names
+
+
+class TestProvenance:
+    """Test provenance tracking."""
+
+    def test_get_command_names_returns_all_commands(self):
+        """Test get_command_names returns all generated commands."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        generator.register(cli)
+
+        command_names = generator.get_command_names()
+
+        assert "list" in command_names
+        assert "retrieve" in command_names
+        assert "create" in command_names
+        assert "delete" in command_names
+        assert "exists" in command_names
+        assert len(command_names) == 5
+
+    def test_get_provenance_returns_command_info(self):
+        """Test get_provenance returns command metadata."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        generator.register(cli)
+
+        provenance = generator.get_provenance("list")
+
+        assert provenance is not None
+        assert provenance["generator"] == "ServiceCLIGenerator"
+        assert provenance["service_name"] == "buckets"
+        assert provenance["resource_type"] == "Bucket"
+        assert "command_function" in provenance
+
+    def test_get_provenance_returns_none_for_unknown_command(self):
+        """Test get_provenance returns None for unknown command."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        provenance = generator.get_provenance("unknown")
+
+        assert provenance is None
+
+
+class TestAdvancedFeatures:
+    """Test advanced features: add_nested_group, override_command, collision detection."""
+
+    def test_add_nested_group_success(self):
+        """Test adding a custom nested group successfully."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Create custom nested group
+        @click.group()
+        def file_group():
+            """File operations"""
+            pass
+
+        @file_group.command("upload")
+        def upload():
+            """Upload a file"""
+            pass
+
+        # Add nested group
+        generator.add_nested_group(service_group, "file", file_group)
+
+        # Verify nested group was added
+        assert "file" in service_group.commands
+        assert "file" in generator.get_command_names()
+
+        # Verify provenance
+        provenance = generator.get_provenance("file")
+        assert provenance is not None
+        assert provenance["generator"] == "manual"
+        assert provenance["type"] == "nested_group"
+
+    def test_add_nested_group_collision_with_generated_command(self):
+        """Test that adding nested group with existing name raises error."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Try to add nested group with name that conflicts
+        @click.group()
+        def list_group():
+            """Custom list"""
+            pass
+
+        with pytest.raises(ValueError) as exc_info:
+            generator.add_nested_group(service_group, "list", list_group)
+
+        error_msg = str(exc_info.value)
+        assert "Cannot add nested group 'list'" in error_msg
+        assert "conflicts with auto-generated command" in error_msg
+
+    def test_override_command_success(self):
+        """Test overriding an auto-generated command successfully."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Create custom command
+        @click.command("list")
+        def custom_list():
+            """Custom list implementation"""
+            pass
+
+        # Override the auto-generated list command
+        generator.override_command(service_group, "list", custom_list)
+
+        # Verify command was overridden
+        assert "list" in service_group.commands
+        list_cmd = service_group.commands["list"]
+        # The command should be the custom_command Click object
+        assert list_cmd == custom_list
+
+        # Verify provenance shows override
+        provenance = generator.get_provenance("list")
+        assert provenance is not None
+        assert provenance["generator"] == "manual_override"
+        assert provenance["original_generator"] == "ServiceCLIGenerator"
+
+    def test_override_command_nonexistent(self):
+        """Test that overriding nonexistent command raises error."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        @click.command("nonexistent")
+        def custom_cmd():
+            pass
+
+        with pytest.raises(ValueError) as exc_info:
+            generator.override_command(service_group, "nonexistent", custom_cmd)
+
+        error_msg = str(exc_info.value)
+        assert "Cannot override command 'nonexistent'" in error_msg
+        assert "does not exist" in error_msg
+
+    def test_override_command_non_generated(self):
+        """Test that overriding non-generated command raises error."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Add a manual nested group first
+        @click.group()
+        def file_group():
+            """File operations"""
+            pass
+
+        generator.add_nested_group(service_group, "file", file_group)
+
+        # Try to override the manually added group
+        @click.command("file")
+        def custom_file():
+            pass
+
+        with pytest.raises(ValueError) as exc_info:
+            generator.override_command(service_group, "file", custom_file)
+
+        error_msg = str(exc_info.value)
+        assert "Cannot override command 'file'" in error_msg
+        assert "not an auto-generated command" in error_msg
+
+    def test_validate_no_collisions_success(self):
+        """Test collision validation with no collisions."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Check commands that don't collide
+        errors = generator.validate_no_collisions(service_group, ["custom1", "custom2"])
+
+        assert errors == []
+
+    def test_validate_no_collisions_with_conflicts(self):
+        """Test collision validation detects conflicts."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Check commands that do collide
+        errors = generator.validate_no_collisions(
+            service_group, ["list", "retrieve", "custom"]
+        )
+
+        assert len(errors) == 2
+        assert "Command 'list' conflicts" in errors[0]
+        assert "Command 'retrieve' conflicts" in errors[1]
+
+
+class TestRealWorldExamples:
+    """Test generator with real-world service examples."""
+
+    def test_buckets_service_metadata(self):
+        """Test generator with buckets service metadata."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Bucket description",
+                ),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Verify group created
+        assert service_group.name == "buckets"
+
+        # Verify all commands exist
+        assert "list" in service_group.commands
+        assert "retrieve" in service_group.commands
+        assert "create" in service_group.commands
+        assert "delete" in service_group.commands
+        assert "exists" in service_group.commands
+
+        # Verify create has description parameter
+        create_cmd = service_group.commands["create"]
+        param_names = [p.name for p in create_cmd.params]
+        assert "description" in param_names
+
+    def test_assets_service_metadata(self):
+        """Test generator with assets service metadata."""
+        metadata = ServiceMetadata(
+            service_name="assets",
+            service_attr="assets",
+            resource_type="Asset",
+            create_params={
+                "value": CreateParameter(
+                    type="str",
+                    required=True,
+                    help="Asset value",
+                ),
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Asset description",
+                ),
+            },
+        )
+
+        generator = ServiceCLIGenerator(metadata)
+
+        @click.group()
+        def cli():
+            pass
+
+        service_group = generator.register(cli)
+
+        # Verify create has value and description parameters
+        create_cmd = service_group.commands["create"]
+        param_names = [p.name for p in create_cmd.params]
+        assert "value" in param_names
+        assert "description" in param_names
+
+        # Verify value is required
+        value_param = next(p for p in create_cmd.params if p.name == "value")
+        assert value_param.required is True
diff --git a/packages/uipath/tests/cli/unit/test_service_metadata.py b/packages/uipath/tests/cli/unit/test_service_metadata.py
new file mode 100644
index 000000000..547bb70c4
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_service_metadata.py
@@ -0,0 +1,381 @@
+"""Unit tests for ServiceMetadata Pydantic models.
+
+Tests cover:
+- CreateParameter model creation and immutability
+- DeleteCommandConfig defaults
+- ExistsCommandConfig configuration
+- ServiceMetadata model creation
+- ServiceMetadata validators and defaults
+- Type validation
+- Model immutability (frozen=True)
+"""
+
+import pytest
+from pydantic import ValidationError
+
+from uipath._cli._utils._service_metadata import (
+    CreateParameter,
+    DeleteCommandConfig,
+    ExistsCommandConfig,
+    ServiceMetadata,
+)
+
+__all__ = [
+    "TestCreateParameter",
+    "TestDeleteCommandConfig",
+    "TestExistsCommandConfig",
+    "TestServiceMetadata",
+    "TestServiceMetadataValidation",
+    "TestServiceMetadataRealWorldExamples",
+]
+
+
+class TestCreateParameter:
+    """Test CreateParameter model."""
+
+    def test_create_parameter_minimal(self):
+        """Test creating parameter with minimal fields."""
+        param = CreateParameter(type="str")
+
+        assert param.type == "str"
+        assert param.required is False  # Default
+        assert param.help == ""  # Default
+        assert param.default is None  # Default
+        assert param.option_name is None  # Default
+
+    def test_create_parameter_full(self):
+        """Test creating parameter with all fields."""
+        param = CreateParameter(
+            type="int",
+            required=True,
+            help="A number parameter",
+            default=42,
+            option_name="num",
+        )
+
+        assert param.type == "int"
+        assert param.required is True
+        assert param.help == "A number parameter"
+        assert param.default == 42
+        assert param.option_name == "num"
+
+    def test_create_parameter_immutable(self):
+        """Test that CreateParameter is immutable (frozen=True)."""
+        param = CreateParameter(type="str", help="Original")
+
+        with pytest.raises((ValidationError, AttributeError)):
+            param.help = "Modified"  # type: ignore[misc]  # Testing that this raises
+
+    def test_create_parameter_different_types(self):
+        """Test creating parameters with different types."""
+        str_param = CreateParameter(type="str")
+        int_param = CreateParameter(type="int")
+        bool_param = CreateParameter(type="bool")
+        float_param = CreateParameter(type="float")
+
+        assert str_param.type == "str"
+        assert int_param.type == "int"
+        assert bool_param.type == "bool"
+        assert float_param.type == "float"
+
+
+class TestDeleteCommandConfig:
+    """Test DeleteCommandConfig model."""
+
+    def test_delete_command_config_defaults(self):
+        """Test default values for delete configuration."""
+        config = DeleteCommandConfig()
+
+        assert config.confirmation_required is True
+        assert config.dry_run_supported is True
+        assert config.confirmation_prompt is None
+
+    def test_delete_command_config_custom(self):
+        """Test custom delete configuration."""
+        config = DeleteCommandConfig(
+            confirmation_required=False,
+            dry_run_supported=False,
+            confirmation_prompt="Are you sure?",
+        )
+
+        assert config.confirmation_required is False
+        assert config.dry_run_supported is False
+        assert config.confirmation_prompt == "Are you sure?"
+
+    def test_delete_command_config_immutable(self):
+        """Test that DeleteCommandConfig is immutable."""
+        config = DeleteCommandConfig()
+
+        with pytest.raises((ValidationError, AttributeError)):
+            config.confirmation_required = False  # type: ignore[misc]  # Testing that this raises
+
+
+class TestExistsCommandConfig:
+    """Test ExistsCommandConfig model."""
+
+    def test_exists_command_config_defaults(self):
+        """Test default values for exists configuration."""
+        config = ExistsCommandConfig()
+
+        assert config.identifier_arg_name == "name"
+        assert config.return_format == "dict"
+
+    def test_exists_command_config_custom(self):
+        """Test custom exists configuration."""
+        config = ExistsCommandConfig(
+            identifier_arg_name="key",
+            return_format="bool",
+        )
+
+        assert config.identifier_arg_name == "key"
+        assert config.return_format == "bool"
+
+    def test_exists_command_config_immutable(self):
+        """Test that ExistsCommandConfig is immutable."""
+        config = ExistsCommandConfig()
+
+        with pytest.raises((ValidationError, AttributeError)):
+            config.identifier_arg_name = "id"  # type: ignore[misc]  # Testing that this raises
+
+
+class TestServiceMetadata:
+    """Test ServiceMetadata model."""
+
+    def test_service_metadata_minimal(self):
+        """Test creating metadata with minimal required fields."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        assert metadata.service_name == "test"
+        assert metadata.service_attr == "test"
+        assert metadata.resource_type == "Test"
+        assert metadata.resource_plural == "Tests"  # Auto-generated
+        assert metadata.create_params == {}  # Default
+        assert isinstance(metadata.delete_cmd, DeleteCommandConfig)
+        assert isinstance(metadata.exists_cmd, ExistsCommandConfig)
+
+    def test_service_metadata_auto_plural(self):
+        """Test that resource_plural is auto-generated from resource_type."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+        )
+
+        assert metadata.resource_plural == "Buckets"
+
+    def test_service_metadata_custom_plural(self):
+        """Test specifying custom resource_plural."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Process",
+            resource_plural="Processes",  # Custom (not "Processs")
+        )
+
+        assert metadata.resource_plural == "Processes"
+
+    def test_service_metadata_with_create_params(self):
+        """Test metadata with create parameters."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Bucket description",
+                ),
+                "max_size": CreateParameter(
+                    type="int",
+                    required=False,
+                    help="Maximum size in MB",
+                    default=1000,
+                ),
+            },
+        )
+
+        assert len(metadata.create_params) == 2
+        assert "description" in metadata.create_params
+        assert "max_size" in metadata.create_params
+        assert metadata.create_params["description"].type == "str"
+        assert metadata.create_params["max_size"].type == "int"
+        assert metadata.create_params["max_size"].default == 1000
+
+    def test_service_metadata_immutable(self):
+        """Test that ServiceMetadata is immutable."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+        )
+
+        with pytest.raises((ValidationError, AttributeError)):
+            metadata.service_name = "modified"  # type: ignore[misc]  # Testing that this raises
+
+    def test_service_metadata_custom_delete_config(self):
+        """Test metadata with custom delete configuration."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            delete_cmd=DeleteCommandConfig(
+                confirmation_required=False,
+                dry_run_supported=False,
+            ),
+        )
+
+        assert metadata.delete_cmd.confirmation_required is False
+        assert metadata.delete_cmd.dry_run_supported is False
+
+    def test_service_metadata_custom_exists_config(self):
+        """Test metadata with custom exists configuration."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            exists_cmd=ExistsCommandConfig(
+                identifier_arg_name="key",
+                return_format="bool",
+            ),
+        )
+
+        assert metadata.exists_cmd.identifier_arg_name == "key"
+        assert metadata.exists_cmd.return_format == "bool"
+
+
+class TestServiceMetadataValidation:
+    """Test ServiceMetadata validation methods."""
+
+    def test_validate_types_valid(self):
+        """Test validate_types() with valid types."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            create_params={
+                "param1": CreateParameter(type="str"),
+                "param2": CreateParameter(type="int"),
+                "param3": CreateParameter(type="bool"),
+            },
+        )
+
+        # Should not raise
+        metadata.validate_types()
+
+    def test_validate_types_invalid_raises(self):
+        """Test validate_types() raises for invalid type."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            create_params={
+                "invalid_param": CreateParameter(type="InvalidType"),
+            },
+        )
+
+        with pytest.raises(ValueError) as exc_info:
+            metadata.validate_types()
+
+        error_msg = str(exc_info.value)
+        assert "Invalid type 'InvalidType'" in error_msg
+        assert "invalid_param" in error_msg
+        assert "Valid types:" in error_msg
+
+    def test_validate_types_multiple_invalid(self):
+        """Test validate_types() with multiple invalid types."""
+        metadata = ServiceMetadata(
+            service_name="test",
+            service_attr="test",
+            resource_type="Test",
+            create_params={
+                "param1": CreateParameter(type="str"),  # Valid
+                "param2": CreateParameter(type="BadType"),  # Invalid
+                "param3": CreateParameter(type="int"),  # Valid
+            },
+        )
+
+        with pytest.raises(ValueError) as exc_info:
+            metadata.validate_types()
+
+        error_msg = str(exc_info.value)
+        assert "BadType" in error_msg
+        assert "param2" in error_msg
+
+
+class TestServiceMetadataRealWorldExamples:
+    """Test ServiceMetadata with real-world service examples."""
+
+    def test_buckets_metadata(self):
+        """Test metadata for buckets service."""
+        metadata = ServiceMetadata(
+            service_name="buckets",
+            service_attr="buckets",
+            resource_type="Bucket",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Bucket description",
+                ),
+            },
+        )
+
+        assert metadata.service_name == "buckets"
+        assert metadata.resource_plural == "Buckets"
+        assert "description" in metadata.create_params
+        metadata.validate_types()  # Should not raise
+
+    def test_assets_metadata(self):
+        """Test metadata for assets service."""
+        metadata = ServiceMetadata(
+            service_name="assets",
+            service_attr="assets",
+            resource_type="Asset",
+            create_params={
+                "value": CreateParameter(
+                    type="str",
+                    required=True,
+                    help="Asset value",
+                ),
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Asset description",
+                ),
+            },
+        )
+
+        assert metadata.service_name == "assets"
+        assert len(metadata.create_params) == 2
+        assert metadata.create_params["value"].required is True
+        metadata.validate_types()  # Should not raise
+
+    def test_queues_metadata(self):
+        """Test metadata for queues service."""
+        metadata = ServiceMetadata(
+            service_name="queues",
+            service_attr="queues",
+            resource_type="Queue",
+            create_params={
+                "description": CreateParameter(
+                    type="str",
+                    required=False,
+                    help="Queue description",
+                ),
+                "max_retries": CreateParameter(
+                    type="int",
+                    required=False,
+                    help="Maximum retry attempts",
+                    default=0,
+                ),
+            },
+        )
+
+        assert metadata.service_name == "queues"
+        assert metadata.create_params["max_retries"].default == 0
+        metadata.validate_types()  # Should not raise
diff --git a/packages/uipath/tests/cli/unit/test_service_protocol.py b/packages/uipath/tests/cli/unit/test_service_protocol.py
new file mode 100644
index 000000000..200bd3620
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_service_protocol.py
@@ -0,0 +1,361 @@
+"""Unit tests for CRUDServiceProtocol.
+
+Tests cover:
+- Protocol compliance checking
+- Structural subtyping (duck typing)
+- validate_service_protocol() function
+- Optional methods detection
+- Protocol documentation
+"""
+
+import pytest
+
+from uipath._cli._utils._service_protocol import (
+    CRUDServiceProtocol,
+    has_exists_method,
+    validate_service_protocol,
+)
+
+__all__ = [
+    "TestCRUDServiceProtocol",
+    "TestValidateServiceProtocol",
+    "TestProtocolDuckTyping",
+    "TestProtocolRealWorldExamples",
+]
+
+
+class TestCRUDServiceProtocol:
+    """Test CRUDServiceProtocol structural typing."""
+
+    def test_complete_service_implements_protocol(self):
+        """Test that a complete service implements the protocol."""
+
+        class CompleteService:
+            """Service implementing all CRUD methods."""
+
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+            def exists(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return True
+
+        service = CompleteService()
+
+        # isinstance check should work with runtime_checkable Protocol
+        assert isinstance(service, CRUDServiceProtocol)
+
+    def test_service_without_exists_still_valid(self):
+        """Test that service without exists() is still valid (optional method)."""
+
+        class ServiceWithoutExists:
+            """Service without optional exists() method."""
+
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+            # No exists() method
+
+        service = ServiceWithoutExists()
+
+        # Should still be considered valid since exists() is optional
+        assert isinstance(service, CRUDServiceProtocol)
+
+    def test_incomplete_service_not_protocol(self):
+        """Test that incomplete service doesn't match protocol."""
+
+        class IncompleteService:
+            """Service missing required methods."""
+
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            # Missing retrieve, create, delete
+
+        service = IncompleteService()
+
+        # Should not be considered valid
+        assert not isinstance(service, CRUDServiceProtocol)
+
+
+class TestValidateServiceProtocol:
+    """Test validate_service_protocol() function."""
+
+    def test_validate_complete_service(self):
+        """Test validation of complete service."""
+
+        class CompleteService:
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+            def exists(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return True
+
+        service = CompleteService()
+
+        # Should not raise for valid service
+        validate_service_protocol(service, "complete")
+
+        # Check optional exists method separately
+        assert has_exists_method(service)
+
+    def test_validate_service_without_exists(self):
+        """Test validation of service without optional exists()."""
+
+        class ServiceWithoutExists:
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+        service = ServiceWithoutExists()
+
+        # Should not raise, exists is optional
+        validate_service_protocol(service, "test")
+
+        # Verify exists method is not present
+        assert not has_exists_method(service)
+
+    def test_validate_incomplete_service_raises(self):
+        """Test that incomplete service raises TypeError."""
+
+        class IncompleteService:
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            # Missing retrieve, create, delete
+
+        service = IncompleteService()
+
+        with pytest.raises(TypeError) as exc_info:
+            validate_service_protocol(service, "incomplete")
+
+        error_msg = str(exc_info.value)
+        assert "incomplete" in error_msg
+        assert "must implement" in error_msg
+        assert "retrieve" in error_msg
+        assert "create" in error_msg
+        assert "delete" in error_msg
+
+    def test_validate_service_missing_single_method(self):
+        """Test validation when only one method is missing."""
+
+        class ServiceMissingCreate:
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            # Missing create
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+        service = ServiceMissingCreate()
+
+        with pytest.raises(TypeError) as exc_info:
+            validate_service_protocol(service, "test")
+
+        error_msg = str(exc_info.value)
+        assert "create" in error_msg
+
+    def test_validate_service_with_non_callable_attribute(self):
+        """Test that non-callable attributes don't count as methods."""
+
+        class ServiceWithNonCallable:
+            list = "not_a_method"  # String instead of method
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+        service = ServiceWithNonCallable()
+
+        # Should raise because list is not callable
+        with pytest.raises(TypeError) as exc_info:
+            validate_service_protocol(service, "test")
+
+        error_msg = str(exc_info.value)
+        assert "list" in error_msg
+
+
+class TestProtocolDuckTyping:
+    """Test duck typing behavior of the protocol."""
+
+    def test_service_without_inheritance_works(self):
+        """Test that services don't need to inherit from protocol."""
+
+        # No explicit inheritance from CRUDServiceProtocol
+        class IndependentService:
+            def list(self, *, folder_path=None, folder_key=None, **kwargs):
+                return iter([{"id": 1}, {"id": 2}])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name, "id": 1}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {"name": name, "created": True}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return None
+
+        service = IndependentService()
+
+        # Should work with structural typing
+        assert isinstance(service, CRUDServiceProtocol)
+
+        # Can be used as CRUDServiceProtocol type
+        def use_service(s: CRUDServiceProtocol):
+            return list(s.list())
+
+        result = use_service(service)
+        assert len(result) == 2
+
+    def test_different_signature_compatible(self):
+        """Test that compatible signatures work (extra params OK)."""
+
+        class ExtendedService:
+            def list(
+                self, *, folder_path=None, folder_key=None, extra_filter=None, **kwargs
+            ):
+                # Extra parameter is OK
+                return iter([])
+
+            def retrieve(
+                self,
+                name,
+                *,
+                folder_path=None,
+                folder_key=None,
+                include_meta=False,
+                **kwargs,
+            ):
+                # Extra parameter is OK
+                return {}
+
+            def create(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                return {}
+
+            def delete(self, name, *, folder_path=None, folder_key=None, **kwargs):
+                pass
+
+        service = ExtendedService()
+
+        # Should still match protocol
+        assert isinstance(service, CRUDServiceProtocol)
+
+
+class TestProtocolRealWorldExamples:
+    """Test protocol with real-world service examples."""
+
+    def test_buckets_service_like(self):
+        """Test service similar to actual BucketsService."""
+
+        class BucketsService:
+            def list(self, *, folder_path=None, folder_key=None):
+                return iter(
+                    [
+                        {"name": "bucket1", "description": "Test"},
+                        {"name": "bucket2", "description": "Test"},
+                    ]
+                )
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None):
+                return {"name": name, "description": "Retrieved bucket"}
+
+            def create(
+                self, name, *, description=None, folder_path=None, folder_key=None
+            ):
+                return {"name": name, "description": description}
+
+            def delete(self, name, *, folder_path=None, folder_key=None):
+                pass
+
+            def exists(self, name, *, folder_path=None, folder_key=None):
+                return True
+
+        service = BucketsService()
+
+        # Should match protocol
+        assert isinstance(service, CRUDServiceProtocol)
+
+        # Validation should pass
+        validate_service_protocol(service, "buckets")
+
+        # Check optional exists method separately
+        assert has_exists_method(service)
+
+    def test_assets_service_like(self):
+        """Test service similar to actual AssetsService."""
+
+        class AssetsService:
+            def list(self, *, folder_path=None, folder_key=None):
+                return iter([])
+
+            def retrieve(self, name, *, folder_path=None, folder_key=None):
+                return {"name": name, "value": "secret"}
+
+            def create(
+                self,
+                name,
+                *,
+                value,
+                description=None,
+                folder_path=None,
+                folder_key=None,
+            ):
+                return {"name": name, "value": value}
+
+            def delete(self, name, *, folder_path=None, folder_key=None):
+                pass
+
+            # No exists() method for assets
+
+        service = AssetsService()
+
+        # Should still match (exists is optional)
+        assert isinstance(service, CRUDServiceProtocol)
+
+        # Validation should pass
+        validate_service_protocol(service, "assets")
+
+        # Verify exists method is not present
+        assert not has_exists_method(service)
diff --git a/packages/uipath/tests/cli/unit/test_type_registry.py b/packages/uipath/tests/cli/unit/test_type_registry.py
new file mode 100644
index 000000000..58d7160ef
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_type_registry.py
@@ -0,0 +1,202 @@
+"""Unit tests for TYPE_REGISTRY module.
+
+Tests cover:
+- get_type() basic functionality
+- get_type() error handling
+- register_type() custom type registration
+- is_valid_type() validation
+- Security: ensuring eval() is not used
+"""
+
+import pytest
+
+from uipath._cli._utils._type_registry import (
+    TYPE_REGISTRY,
+    get_type,
+    is_valid_type,
+    register_type,
+)
+
+
+class TestGetType:
+    """Test get_type() function."""
+
+    def test_get_type_str(self):
+        """Test getting str type."""
+        result = get_type("str")
+        assert result is str
+
+    def test_get_type_int(self):
+        """Test getting int type."""
+        result = get_type("int")
+        assert result is int
+
+    def test_get_type_bool(self):
+        """Test getting bool type."""
+        result = get_type("bool")
+        assert result is bool
+
+    def test_get_type_float(self):
+        """Test getting float type."""
+        result = get_type("float")
+        assert result is float
+
+    def test_get_type_invalid_raises_value_error(self):
+        """Test that invalid type name raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            get_type("InvalidType")
+
+        error_msg = str(exc_info.value)
+        assert "Unknown type: 'InvalidType'" in error_msg
+        assert "Valid types:" in error_msg
+        assert "str" in error_msg
+        assert "int" in error_msg
+
+    def test_get_type_case_sensitive(self):
+        """Test that type names are case-sensitive."""
+        with pytest.raises(ValueError):
+            get_type("STR")  # Should be "str"
+
+        with pytest.raises(ValueError):
+            get_type("Int")  # Should be "int"
+
+
+class TestIsValidType:
+    """Test is_valid_type() function."""
+
+    def test_is_valid_type_str(self):
+        """Test that 'str' is valid."""
+        assert is_valid_type("str") is True
+
+    def test_is_valid_type_int(self):
+        """Test that 'int' is valid."""
+        assert is_valid_type("int") is True
+
+    def test_is_valid_type_bool(self):
+        """Test that 'bool' is valid."""
+        assert is_valid_type("bool") is True
+
+    def test_is_valid_type_float(self):
+        """Test that 'float' is valid."""
+        assert is_valid_type("float") is True
+
+    def test_is_valid_type_invalid(self):
+        """Test that invalid type returns False."""
+        assert is_valid_type("InvalidType") is False
+        assert is_valid_type("list") is False  # Not registered
+        assert is_valid_type("dict") is False  # Not registered
+
+    def test_is_valid_type_empty_string(self):
+        """Test that empty string is invalid."""
+        assert is_valid_type("") is False
+
+
+class TestRegisterType:
+    """Test register_type() function."""
+
+    def test_register_type_custom(self):
+        """Test registering a custom type."""
+        from pathlib import Path
+
+        # Clean up if already registered (from previous test run)
+        if "path" in TYPE_REGISTRY:
+            del TYPE_REGISTRY["path"]
+
+        register_type("path", Path)
+
+        # Verify it's registered
+        assert is_valid_type("path")
+        assert get_type("path") is Path
+
+        # Clean up
+        del TYPE_REGISTRY["path"]
+
+    def test_register_type_duplicate_raises(self):
+        """Test that registering duplicate type raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            register_type("str", str)  # str is already registered
+
+        error_msg = str(exc_info.value)
+        assert "str" in error_msg
+        assert "already registered" in error_msg
+
+    def test_register_type_persists(self):
+        """Test that registered type persists."""
+        # Clean up if exists
+        if "custom_type" in TYPE_REGISTRY:
+            del TYPE_REGISTRY["custom_type"]
+
+        class CustomType:
+            pass
+
+        register_type("custom_type", CustomType)
+
+        # Verify persistence
+        assert is_valid_type("custom_type")
+        assert get_type("custom_type") is CustomType
+
+        # Clean up
+        del TYPE_REGISTRY["custom_type"]
+
+
+class TestTypeRegistrySecurity:
+    """Test security aspects of TYPE_REGISTRY."""
+
+    def test_type_registry_does_not_use_eval(self):
+        """Test that get_type() does not use eval().
+
+        This is a critical security test ensuring we don't execute
+        arbitrary code via eval().
+        """
+        # Attempt to inject code via type name
+        malicious_input = "__import__('os').system('echo pwned')"
+
+        with pytest.raises(ValueError):
+            get_type(malicious_input)
+
+        # Verify the malicious code was not executed (would not be in registry)
+        assert malicious_input not in TYPE_REGISTRY
+
+    def test_type_registry_only_allows_registered_types(self):
+        """Test that only explicitly registered types are allowed."""
+        # These types exist in Python but are not in our registry
+        unsafe_types = ["list", "dict", "tuple", "set", "object", "type"]
+
+        for unsafe_type in unsafe_types:
+            assert not is_valid_type(unsafe_type), (
+                f"Type '{unsafe_type}' should not be valid"
+            )
+
+            with pytest.raises(ValueError):
+                get_type(unsafe_type)
+
+
+class TestTypeRegistryDefaults:
+    """Test default registered types."""
+
+    def test_type_registry_has_expected_defaults(self):
+        """Test that TYPE_REGISTRY has all expected default types."""
+        expected_types = {"str", "int", "bool", "float"}
+        actual_types = set(TYPE_REGISTRY.keys())
+
+        # Check that at least the expected types are present
+        # (there might be more if custom types were registered)
+        assert expected_types.issubset(actual_types), (
+            f"Missing expected types: {expected_types - actual_types}"
+        )
+
+    def test_type_registry_str_maps_to_str_class(self):
+        """Test that 'str' maps to actual str class."""
+        assert TYPE_REGISTRY["str"] is str
+
+    def test_type_registry_int_maps_to_int_class(self):
+        """Test that 'int' maps to actual int class."""
+        assert TYPE_REGISTRY["int"] is int
+
+    def test_type_registry_bool_maps_to_bool_class(self):
+        """Test that 'bool' maps to actual bool class."""
+        assert TYPE_REGISTRY["bool"] is bool
+
+    def test_type_registry_float_maps_to_float_class(self):
+        """Test that 'float' maps to actual float class."""
+        assert TYPE_REGISTRY["float"] is float
diff --git a/packages/uipath/tests/cli/unit/test_validators.py b/packages/uipath/tests/cli/unit/test_validators.py
new file mode 100644
index 000000000..0a9e73211
--- /dev/null
+++ b/packages/uipath/tests/cli/unit/test_validators.py
@@ -0,0 +1,419 @@
+"""Unit tests for CLI validators.
+
+Tests validation functions for folder paths, UUIDs, resource names,
+and mutual exclusion constraints.
+"""
+
+import click
+import pytest
+
+from uipath._cli._utils._validators import (
+    validate_folder_path,
+    validate_mutually_exclusive,
+    validate_resource_name,
+    validate_uuid,
+)
+
+
+class TestValidateFolderPath:
+    """Tests for validate_folder_path function."""
+
+    def test_validate_folder_path_valid_simple(self):
+        """Test validation of a simple valid folder path."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        result = validate_folder_path(ctx, param, "Shared")
+
+        assert result == "Shared"
+
+    def test_validate_folder_path_valid_nested(self):
+        """Test validation of nested folder path."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        result = validate_folder_path(ctx, param, "Shared/Production/MyFolder")
+
+        assert result == "Shared/Production/MyFolder"
+
+    def test_validate_folder_path_none(self):
+        """Test validation with None value."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        result = validate_folder_path(ctx, param, None)
+
+        assert result is None
+
+    def test_validate_folder_path_empty_string(self):
+        """Test validation with empty string (should be allowed)."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        result = validate_folder_path(ctx, param, "")
+
+        assert result == ""
+
+    def test_validate_folder_path_invalid_leading_slash(self):
+        """Test validation fails with leading slash."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_folder_path(ctx, param, "/Shared")
+
+        assert "should not start or end with '/'" in str(exc_info.value)
+
+    def test_validate_folder_path_invalid_trailing_slash(self):
+        """Test validation fails with trailing slash."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_folder_path(ctx, param, "Shared/")
+
+        assert "should not start or end with '/'" in str(exc_info.value)
+
+    def test_validate_folder_path_invalid_both_slashes(self):
+        """Test validation fails with both leading and trailing slashes."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--folder-path"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_folder_path(ctx, param, "/Shared/Production/")
+
+        assert "should not start or end with '/'" in str(exc_info.value)
+
+
+class TestValidateUuid:
+    """Tests for validate_uuid function."""
+
+    def test_validate_uuid_valid_lowercase(self):
+        """Test validation of valid UUID in lowercase."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        result = validate_uuid(ctx, param, "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6")
+
+        assert result == "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
+
+    def test_validate_uuid_valid_uppercase(self):
+        """Test validation of valid UUID in uppercase."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        result = validate_uuid(ctx, param, "A1B2C3D4-E5F6-47A8-B9C0-D1E2F3A4B5C6")
+
+        assert result == "A1B2C3D4-E5F6-47A8-B9C0-D1E2F3A4B5C6"
+
+    def test_validate_uuid_valid_mixed_case(self):
+        """Test validation of valid UUID in mixed case."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        result = validate_uuid(ctx, param, "A1b2C3d4-E5f6-47a8-B9c0-D1e2F3a4B5c6")
+
+        assert result == "A1b2C3d4-E5f6-47a8-B9c0-D1e2F3a4B5c6"
+
+    def test_validate_uuid_none(self):
+        """Test validation with None value."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        result = validate_uuid(ctx, param, None)
+
+        assert result is None
+
+    def test_validate_uuid_invalid_format_no_hyphens(self):
+        """Test validation fails with UUID without hyphens."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "a1b2c3d4e5f647a8b9c0d1e2f3a4b5c6")
+
+        assert "not a valid UUID" in str(exc_info.value)
+        assert "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" in str(exc_info.value)
+
+    def test_validate_uuid_invalid_format_wrong_positions(self):
+        """Test validation fails with hyphens in wrong positions."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "a1b2-c3d4e5f6-47a8-b9c0-d1e2f3a4b5c6")
+
+        assert "not a valid UUID" in str(exc_info.value)
+
+    def test_validate_uuid_invalid_too_short(self):
+        """Test validation fails with too short UUID."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "a1b2c3d4-e5f6-47a8-b9c0")
+
+        assert "not a valid UUID" in str(exc_info.value)
+
+    def test_validate_uuid_invalid_too_long(self):
+        """Test validation fails with too long UUID."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6-extra")
+
+        assert "not a valid UUID" in str(exc_info.value)
+
+    def test_validate_uuid_invalid_non_hex_characters(self):
+        """Test validation fails with non-hex characters."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "g1h2i3j4-k5l6-m7n8-o9p0-q1r2s3t4u5v6")
+
+        assert "not a valid UUID" in str(exc_info.value)
+
+    def test_validate_uuid_invalid_empty_string(self):
+        """Test validation fails with empty string."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--key"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_uuid(ctx, param, "")
+
+        assert "not a valid UUID" in str(exc_info.value)
+
+
+class TestValidateResourceName:
+    """Tests for validate_resource_name function."""
+
+    def test_validate_resource_name_valid_simple(self):
+        """Test validation of simple valid resource name."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        result = validate_resource_name(ctx, param, "my-bucket")
+
+        assert result == "my-bucket"
+
+    def test_validate_resource_name_valid_with_spaces(self):
+        """Test validation of resource name with spaces."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        result = validate_resource_name(ctx, param, "My Bucket Name")
+
+        assert result == "My Bucket Name"
+
+    def test_validate_resource_name_valid_with_underscores(self):
+        """Test validation of resource name with underscores."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        result = validate_resource_name(ctx, param, "my_bucket_name")
+
+        assert result == "my_bucket_name"
+
+    def test_validate_resource_name_valid_with_numbers(self):
+        """Test validation of resource name with numbers."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        result = validate_resource_name(ctx, param, "bucket123")
+
+        assert result == "bucket123"
+
+    def test_validate_resource_name_none(self):
+        """Test validation with None value."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        result = validate_resource_name(ctx, param, None)
+
+        assert result is None
+
+    def test_validate_resource_name_invalid_empty(self):
+        """Test validation fails with empty string."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "")
+
+        assert "cannot be empty" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_whitespace_only(self):
+        """Test validation fails with whitespace only."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "   ")
+
+        assert "cannot be empty" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_less_than(self):
+        """Test validation fails with < character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket<name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert "<" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_greater_than(self):
+        """Test validation fails with > character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket>name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert ">" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_colon(self):
+        """Test validation fails with : character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket:name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert ":" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_quote(self):
+        """Test validation fails with \" character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, 'bucket"name')
+
+        assert "invalid character" in str(exc_info.value)
+        assert '"' in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_pipe(self):
+        """Test validation fails with | character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket|name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert "|" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_question_mark(self):
+        """Test validation fails with ? character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket?name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert "?" in str(exc_info.value)
+
+    def test_validate_resource_name_invalid_asterisk(self):
+        """Test validation fails with * character."""
+        ctx = click.Context(click.Command("test"))
+        param = click.Option(["--name"])
+
+        with pytest.raises(click.BadParameter) as exc_info:
+            validate_resource_name(ctx, param, "bucket*name")
+
+        assert "invalid character" in str(exc_info.value)
+        assert "*" in str(exc_info.value)
+
+
+class TestValidateMutuallyExclusive:
+    """Tests for validate_mutually_exclusive function."""
+
+    def test_validate_mutually_exclusive_both_none(self):
+        """Test validation passes when both parameters are None."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": None}
+        param = click.Option(["--param"])
+
+        result = validate_mutually_exclusive(ctx, param, None, "other_param")
+
+        assert result is None
+
+    def test_validate_mutually_exclusive_first_set(self):
+        """Test validation passes when only first parameter is set."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": None}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        result = validate_mutually_exclusive(ctx, param, "value1", "other_param")
+
+        assert result == "value1"
+
+    def test_validate_mutually_exclusive_second_set(self):
+        """Test validation passes when only second parameter is set."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": "value2"}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        result = validate_mutually_exclusive(ctx, param, None, "other_param")
+
+        assert result is None
+
+    def test_validate_mutually_exclusive_both_set_raises_error(self):
+        """Test validation fails when both parameters are set."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": "value2"}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        with pytest.raises(click.UsageError) as exc_info:
+            validate_mutually_exclusive(ctx, param, "value1", "other_param")
+
+        assert "mutually exclusive" in str(exc_info.value)
+        assert "param" in str(exc_info.value)
+        assert "other_param" in str(exc_info.value)
+        assert "Provide only one" in str(exc_info.value)
+
+    def test_validate_mutually_exclusive_with_empty_strings(self):
+        """Test validation with empty strings (treated as set)."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": ""}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        with pytest.raises(click.UsageError) as exc_info:
+            validate_mutually_exclusive(ctx, param, "", "other_param")
+
+        assert "mutually exclusive" in str(exc_info.value)
+
+    def test_validate_mutually_exclusive_with_zero(self):
+        """Test validation with zero value (treated as set)."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": 0}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        with pytest.raises(click.UsageError) as exc_info:
+            validate_mutually_exclusive(ctx, param, 0, "other_param")
+
+        assert "mutually exclusive" in str(exc_info.value)
+
+    def test_validate_mutually_exclusive_with_false(self):
+        """Test validation with False value (treated as set)."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"other_param": False}
+        param = click.Option(["--param"])
+        param.name = "param"
+
+        with pytest.raises(click.UsageError) as exc_info:
+            validate_mutually_exclusive(ctx, param, False, "other_param")
+
+        assert "mutually exclusive" in str(exc_info.value)
diff --git a/packages/uipath/tests/cli/utils/common.py b/packages/uipath/tests/cli/utils/common.py
new file mode 100644
index 000000000..b9b184fb0
--- /dev/null
+++ b/packages/uipath/tests/cli/utils/common.py
@@ -0,0 +1,6 @@
+import os
+
+
+def configure_env_vars(env_vars: dict[str, str]):
+    os.environ.clear()
+    os.environ.update(env_vars)
diff --git a/tests/cli/utils/project_details.py b/packages/uipath/tests/cli/utils/project_details.py
similarity index 67%
rename from tests/cli/utils/project_details.py
rename to packages/uipath/tests/cli/utils/project_details.py
index 7d9d29c63..457ac1a74 100644
--- a/tests/cli/utils/project_details.py
+++ b/packages/uipath/tests/cli/utils/project_details.py
@@ -1,4 +1,6 @@
-import toml
+import tomllib
+
+import tomli_w
 
 
 class ProjectDetails:
@@ -20,7 +22,7 @@ def __init__(
 
     @classmethod
     def from_toml(cls, toml_str):
-        data = toml.loads(toml_str)
+        data = tomllib.loads(toml_str)
         project_data = data.get("project")
         if project_data:
             name = project_data.get("name")
@@ -35,15 +37,19 @@ def from_toml(cls, toml_str):
         else:
             return None
 
-    def to_toml(self):
+    def to_toml(self) -> str:
         data = {
             "project": {
-                "name": self.name,
-                "version": self.version,
-                "description": self.description,
-                "authors": self.authors,
-                "dependencies": self.dependencies,
-                "requires-python": self.requires_python,
+                k: v
+                for k, v in {
+                    "name": self.name,
+                    "version": self.version,
+                    "description": self.description,
+                    "authors": self.authors,
+                    "dependencies": self.dependencies,
+                    "requires-python": self.requires_python,
+                }.items()
+                if v is not None
             }
         }
-        return toml.dumps(data)
+        return tomli_w.dumps(data)
diff --git a/tests/conftest.py b/packages/uipath/tests/conftest.py
similarity index 70%
rename from tests/conftest.py
rename to packages/uipath/tests/conftest.py
index cba9b6464..2118672a9 100644
--- a/tests/conftest.py
+++ b/packages/uipath/tests/conftest.py
@@ -1,11 +1,19 @@
 import os
+import sys
 import tempfile
+from pathlib import Path
 from typing import Generator
 
 import pytest
 from click.testing import CliRunner
 
-from uipath._execution_context import ExecutionContext
+from uipath.platform import UiPathExecutionContext
+
+# Ensure local source package (src/uipath) is importable before tests collect
+_PROJECT_ROOT: Path = Path(__file__).resolve().parents[1]
+_SRC_PATH: Path = _PROJECT_ROOT / "src"
+if _SRC_PATH.exists():
+    sys.path.insert(0, str(_SRC_PATH))
 
 
 @pytest.fixture
@@ -29,10 +37,10 @@ def clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
 
 
 @pytest.fixture
-def execution_context(monkeypatch: pytest.MonkeyPatch) -> ExecutionContext:
+def execution_context(monkeypatch: pytest.MonkeyPatch) -> UiPathExecutionContext:
     """Provide an execution context for testing."""
     monkeypatch.setenv("UIPATH_ROBOT_KEY", "test-robot-key")
-    return ExecutionContext()
+    return UiPathExecutionContext()
 
 
 @pytest.fixture
diff --git a/packages/uipath/tests/evaluators/__init__.py b/packages/uipath/tests/evaluators/__init__.py
new file mode 100644
index 000000000..20e9710bd
--- /dev/null
+++ b/packages/uipath/tests/evaluators/__init__.py
@@ -0,0 +1 @@
+"""Test package for evaluator functionality."""
diff --git a/packages/uipath/tests/evaluators/test_attachment_utils.py b/packages/uipath/tests/evaluators/test_attachment_utils.py
new file mode 100644
index 000000000..0732d167d
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_attachment_utils.py
@@ -0,0 +1,241 @@
+"""Tests for attachment utility functions."""
+
+import uuid
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath.eval.evaluators.attachment_utils import (
+    download_attachment_as_string,
+    extract_attachment_id,
+    is_job_attachment_uri,
+)
+from uipath.eval.models.models import UiPathEvaluationError
+
+
+class TestIsJobAttachmentUri:
+    """Tests for is_job_attachment_uri function."""
+
+    def test_valid_attachment_uri_lowercase(self):
+        """Test with valid attachment URI in lowercase."""
+        uri = "urn:uipath:cas:file:orchestrator:123e4567-e89b-12d3-a456-426614174000"
+        assert is_job_attachment_uri(uri) is True
+
+    def test_valid_attachment_uri_uppercase(self):
+        """Test with valid attachment URI in uppercase."""
+        uri = "urn:uipath:cas:file:orchestrator:123E4567-E89B-12D3-A456-426614174000"
+        assert is_job_attachment_uri(uri) is True
+
+    def test_valid_attachment_uri_mixed_case(self):
+        """Test with valid attachment URI in mixed case."""
+        uri = "URN:UIPATH:CAS:FILE:ORCHESTRATOR:123e4567-E89B-12d3-A456-426614174000"
+        assert is_job_attachment_uri(uri) is True
+
+    def test_invalid_uri_wrong_prefix(self):
+        """Test with wrong URI prefix."""
+        uri = "urn:uipath:cas:file:other:123e4567-e89b-12d3-a456-426614174000"
+        assert is_job_attachment_uri(uri) is False
+
+    def test_invalid_uri_malformed_uuid(self):
+        """Test with malformed UUID."""
+        uri = "urn:uipath:cas:file:orchestrator:not-a-uuid"
+        assert is_job_attachment_uri(uri) is False
+
+    def test_invalid_uri_missing_parts(self):
+        """Test with missing URI parts."""
+        uri = "urn:uipath:cas:file:123e4567-e89b-12d3-a456-426614174000"
+        assert is_job_attachment_uri(uri) is False
+
+    def test_non_string_value_dict(self):
+        """Test with non-string value (dict)."""
+        assert is_job_attachment_uri({"key": "value"}) is False
+
+    def test_non_string_value_int(self):
+        """Test with non-string value (int)."""
+        assert is_job_attachment_uri(123) is False
+
+    def test_non_string_value_none(self):
+        """Test with None value."""
+        assert is_job_attachment_uri(None) is False
+
+    def test_empty_string(self):
+        """Test with empty string."""
+        assert is_job_attachment_uri("") is False
+
+    def test_regular_file_path(self):
+        """Test with regular file path."""
+        assert is_job_attachment_uri("/path/to/file.txt") is False
+
+
+class TestExtractAttachmentId:
+    """Tests for extract_attachment_id function."""
+
+    def test_extract_valid_uuid_lowercase(self):
+        """Test extracting UUID from valid URI (lowercase)."""
+        uri = "urn:uipath:cas:file:orchestrator:123e4567-e89b-12d3-a456-426614174000"
+        result = extract_attachment_id(uri)
+        assert result == "123e4567-e89b-12d3-a456-426614174000"
+
+    def test_extract_valid_uuid_uppercase(self):
+        """Test extracting UUID from valid URI (uppercase)."""
+        uri = "urn:uipath:cas:file:orchestrator:123E4567-E89B-12D3-A456-426614174000"
+        result = extract_attachment_id(uri)
+        assert result == "123E4567-E89B-12D3-A456-426614174000"
+
+    def test_extract_valid_uuid_mixed_case(self):
+        """Test extracting UUID from valid URI (mixed case)."""
+        uri = "URN:UIPATH:CAS:FILE:ORCHESTRATOR:aB3e4567-E89B-12d3-A456-426614174000"
+        result = extract_attachment_id(uri)
+        assert result == "aB3e4567-E89B-12d3-A456-426614174000"
+
+    def test_invalid_uri_raises_error(self):
+        """Test that invalid URI raises ValueError."""
+        uri = "urn:uipath:cas:file:other:123e4567-e89b-12d3-a456-426614174000"
+        with pytest.raises(ValueError, match="Invalid job attachment URI"):
+            extract_attachment_id(uri)
+
+    def test_malformed_uuid_raises_error(self):
+        """Test that malformed UUID raises ValueError."""
+        uri = "urn:uipath:cas:file:orchestrator:not-a-uuid"
+        with pytest.raises(ValueError, match="Invalid job attachment URI"):
+            extract_attachment_id(uri)
+
+    def test_empty_string_raises_error(self):
+        """Test that empty string raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid job attachment URI"):
+            extract_attachment_id("")
+
+
+class TestDownloadAttachmentAsString:
+    """Tests for download_attachment_as_string function."""
+
+    def test_successful_download(self):
+        """Test successful attachment download."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+        expected_content = "This is the attachment content"
+
+        # Create a mock UiPath client
+        mock_client = MagicMock()
+        mock_attachments = MagicMock()
+        mock_client.attachments = mock_attachments
+
+        # Mock the download method to write content to the temp file
+        def mock_download(key, destination_path):
+            with open(destination_path, "w", encoding="utf-8") as f:
+                f.write(expected_content)
+
+        mock_attachments.download.side_effect = mock_download
+
+        with patch("uipath.platform.UiPath", return_value=mock_client):
+            result = download_attachment_as_string(attachment_id)
+
+        assert result == expected_content
+        mock_attachments.download.assert_called_once()
+
+        # Verify UUID was passed correctly
+        call_args = mock_attachments.download.call_args
+        assert call_args.kwargs["key"] == uuid.UUID(attachment_id)
+        assert "destination_path" in call_args.kwargs
+
+    def test_download_with_multiline_content(self):
+        """Test downloading attachment with multiline content."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+        expected_content = "Line 1\nLine 2\nLine 3"
+
+        mock_client = MagicMock()
+        mock_attachments = MagicMock()
+        mock_client.attachments = mock_attachments
+
+        def mock_download(key, destination_path):
+            with open(destination_path, "w", encoding="utf-8") as f:
+                f.write(expected_content)
+
+        mock_attachments.download.side_effect = mock_download
+
+        with patch("uipath.platform.UiPath", return_value=mock_client):
+            result = download_attachment_as_string(attachment_id)
+
+        assert result == expected_content
+        assert "\n" in result
+        assert result.count("\n") == 2
+
+    def test_download_failure_raises_evaluation_error(self):
+        """Test that download failure raises UiPathEvaluationError."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+
+        mock_client = MagicMock()
+        mock_attachments = MagicMock()
+        mock_client.attachments = mock_attachments
+        mock_attachments.download.side_effect = Exception("Network error")
+
+        with patch("uipath.platform.UiPath", return_value=mock_client):
+            with pytest.raises(UiPathEvaluationError) as exc_info:
+                download_attachment_as_string(attachment_id)
+
+        assert exc_info.value.error_info.code == "Python.ATTACHMENT_DOWNLOAD_FAILED"
+        assert "Failed to download job attachment" in exc_info.value.error_info.title
+        assert "Network error" in exc_info.value.error_info.detail
+
+    def test_temp_file_cleanup_on_success(self):
+        """Test that temporary file is cleaned up after successful download."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+        temp_files_created = []
+
+        mock_client = MagicMock()
+        mock_attachments = MagicMock()
+        mock_client.attachments = mock_attachments
+
+        def mock_download(key, destination_path):
+            temp_files_created.append(destination_path)
+            with open(destination_path, "w", encoding="utf-8") as f:
+                f.write("content")
+
+        mock_attachments.download.side_effect = mock_download
+
+        with patch("uipath.platform.UiPath", return_value=mock_client):
+            download_attachment_as_string(attachment_id)
+
+        # Verify temp file was cleaned up
+        assert len(temp_files_created) == 1
+        assert not Path(temp_files_created[0]).exists()
+
+    def test_temp_file_cleanup_on_failure(self):
+        """Test that temporary file is cleaned up even on failure."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+        temp_files_created = []
+
+        mock_client = MagicMock()
+        mock_attachments = MagicMock()
+        mock_client.attachments = mock_attachments
+
+        def mock_download(key, destination_path):
+            temp_files_created.append(destination_path)
+            # Create the file but then raise an error
+            with open(destination_path, "w", encoding="utf-8") as f:
+                f.write("partial content")
+            raise Exception("Download failed midway")
+
+        mock_attachments.download.side_effect = mock_download
+
+        with patch("uipath.platform.UiPath", return_value=mock_client):
+            with pytest.raises(UiPathEvaluationError):
+                download_attachment_as_string(attachment_id)
+
+        # Verify temp file was cleaned up
+        assert len(temp_files_created) == 1
+        assert not Path(temp_files_created[0]).exists()
+
+    def test_uipath_client_import_error(self):
+        """Test handling when UiPath client cannot be imported."""
+        attachment_id = "123e4567-e89b-12d3-a456-426614174000"
+
+        with patch(
+            "uipath.platform.UiPath",
+            side_effect=ImportError("Module not found"),
+        ):
+            with pytest.raises(UiPathEvaluationError) as exc_info:
+                download_attachment_as_string(attachment_id)
+
+        assert exc_info.value.error_info.code == "Python.ATTACHMENT_DOWNLOAD_FAILED"
+        assert "Module not found" in exc_info.value.error_info.detail
diff --git a/packages/uipath/tests/evaluators/test_documentation_examples.py b/packages/uipath/tests/evaluators/test_documentation_examples.py
new file mode 100644
index 000000000..559df3a01
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_documentation_examples.py
@@ -0,0 +1,2315 @@
+"""Tests for examples in the eval documentation.
+
+This module ensures all code examples in the documentation actually work by
+testing them with proper agent execution data. For LLM judge examples, we use
+mocked completions to avoid API calls.
+"""
+
+from typing import Any
+
+import pytest
+from pydantic import TypeAdapter
+from pytest_mock.plugin import MockerFixture
+
+from uipath.eval.evaluators import (
+    ContainsEvaluator,
+    ExactMatchEvaluator,
+    JsonSimilarityEvaluator,
+    LLMJudgeOutputEvaluator,
+    LLMJudgeStrictJSONSimilarityOutputEvaluator,
+    LLMJudgeTrajectoryEvaluator,
+    LLMJudgeTrajectorySimulationEvaluator,
+    ToolCallArgsEvaluator,
+    ToolCallCountEvaluator,
+    ToolCallOrderEvaluator,
+    ToolCallOutputEvaluator,
+)
+from uipath.eval.evaluators.json_similarity_evaluator import (
+    JsonSimilarityJustification,
+)
+from uipath.eval.evaluators.tool_call_order_evaluator import (
+    ToolCallOrderEvaluatorJustification,
+)
+from uipath.eval.models import AgentExecution
+
+
+class TestIndexExamples:
+    """Test examples from docs/eval/index.md."""
+
+    @pytest.mark.asyncio
+    async def test_getting_started_example(self) -> None:
+        """Test the getting started example from index.md."""
+        # Sample agent execution (this is what the docs were missing!)
+        agent_execution = AgentExecution(
+            agent_input={"query": "Greet the world"},
+            agent_output={"result": "hello, world!"},
+            agent_trace=[],
+        )
+
+        # Create evaluator
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-1",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "case_sensitive": False,
+                    "target_output_key": "result",
+                },
+            )
+        )
+
+        # Evaluate
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"result": "Hello, World!"}},
+        )
+
+        assert result.score == 1.0
+
+
+class TestContainsExamples:
+    """Test examples from docs/eval/contains.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_usage(self) -> None:
+        """Test basic usage example."""
+        # Create evaluator - extracts "response" field for comparison
+        evaluator = TypeAdapter(ContainsEvaluator).validate_python(
+            dict(
+                id="contains-check",
+                evaluatorConfig={
+                    "name": "ContainsEvaluator",
+                    "case_sensitive": False,
+                    "target_output_key": "response",  # Extract the "response" field
+                },
+            )
+        )
+
+        # agent_output must be a dict
+        agent_execution = AgentExecution(
+            agent_input={"query": "What is the capital of France?"},
+            agent_output={"response": "The capital of France is Paris."},
+            agent_trace=[],
+        )
+
+        # Evaluate - searches in the "response" field value
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"search_text": "Paris"},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_case_sensitive_search(self) -> None:
+        """Test case-sensitive search example."""
+        evaluator = TypeAdapter(ContainsEvaluator).validate_python(
+            dict(
+                id="contains-case-sensitive",
+                evaluatorConfig={
+                    "name": "ContainsEvaluator",
+                    "case_sensitive": True,
+                    "target_output_key": "message",  # Extract the "message" field
+                },
+            )
+        )
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"message": "Hello World"},
+            agent_trace=[],
+        )
+
+        # This will fail because of case mismatch
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"search_text": "hello"},
+        )
+
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_negated_search(self) -> None:
+        """Test negated search example."""
+        evaluator = TypeAdapter(ContainsEvaluator).validate_python(
+            dict(
+                id="contains-negated",
+                evaluatorConfig={
+                    "name": "ContainsEvaluator",
+                    "negated": True,
+                    "target_output_key": "status",  # Extract the "status" field
+                },
+            )
+        )
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "Success: Operation completed"},
+            agent_trace=[],
+        )
+
+        # Passes because "error" is NOT found
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"search_text": "error"},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_target_specific_output_field(self) -> None:
+        """Test targeting specific output field example."""
+        evaluator = TypeAdapter(ContainsEvaluator).validate_python(
+            dict(
+                id="contains-targeted",
+                evaluatorConfig={
+                    "name": "ContainsEvaluator",
+                    "target_output_key": "message",
+                },
+            )
+        )
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "status": "success",
+                "message": "User profile updated successfully",
+            },
+            agent_trace=[],
+        )
+
+        # Only searches within the "message" field
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"search_text": "updated"},
+        )
+
+        assert result.score == 1.0
+
+
+class TestExactMatchExamples:
+    """Test examples from docs/eval/exact_match.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_usage(self) -> None:
+        """Test basic usage example."""
+        # agent_output must be a dict
+        agent_execution = AgentExecution(
+            agent_input={"query": "What is 2+2?"},
+            agent_output={"result": "4"},
+            agent_trace=[],
+        )
+
+        # Create evaluator - extracts "result" field for comparison
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-1",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "case_sensitive": False,
+                    "target_output_key": "result",  # Extract the "result" field
+                },
+            )
+        )
+
+        # Evaluate - compares just the "result" field value
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"result": "4"}},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_case_sensitive_matching(self) -> None:
+        """Test case-sensitive matching example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "SUCCESS"},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-case",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "case_sensitive": True,
+                    "target_output_key": "status",  # Extract the "status" field
+                },
+            )
+        )
+
+        # Fails due to case mismatch
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"status": "success"}},
+        )
+
+        assert result.score == 0.0
+
+        # This would pass
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"status": "SUCCESS"}},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_matching_structured_outputs(self) -> None:
+        """Test matching structured outputs example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "success", "code": 200},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-dict",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "target_output_key": "*",  # Compare entire output (default)
+                },
+            )
+        )
+
+        # Entire dict structure must match
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"status": "success", "code": 200}},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_negated_mode(self) -> None:
+        """Test negated mode example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"result": "error"},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-negated",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "negated": True,
+                    "target_output_key": "result",  # Extract the "result" field
+                },
+            )
+        )
+
+        # Passes because outputs do NOT match
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"result": "success"}},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_using_default_criteria(self) -> None:
+        """Test using default criteria example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "OK"},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="exact-match-default",
+                evaluatorConfig={
+                    "name": "ExactMatchEvaluator",
+                    "target_output_key": "status",  # Extract the "status" field
+                    "default_evaluation_criteria": {
+                        "expected_output": {"status": "OK"}
+                    },
+                },
+            )
+        )
+
+        # Use default criteria
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution, evaluation_criteria=None
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_list_target_output_key(self) -> None:
+        """Test evaluating multiple output fields at once using a list of keys.
+
+        Mirrors the multi-output-agent sample (list-keys-exact-match evaluator).
+        """
+        # Agent returns a rich nested output; we only care about two summary fields.
+        agent_execution = AgentExecution(
+            agent_input={"customer_name": "John Doe", "items": []},
+            agent_output={
+                "order_id": "ORD-001",
+                "summary": {"status": "completed", "total": 44.97, "item_count": 3},
+                "tags": ["priority", "express"],
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(ExactMatchEvaluator).validate_python(
+            dict(
+                id="list-keys-exact-match",
+                evaluatorConfig={
+                    "name": "ListKeysExactMatch",
+                    # Pass a list to assert multiple fields in a single evaluator run.
+                    "target_output_key": ["summary.status", "summary.total"],
+                },
+            )
+        )
+
+        # Both keys match → score 1.0
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"summary": {"status": "completed", "total": 44.97}}
+            },
+        )
+        assert result.score == 1.0
+
+        # One key differs → score 0.0
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"summary": {"status": "completed", "total": 999.0}}
+            },
+        )
+        assert result.score == 0.0
+
+
+class TestJsonSimilarityExamples:
+    """Test examples from docs/eval/json_similarity.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_json_comparison(self) -> None:
+        """Test basic JSON comparison example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"name": "John Doe", "age": 30, "city": "New York"},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-1",
+                evaluatorConfig={
+                    "name": "JsonSimilarityEvaluator"
+                    # target_output_key defaults to "*" - compares entire output dict
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"name": "John Doe", "age": 30, "city": "New York"}
+            },
+        )
+
+        assert result.score == 1.0
+
+        assert isinstance(result.details, JsonSimilarityJustification)
+        assert result.details.matched_leaves == 3.0
+        assert result.details.total_leaves == 3.0
+
+    @pytest.mark.asyncio
+    async def test_numeric_tolerance(self) -> None:
+        """Test numeric tolerance example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"temperature": 20.5, "humidity": 65},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-numeric",
+                evaluatorConfig={"name": "JsonSimilarityEvaluator"},
+            )
+        )
+
+        # Slightly different numbers
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"temperature": 20.3, "humidity": 65}
+            },
+        )
+
+        # High similarity despite numeric difference
+        assert result.score >= 0.9
+
+    @pytest.mark.asyncio
+    async def test_string_similarity(self) -> None:
+        """Test string similarity example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "completed successfully"},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-string",
+                evaluatorConfig={"name": "JsonSimilarityEvaluator"},
+            )
+        )
+
+        # Similar but not exact string
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"status": "completed sucessfully"}  # typo
+            },
+        )
+
+        # High but not perfect similarity
+        assert result.score >= 0.9
+        assert result.score < 1.0
+
+    @pytest.mark.asyncio
+    async def test_nested_structures(self) -> None:
+        """Test nested structures example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "user": {"name": "Alice", "profile": {"age": 25, "location": "Paris"}},
+                "status": "active",
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-nested",
+                evaluatorConfig={"name": "JsonSimilarityEvaluator"},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {
+                    "user": {
+                        "name": "Alice",
+                        "profile": {"age": 25, "location": "Paris"},
+                    },
+                    "status": "active",
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_array_comparison(self) -> None:
+        """Test array comparison example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={"items": ["apple", "banana", "orange"]},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-array",
+                evaluatorConfig={"name": "JsonSimilarityEvaluator"},
+            )
+        )
+
+        # Partial match (2 out of 3 correct)
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"items": ["apple", "banana", "grape"]}
+            },
+        )
+
+        # The actual implementation gives partial credit for string similarity
+        # "orange" vs "grape" has some similarity, so score is higher than simple 2/3
+        assert 0.75 <= result.score <= 0.85
+
+    @pytest.mark.asyncio
+    async def test_handling_extra_keys(self) -> None:
+        """Test handling extra keys in actual output example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "name": "Bob",
+                "age": 30,
+                "extra_field": "ignored",  # Extra field in actual output
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-extra",
+                evaluatorConfig={"name": "JsonSimilarityEvaluator"},
+            )
+        )
+
+        # Only expected keys are evaluated
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"expected_output": {"name": "Bob", "age": 30}},
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_target_specific_field(self) -> None:
+        """Test target specific field example."""
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "result": {"score": 95, "passed": True},
+                "metadata": {"timestamp": "2024-01-01"},
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(JsonSimilarityEvaluator).validate_python(
+            dict(
+                id="json-sim-targeted",
+                evaluatorConfig={
+                    "name": "JsonSimilarityEvaluator",
+                    "target_output_key": "result",
+                },
+            )
+        )
+
+        # Only compares the "result" field
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"result": {"score": 95, "passed": True}}
+            },
+        )
+
+        assert result.score == 1.0
+
+
+class TestLLMJudgeOutputExamples:
+    """Test examples from docs/eval/llm_judge_output.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_semantic_similarity(self, mocker: MockerFixture) -> None:
+        """Test basic semantic similarity example."""
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 95,
+            "justification": "Both outputs convey the same meaning about Paris being the capital of France.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={"query": "What is the capital of France?"},
+            agent_output={"answer": "Paris is the capital city of France."},
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(LLMJudgeOutputEvaluator).validate_python(
+            dict(
+                id="llm-judge-1",
+                evaluatorConfig={
+                    "name": "LLMJudgeOutputEvaluator",
+                    "model": "gpt-4",
+                    "temperature": 0.0,
+                    "target_output_key": "answer",  # Extract the "answer" field
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"answer": "The capital of France is Paris."}
+            },
+        )
+
+        assert result.score == 0.95
+
+    @pytest.mark.asyncio
+    async def test_custom_evaluation_prompt(self, mocker: MockerFixture) -> None:
+        """Test custom evaluation prompt example."""
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_2"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 90,
+            "justification": "Both messages convey successful cart addition.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        custom_prompt = """
+Compare the actual output with the expected output.
+Focus on semantic meaning and intent rather than exact wording.
+
+Actual Output: {{ActualOutput}}
+Expected Output: {{ExpectedOutput}}
+
+Provide a score from 0-100 based on semantic similarity.
+"""
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "message": "The product has been successfully added to your cart."
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(LLMJudgeOutputEvaluator).validate_python(
+            dict(
+                id="llm-judge-custom",
+                evaluatorConfig={
+                    "name": "LLMJudgeOutputEvaluator",
+                    "model": "gpt-4",
+                    "prompt": custom_prompt,
+                    "temperature": 0.0,
+                    "target_output_key": "message",  # Extract the "message" field
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {"message": "Item added to shopping cart."}
+            },
+        )
+
+        assert result.score == 0.9
+
+    @pytest.mark.asyncio
+    async def test_evaluating_natural_language_quality(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test evaluating natural language quality example."""
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_3"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 85,
+            "justification": "The email is professional and addresses the customer inquiry appropriately.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Write a professional email"},
+            agent_output={
+                "email": """Dear Customer,
+
+Thank you for your inquiry. We have reviewed your request
+and are pleased to inform you that we can accommodate your
+needs. Please let us know if you have any questions.
+
+Best regards,
+Support Team"""
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(LLMJudgeOutputEvaluator).validate_python(
+            dict(
+                id="llm-judge-quality",
+                evaluatorConfig={
+                    "name": "LLMJudgeOutputEvaluator",
+                    "model": "gpt-4o",
+                    "temperature": 0.0,
+                    "target_output_key": "email",  # Extract the "email" field
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {
+                    "email": "A professional, courteous response addressing the customer's inquiry"
+                }
+            },
+        )
+
+        assert result.score == 0.85
+
+    @pytest.mark.asyncio
+    async def test_strict_json_similarity(self, mocker: MockerFixture) -> None:
+        """Test strict JSON similarity output evaluator example."""
+
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_4"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 100,
+            "justification": "All keys match perfectly.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={},
+            agent_output={
+                "status": "success",
+                "user_id": 12345,
+                "name": "John Doe",
+                "email": "john@example.com",
+            },
+            agent_trace=[],
+        )
+
+        evaluator = TypeAdapter(
+            LLMJudgeStrictJSONSimilarityOutputEvaluator
+        ).validate_python(
+            dict(
+                id="llm-json-strict",
+                evaluatorConfig={
+                    "name": "LLMJudgeStrictJSONSimilarityOutputEvaluator",
+                    "model": "gpt-4",
+                    "temperature": 0.0,
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_output": {
+                    "status": "success",
+                    "user_id": 12345,
+                    "name": "John Doe",
+                    "email": "john@example.com",
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+
+class TestLLMJudgeTrajectoryExamples:
+    """Test examples from docs/eval/llm_judge_trajectory.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_trajectory_evaluation(self, mocker: MockerFixture) -> None:
+        """Test basic trajectory evaluation example."""
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_5"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 85,
+            "justification": "Agent followed the expected booking flow.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={"user_query": "Book a flight to Paris"},
+            agent_output={"booking_id": "FL123", "status": "confirmed"},
+            agent_trace=[
+                # Trace contains spans showing the agent's execution path
+                # Each span represents a step in the agent's decision-making
+            ],
+        )
+
+        evaluator = TypeAdapter(LLMJudgeTrajectoryEvaluator).validate_python(
+            dict(
+                id="trajectory-judge-1",
+                evaluatorConfig={
+                    "name": "LLMJudgeTrajectoryEvaluator",
+                    "model": "gpt-4",
+                    "temperature": 0.0,
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_agent_behavior": """
+        The agent should:
+        1. Search for available flights to Paris
+        2. Present options to the user
+        3. Process the booking
+        4. Confirm the reservation
+        """
+            },
+        )
+
+        assert result.score == 0.85
+
+    @pytest.mark.asyncio
+    async def test_validating_tool_usage_sequence(self, mocker: MockerFixture) -> None:
+        """Test validating tool usage sequence example."""
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_6"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 90,
+            "justification": "Agent correctly validated, updated, and notified in proper sequence.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Update user profile and send notification"},
+            agent_output={"status": "completed"},
+            agent_trace=[
+                # Spans showing: validate_user -> update_profile -> send_notification
+            ],
+        )
+
+        evaluator = TypeAdapter(LLMJudgeTrajectoryEvaluator).validate_python(
+            dict(
+                id="trajectory-tools",
+                evaluatorConfig={
+                    "name": "LLMJudgeTrajectoryEvaluator",
+                    "model": "gpt-4o",
+                    "temperature": 0.0,
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_agent_behavior": """
+        The agent must:
+        1. First validate the user exists
+        2. Update the profile in the database
+        3. Send a confirmation notification
+        This sequence must be followed to ensure data integrity.
+        """
+            },
+        )
+
+        assert result.score == 0.9
+
+    @pytest.mark.asyncio
+    async def test_trajectory_simulation(self, mocker: MockerFixture) -> None:
+        """Test tool simulation trajectory evaluation example."""
+
+        # Mock the LLM response with tool_call format
+        mock_response = mocker.MagicMock()
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_7"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 88,
+            "justification": "Agent followed expected flow with simulated tool responses.",
+        }
+
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        agent_execution = AgentExecution(
+            agent_input={"query": "Book a flight to Paris for tomorrow"},
+            agent_output={"booking_id": "FL123", "status": "confirmed"},
+            agent_trace=[
+                # Execution spans showing tool calls and their simulated responses
+            ],
+            simulation_instructions="""
+    Simulate the following tool responses:
+    - search_flights tool: Return 3 available flights with prices
+    - book_flight tool: Return booking confirmation with ID "FL123"
+    - send_confirmation_email tool: Return success status
+    Mock the tools to respond as if it's a Tuesday in March with normal availability.
+    """,
+        )
+
+        evaluator = TypeAdapter(LLMJudgeTrajectorySimulationEvaluator).validate_python(
+            dict(
+                id="sim-trajectory-1",
+                evaluatorConfig={
+                    "name": "LLMJudgeTrajectorySimulationEvaluator",
+                    "model": "gpt-4",
+                    "temperature": 0.0,
+                },
+                llm_service=mock_chat_completions,
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "expected_agent_behavior": """
+        The agent should:
+        1. Call search_flights to find available options
+        2. Present flight options to the user (simulated in conversation)
+        3. Call book_flight with appropriate parameters
+        4. Confirm the booking with the user
+        5. Call send_confirmation_email to notify the user
+        """
+            },
+        )
+
+        assert result.score == 0.88
+
+
+# Note: Tool call evaluators (order, count, args, output) require proper trace data with tool calls
+# These are more complex to set up and are already well-tested in test_evaluator_methods.py
+# The documentation examples for these assume the trace is already populated with tool call spans.
+# Since creating realistic trace data with tool calls is complex and implementation-specific,
+# we'll add simplified versions of key examples.
+
+
+class TestToolCallOrderExamples:
+    """Test examples from docs/eval/tool_call_order.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_tool_call_order(self) -> None:
+        """Test basic tool call order validation example with sample trace."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Sample agent execution with tool calls in trace (this is what was missing in docs!)
+        mock_spans = [
+            ReadableSpan(
+                name="validate_user",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "validate_user"},
+            ),
+            ReadableSpan(
+                name="check_inventory",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "check_inventory"},
+            ),
+            ReadableSpan(
+                name="create_order",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "create_order"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Process user order"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="order-check-1",
+                evaluatorConfig={"name": "ToolCallOrderEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_order": ["validate_user", "check_inventory", "create_order"]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_strict_order_validation(self) -> None:
+        """Test strict order validation example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Critical security sequence
+        mock_spans = [
+            ReadableSpan(
+                name="authenticate_user",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "authenticate_user"},
+            ),
+            ReadableSpan(
+                name="verify_permissions",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "verify_permissions"},
+            ),
+            ReadableSpan(
+                name="access_resource",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "access_resource"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Access secured resource"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="order-strict",
+                evaluatorConfig={"name": "ToolCallOrderEvaluator", "strict": True},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_order": [
+                    "authenticate_user",
+                    "verify_permissions",
+                    "access_resource",
+                ]
+            },
+        )
+
+        # Score is either 1.0 (perfect match) or 0.0 (any mismatch)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_partial_credit_with_lcs(self) -> None:
+        """Test partial credit with LCS example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Actual execution (missing "sort")
+        mock_spans = [
+            ReadableSpan(
+                name="search",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "search"},
+            ),
+            ReadableSpan(
+                name="filter",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "filter"},
+            ),
+            ReadableSpan(
+                name="display",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "display"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Search and display"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="order-lcs",
+                evaluatorConfig={"name": "ToolCallOrderEvaluator", "strict": False},
+            )
+        )
+
+        # Expected sequence
+        expected = ["search", "filter", "sort", "display"]
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={"tool_calls_order": expected},
+        )
+
+        # Score: 3/4 = 0.75 (3 tools in correct order out of 4 expected)
+        assert result.score == 0.75
+        assert isinstance(result.details, ToolCallOrderEvaluatorJustification)
+        assert result.details.lcs == ["search", "filter", "display"]
+
+    @pytest.mark.asyncio
+    async def test_database_transaction_sequence(self) -> None:
+        """Test database transaction sequence example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="begin_transaction",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "begin_transaction"},
+            ),
+            ReadableSpan(
+                name="validate_data",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "validate_data"},
+            ),
+            ReadableSpan(
+                name="update_records",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "update_records"},
+            ),
+            ReadableSpan(
+                name="commit_transaction",
+                start_time=3,
+                end_time=4,
+                attributes={"tool.name": "commit_transaction"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Update database"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="db-transaction",
+                evaluatorConfig={"name": "ToolCallOrderEvaluator", "strict": True},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_order": [
+                    "begin_transaction",
+                    "validate_data",
+                    "update_records",
+                    "commit_transaction",
+                ]
+            },
+        )
+
+        # Must match exactly for data integrity
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_api_integration_workflow(self) -> None:
+        """Test API integration workflow example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="get_api_token",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "get_api_token"},
+            ),
+            ReadableSpan(
+                name="fetch_user_data",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "fetch_user_data"},
+            ),
+            ReadableSpan(
+                name="enrich_data",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "enrich_data"},
+            ),
+            ReadableSpan(
+                name="post_to_webhook",
+                start_time=3,
+                end_time=4,
+                attributes={"tool.name": "post_to_webhook"},
+            ),
+            ReadableSpan(
+                name="log_result",
+                start_time=4,
+                end_time=5,
+                attributes={"tool.name": "log_result"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "API integration"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="api-workflow",
+                evaluatorConfig={"name": "ToolCallOrderEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_order": [
+                    "get_api_token",
+                    "fetch_user_data",
+                    "enrich_data",
+                    "post_to_webhook",
+                    "log_result",
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_using_default_criteria(self) -> None:
+        """Test using default criteria example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="init",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "init"},
+            ),
+            ReadableSpan(
+                name="process",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "process"},
+            ),
+            ReadableSpan(
+                name="cleanup",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "cleanup"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Standard workflow"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOrderEvaluator).validate_python(
+            dict(
+                id="order-default",
+                evaluatorConfig={
+                    "name": "ToolCallOrderEvaluator",
+                    "strict": False,
+                    "default_evaluation_criteria": {
+                        "tool_calls_order": ["init", "process", "cleanup"]
+                    },
+                },
+            )
+        )
+
+        # Use default criteria
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution, evaluation_criteria=None
+        )
+
+        assert result.score == 1.0
+
+
+class TestToolCallCountExamples:
+    """Test examples from docs/eval/tool_call_count.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_count_validation(self) -> None:
+        """Test basic count validation example with sample trace."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Sample agent execution with tool calls (this is what was missing in docs!)
+        mock_spans = [
+            ReadableSpan(
+                name="fetch_data",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "fetch_data"},
+            ),
+            ReadableSpan(
+                name="process_item",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "process_item"},
+            ),
+            ReadableSpan(
+                name="process_item",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "process_item"},
+            ),
+            ReadableSpan(
+                name="process_item",
+                start_time=3,
+                end_time=4,
+                attributes={"tool.name": "process_item"},
+            ),
+            ReadableSpan(
+                name="process_item",
+                start_time=4,
+                end_time=5,
+                attributes={"tool.name": "process_item"},
+            ),
+            ReadableSpan(
+                name="process_item",
+                start_time=5,
+                end_time=6,
+                attributes={"tool.name": "process_item"},
+            ),
+            ReadableSpan(
+                name="send_notification",
+                start_time=6,
+                end_time=7,
+                attributes={"tool.name": "send_notification"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Fetch and process data"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallCountEvaluator).validate_python(
+            dict(
+                id="count-check-1",
+                evaluatorConfig={"name": "ToolCallCountEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_count": {
+                    "fetch_data": ("=", 1),
+                    "process_item": ("=", 5),
+                    "send_notification": ("=", 1),
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_using_comparison_operators(self) -> None:
+        """Test using comparison operators example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="validate",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "validate"},
+            ),
+            ReadableSpan(
+                name="retry_api",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "retry_api"},
+            ),
+            ReadableSpan(
+                name="log_event",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "log_event"},
+            ),
+            ReadableSpan(
+                name="expensive_call",
+                start_time=3,
+                end_time=4,
+                attributes={"tool.name": "expensive_call"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "API operation"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallCountEvaluator).validate_python(
+            dict(
+                id="count-operators",
+                evaluatorConfig={"name": "ToolCallCountEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_count": {
+                    "validate": (">=", 1),  # At least once
+                    "retry_api": ("<=", 3),  # At most 3 times
+                    "log_event": (">", 0),  # More than 0 times
+                    "expensive_call": ("<", 2),  # Less than 2 times
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_strict_mode_all_or_nothing(self) -> None:
+        """Test strict mode - all or nothing example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="authenticate",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "authenticate"},
+            ),
+            ReadableSpan(
+                name="fetch_records",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "fetch_records"},
+            ),
+            ReadableSpan(
+                name="close_connection",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "close_connection"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Database operation"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallCountEvaluator).validate_python(
+            dict(
+                id="count-strict",
+                evaluatorConfig={"name": "ToolCallCountEvaluator", "strict": True},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_count": {
+                    "authenticate": ("=", 1),
+                    "fetch_records": ("=", 1),
+                    "close_connection": ("=", 1),
+                }
+            },
+        )
+
+        # Score is 1.0 only if ALL counts match exactly
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_preventing_redundant_calls(self) -> None:
+        """Test preventing redundant calls example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Only one expensive call
+        mock_spans = [
+            ReadableSpan(
+                name="expensive_api_call",
+                start_time=0,
+                end_time=1,
+                attributes={"tool.name": "expensive_api_call"},
+            ),
+            ReadableSpan(
+                name="database_query",
+                start_time=1,
+                end_time=2,
+                attributes={"tool.name": "database_query"},
+            ),
+            ReadableSpan(
+                name="database_query",
+                start_time=2,
+                end_time=3,
+                attributes={"tool.name": "database_query"},
+            ),
+            ReadableSpan(
+                name="llm_call",
+                start_time=3,
+                end_time=4,
+                attributes={"tool.name": "llm_call"},
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Optimize resource usage"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallCountEvaluator).validate_python(
+            dict(
+                id="prevent-redundant",
+                evaluatorConfig={"name": "ToolCallCountEvaluator", "strict": False},
+            )
+        )
+
+        # Ensure expensive operations aren't called too many times
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_count": {
+                    "expensive_api_call": (
+                        "<=",
+                        1,
+                    ),  # Should not be called more than once
+                    "database_query": ("<=", 3),  # At most 3 queries
+                    "llm_call": ("<=", 2),  # At most 2 LLM calls
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_loop_validation(self) -> None:
+        """Test loop validation example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Create 10 process_item, 10 validate_item, 10 save_result calls
+        mock_spans = []
+        for i in range(10):
+            mock_spans.extend(
+                [
+                    ReadableSpan(
+                        name="process_item",
+                        start_time=i * 3,
+                        end_time=i * 3 + 1,
+                        attributes={"tool.name": "process_item"},
+                    ),
+                    ReadableSpan(
+                        name="validate_item",
+                        start_time=i * 3 + 1,
+                        end_time=i * 3 + 2,
+                        attributes={"tool.name": "validate_item"},
+                    ),
+                    ReadableSpan(
+                        name="save_result",
+                        start_time=i * 3 + 2,
+                        end_time=i * 3 + 3,
+                        attributes={"tool.name": "save_result"},
+                    ),
+                ]
+            )
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Process 10 items"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallCountEvaluator).validate_python(
+            dict(
+                id="loop-validation",
+                evaluatorConfig={"name": "ToolCallCountEvaluator", "strict": False},
+            )
+        )
+
+        # Verify loop processed correct number of items
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls_count": {
+                    "process_item": ("=", 10),  # Should process 10 items
+                    "validate_item": ("=", 10),  # Each item should be validated
+                    "save_result": ("=", 10),  # Each result should be saved
+                }
+            },
+        )
+
+        assert result.score == 1.0
+
+
+class TestToolCallArgsExamples:
+    """Test examples from docs/eval/tool_call_args.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_argument_validation(self) -> None:
+        """Test basic argument validation example with sample trace."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Sample agent execution with tool calls and arguments (this is what was missing in docs!)
+        mock_spans = [
+            ReadableSpan(
+                name="update_user",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "update_user",
+                    "input.value": "{'user_id': 123, 'fields': {'email': 'user@example.com'}, 'notify': True}",
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"user_id": 123, "action": "update"},
+            agent_output={"status": "success"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-check-1",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": False,
+                    "subset": False,
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "update_user",
+                        "args": {
+                            "user_id": 123,
+                            "fields": {"email": "user@example.com"},
+                            "notify": True,
+                        },
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_strict_mode_exact_matching(self) -> None:
+        """Test strict mode - exact matching example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="send_email",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "send_email",
+                    "input.value": "{'to': 'user@example.com', 'subject': 'Hello', 'body': 'Test message'}",
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Send email"},
+            agent_output={"status": "sent"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-strict",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": True,
+                    "subset": False,
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "send_email",
+                        "args": {
+                            "to": "user@example.com",
+                            "subject": "Hello",
+                            "body": "Test message",
+                        },
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_subset_mode_partial_validation(self) -> None:
+        """Test subset mode - partial validation example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="create_user",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "create_user",
+                    "input.value": "{'username': 'john_doe', 'email': 'john@example.com', 'role': 'admin', 'active': True}",
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Create user"},
+            agent_output={"status": "created"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-subset",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": False,
+                    "subset": True,
+                },
+            )
+        )
+
+        # Only validate critical fields
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "create_user",
+                        "args": {"username": "john_doe", "email": "john@example.com"},
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_multiple_tool_calls(self) -> None:
+        """Test multiple tool calls example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="fetch_data",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "fetch_data",
+                    "input.value": "{'source': 'database', 'query': 'SELECT * FROM users'}",
+                },
+            ),
+            ReadableSpan(
+                name="process_data",
+                start_time=1,
+                end_time=2,
+                attributes={
+                    "tool.name": "process_data",
+                    "input.value": "{'data': [{'id': 1}], 'operation': 'filter'}",
+                },
+            ),
+            ReadableSpan(
+                name="save_results",
+                start_time=2,
+                end_time=3,
+                attributes={
+                    "tool.name": "save_results",
+                    "input.value": "{'destination': 'cache', 'ttl': 3600}",
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Data pipeline"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-multiple",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": False,
+                    "subset": False,
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "fetch_data",
+                        "args": {"source": "database", "query": "SELECT * FROM users"},
+                    },
+                    {
+                        "name": "process_data",
+                        "args": {"data": [{"id": 1}], "operation": "filter"},
+                    },
+                    {
+                        "name": "save_results",
+                        "args": {"destination": "cache", "ttl": 3600},
+                    },
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_nested_arguments(self) -> None:
+        """Test nested arguments example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="evaluatorConfigure_service",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "evaluatorConfigure_service",
+                    "input.value": "{'service': 'api', 'evaluatorConfig': {'host': 'api.example.com', 'port': 443, 'ssl': {'enabled': True, 'cert_path': '/path/to/cert'}}}",
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "evaluatorConfigure API service"},
+            agent_output={"status": "evaluatorConfigured"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-nested",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": False,
+                    "subset": False,
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "evaluatorConfigure_service",
+                        "args": {
+                            "service": "api",
+                            "evaluatorConfig": {
+                                "host": "api.example.com",
+                                "port": 443,
+                                "ssl": {"enabled": True, "cert_path": "/path/to/cert"},
+                            },
+                        },
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_non_strict_proportional_scoring(self) -> None:
+        """Test non-strict mode with proportional scoring (2/3 tools match)."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Agent called 3 tools, but only 2 match the expected args
+        mock_spans = [
+            ReadableSpan(
+                name="validate_input",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "validate_input",
+                    "input.value": "{'data': {'user_id': 123}}",  # ✓ Matches
+                },
+            ),
+            ReadableSpan(
+                name="fetch_user",
+                start_time=1,
+                end_time=2,
+                attributes={
+                    "tool.name": "fetch_user",
+                    "input.value": "{'user_id': 999}",  # ✗ Wrong ID!
+                },
+            ),
+            ReadableSpan(
+                name="update_profile",
+                start_time=2,
+                end_time=3,
+                attributes={
+                    "tool.name": "update_profile",
+                    "input.value": "{'user_id': 123, 'updates': {'name': 'John Doe'}}",  # ✓ Matches
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Update user profile"},
+            agent_output={"status": "updated"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallArgsEvaluator).validate_python(
+            dict(
+                id="args-proportional",
+                evaluatorConfig={
+                    "name": "ToolCallArgsEvaluator",
+                    "strict": False,  # Proportional scoring
+                    "subset": False,
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_calls": [
+                    {
+                        "name": "validate_input",
+                        "args": {"data": {"user_id": 123}},  # ✓ Matches
+                    },
+                    {
+                        "name": "fetch_user",
+                        "args": {"user_id": 123},  # ✗ Actual was 999
+                    },
+                    {
+                        "name": "update_profile",
+                        "args": {
+                            "user_id": 123,
+                            "updates": {"name": "John Doe"},  # ✓ Matches
+                        },
+                    },
+                ]
+            },
+        )
+
+        # Score is 2/3 = 0.66 (2 out of 3 tools matched)
+        assert abs(result.score - 0.66) < 0.01  # Allow small floating point differences
+
+
+class TestToolCallOutputExamples:
+    """Test examples from docs/eval/tool_call_output.md."""
+
+    @pytest.mark.asyncio
+    async def test_basic_output_validation(self) -> None:
+        """Test basic output validation example with sample trace."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Sample agent execution with tool calls and outputs (this is what was missing in docs!)
+        mock_spans = [
+            ReadableSpan(
+                name="get_user",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "get_user",
+                    "output.value": '{"content": "{\\"user_id\\": 123, \\"name\\": \\"John Doe\\", \\"email\\": \\"john@example.com\\", \\"status\\": \\"active\\"}"}',
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"user_id": 123},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOutputEvaluator).validate_python(
+            dict(
+                id="output-check-1",
+                evaluatorConfig={"name": "ToolCallOutputEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_outputs": [
+                    {
+                        "name": "get_user",
+                        "output": '{"user_id": 123, "name": "John Doe", "email": "john@example.com", "status": "active"}',
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_strict_mode_exact_output_matching(self) -> None:
+        """Test strict mode - exact output matching example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="calculate",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "calculate",
+                    "output.value": '{"content": "{\\"result\\": 42, \\"operation\\": \\"multiply\\"}"}',
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"operation": "multiply"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOutputEvaluator).validate_python(
+            dict(
+                id="output-strict",
+                evaluatorConfig={"name": "ToolCallOutputEvaluator", "strict": True},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_outputs": [
+                    {
+                        "name": "calculate",
+                        "output": '{"result": 42, "operation": "multiply"}',
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_multiple_tool_outputs(self) -> None:
+        """Test multiple tool outputs example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="fetch",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "fetch",
+                    "output.value": '{"content": "{\\"data\\": [\\"item1\\", \\"item2\\"]}"}',
+                },
+            ),
+            ReadableSpan(
+                name="process",
+                start_time=1,
+                end_time=2,
+                attributes={
+                    "tool.name": "process",
+                    "output.value": '{"content": "{\\"processed\\": true}"}',
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Process items"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOutputEvaluator).validate_python(
+            dict(
+                id="output-multiple",
+                evaluatorConfig={"name": "ToolCallOutputEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_outputs": [
+                    {"name": "fetch", "output": '{"data": ["item1", "item2"]}'},
+                    {"name": "process", "output": '{"processed": true}'},
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_error_handling_validation(self) -> None:
+        """Test error handling validation example."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        mock_spans = [
+            ReadableSpan(
+                name="validate_input",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "validate_input",
+                    "output.value": '{"content": "{\\"valid\\": false, \\"error\\": \\"Invalid email format\\"}"}',
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"email": "invalid-email"},
+            agent_output={"status": "validation_failed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOutputEvaluator).validate_python(
+            dict(
+                id="error-validation",
+                evaluatorConfig={"name": "ToolCallOutputEvaluator", "strict": False},
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_outputs": [
+                    {
+                        "name": "validate_input",
+                        "output": '{"valid": false, "error": "Invalid email format"}',
+                    }
+                ]
+            },
+        )
+
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_non_strict_proportional_scoring(self) -> None:
+        """Test non-strict mode with proportional scoring (2/3 outputs match)."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        # Agent produced 3 outputs, but only 2 match expected
+        mock_spans = [
+            ReadableSpan(
+                name="fetch_data",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "fetch_data",
+                    "output.value": '{"content": "{\\"records\\": 150, \\"status\\": \\"success\\"}"}',  # ✓ Matches
+                },
+            ),
+            ReadableSpan(
+                name="process_data",
+                start_time=1,
+                end_time=2,
+                attributes={
+                    "tool.name": "process_data",
+                    "output.value": '{"content": "{\\"processed\\": 100, \\"errors\\": 5}"}',  # ✗ Wrong values
+                },
+            ),
+            ReadableSpan(
+                name="save_results",
+                start_time=2,
+                end_time=3,
+                attributes={
+                    "tool.name": "save_results",
+                    "output.value": '{"content": "{\\"saved\\": 150, \\"location\\": \\"/data/results.csv\\"}"}',  # ✓ Matches
+                },
+            ),
+        ]
+
+        agent_execution = AgentExecution(
+            agent_input={"task": "Process data pipeline"},
+            agent_output={"status": "completed"},
+            agent_trace=mock_spans,
+        )
+
+        evaluator = TypeAdapter(ToolCallOutputEvaluator).validate_python(
+            dict(
+                id="output-proportional",
+                evaluatorConfig={
+                    "name": "ToolCallOutputEvaluator",
+                    "strict": False,  # Proportional scoring
+                },
+            )
+        )
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution=agent_execution,
+            evaluation_criteria={
+                "tool_outputs": [
+                    {
+                        "name": "fetch_data",
+                        "output": '{"records": 150, "status": "success"}',  # ✓ Matches
+                    },
+                    {
+                        "name": "process_data",
+                        "output": '{"processed": 150, "errors": 0}',  # ✗ Actual had errors: 5
+                    },
+                    {
+                        "name": "save_results",
+                        "output": '{"saved": 150, "location": "/data/results.csv"}',  # ✓ Matches
+                    },
+                ]
+            },
+        )
+
+        # Score is 2/3 = 0.66 (2 out of 3 outputs matched)
+        assert abs(result.score - 0.66) < 0.01  # Allow small floating point differences
diff --git a/packages/uipath/tests/evaluators/test_eval_level_expected_output.py b/packages/uipath/tests/evaluators/test_eval_level_expected_output.py
new file mode 100644
index 000000000..1c2b8fd44
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_eval_level_expected_output.py
@@ -0,0 +1,761 @@
+"""Tests for evaluation-level expectedOutput schema enhancement.
+
+Tests the new optional `expectedOutput` field on EvaluationItem and the
+runtime criteria resolution logic that injects it into output-based evaluators.
+"""
+
+import uuid
+from typing import Any
+
+import pytest
+from pytest_mock.plugin import MockerFixture
+
+from uipath.eval.evaluators.contains_evaluator import (
+    ContainsEvaluationCriteria,
+    ContainsEvaluator,
+)
+from uipath.eval.evaluators.exact_match_evaluator import ExactMatchEvaluator
+from uipath.eval.evaluators.json_similarity_evaluator import (
+    JsonSimilarityEvaluator,
+)
+from uipath.eval.evaluators.llm_as_judge_evaluator import LLMJudgeJustification
+from uipath.eval.evaluators.llm_judge_output_evaluator import (
+    LLMJudgeOutputEvaluator,
+)
+from uipath.eval.evaluators.output_evaluator import OutputEvaluationCriteria
+from uipath.eval.models import NumericEvaluationResult
+from uipath.eval.models.evaluation_set import (
+    EvaluationItem,
+    EvaluationSet,
+)
+from uipath.eval.models.models import AgentExecution
+
+# ─────────────────────────────────────────────────────────────────
+# Model Tests
+# ─────────────────────────────────────────────────────────────────
+
+
+class TestEvaluationItemExpectedOutput:
+    """Test the new expectedOutput field on EvaluationItem."""
+
+    def test_evaluation_item_with_dict_expected_output(self) -> None:
+        """EvaluationItem with dict expectedOutput parses correctly."""
+        item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test Evaluation",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"result": 4},
+                "evaluationCriterias": {
+                    "exact-match": None,
+                },
+            }
+        )
+        assert item.expected_output == {"result": 4}
+
+    def test_evaluation_item_with_string_expected_output(self) -> None:
+        """EvaluationItem with string expectedOutput parses correctly."""
+        item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test Evaluation",
+                "inputs": {"query": "hello"},
+                "expectedOutput": "Hello World",
+                "evaluationCriterias": {
+                    "exact-match": None,
+                },
+            }
+        )
+        assert item.expected_output == "Hello World"
+
+    def test_evaluation_item_without_expected_output(self) -> None:
+        """EvaluationItem without expectedOutput still works (backward compat)."""
+        item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test Evaluation",
+                "inputs": {"query": "2+2"},
+                "evaluationCriterias": {
+                    "exact-match": {"expectedOutput": {"result": 4}},
+                },
+            }
+        )
+        assert item.expected_output is None
+
+    def test_evaluation_item_with_null_expected_output(self) -> None:
+        """EvaluationItem with explicit null expectedOutput parses as None."""
+        item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test Evaluation",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": None,
+                "evaluationCriterias": {
+                    "exact-match": {"expectedOutput": {"result": 4}},
+                },
+            }
+        )
+        assert item.expected_output is None
+
+    def test_evaluation_item_serialization_roundtrip_with_expected_output(
+        self,
+    ) -> None:
+        """Serialization roundtrip preserves expectedOutput."""
+        original_data = {
+            "id": "eval-1",
+            "name": "Test Evaluation",
+            "inputs": {"query": "2+2"},
+            "expectedOutput": {"result": 4},
+            "evaluationCriterias": {
+                "exact-match": None,
+            },
+        }
+        item = EvaluationItem.model_validate(original_data)
+        serialized = item.model_dump(by_alias=True, exclude_none=True)
+
+        assert serialized["expectedOutput"] == {"result": 4}
+
+        # Roundtrip
+        item2 = EvaluationItem.model_validate(serialized)
+        assert item2.expected_output == {"result": 4}
+
+    def test_evaluation_item_serialization_omits_none_expected_output(self) -> None:
+        """Serialization omits expectedOutput when None and exclude_none=True."""
+        item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test Evaluation",
+                "inputs": {"query": "2+2"},
+                "evaluationCriterias": {"exact-match": None},
+            }
+        )
+        serialized = item.model_dump(by_alias=True, exclude_none=True)
+        assert "expectedOutput" not in serialized
+
+    def test_evaluation_set_with_evaluation_level_expected_output(self) -> None:
+        """EvaluationSet with evaluation-level expectedOutput parses correctly."""
+        evaluation_set = EvaluationSet.model_validate(
+            {
+                "id": "set-1",
+                "name": "Test Set",
+                "version": "1.0",
+                "evaluatorConfigs": ["exact-match"],
+                "evaluations": [
+                    {
+                        "id": "eval-1",
+                        "name": "Test Evaluation",
+                        "inputs": {"query": "2+2"},
+                        "expectedOutput": {"result": 4},
+                        "evaluationCriterias": {
+                            "exact-match": None,
+                        },
+                    }
+                ],
+            }
+        )
+        assert evaluation_set.evaluations[0].expected_output == {"result": 4}
+
+    def test_evaluation_item_with_python_field_name(self) -> None:
+        """EvaluationItem works with Python field name (populate_by_name=True)."""
+        item = EvaluationItem(
+            id="eval-1",
+            name="Test Evaluation",
+            inputs={"query": "2+2"},
+            expected_output={"result": 4},
+            evaluation_criterias={"exact-match": None},
+        )
+        assert item.expected_output == {"result": 4}
+
+
+# ─────────────────────────────────────────────────────────────────
+# Runtime Criteria Resolution Tests
+# ─────────────────────────────────────────────────────────────────
+
+
+class TestRuntimeCriteriaResolution:
+    """Test the runtime criteria merge logic for evaluation-level expectedOutput.
+
+    These tests verify the merge logic directly against evaluators,
+    simulating what runtime.py does when building typed criteria.
+    """
+
+    def _build_criteria(
+        self,
+        evaluator: Any,
+        evaluation_item: EvaluationItem,
+        evaluator_id: str,
+    ) -> Any:
+        """Simulate the runtime's criteria resolution logic.
+
+        This mirrors the logic in runtime.py _execute_eval().
+        """
+        if evaluator_id not in evaluation_item.evaluation_criterias:
+            return None
+
+        evaluation_criteria = evaluation_item.evaluation_criterias[evaluator_id]
+
+        # Inject evaluation-level expectedOutput for output-based evaluators
+        if evaluation_item.expected_output is not None and issubclass(
+            evaluator.evaluation_criteria_type,
+            OutputEvaluationCriteria,
+        ):
+            if evaluation_criteria is None:
+                evaluation_criteria = {
+                    "expectedOutput": evaluation_item.expected_output
+                }
+            elif "expectedOutput" not in evaluation_criteria:
+                evaluation_criteria = {
+                    **evaluation_criteria,
+                    "expectedOutput": evaluation_item.expected_output,
+                }
+            # else: per-evaluator expectedOutput takes precedence
+
+        if evaluation_criteria:
+            return evaluator.evaluation_criteria_type(**evaluation_criteria)
+        return None
+
+    @pytest.mark.asyncio
+    async def test_evaluation_level_used_when_criteria_is_null(self) -> None:
+        """When per-evaluator criteria is null, evaluation-level expectedOutput is injected."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"output": "Test output"},
+                "evaluationCriterias": {evaluator_id: None},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert isinstance(criteria, OutputEvaluationCriteria)
+        assert criteria.expected_output == {"output": "Test output"}
+
+    @pytest.mark.asyncio
+    async def test_per_evaluator_overrides_evaluation_level(self) -> None:
+        """Per-evaluator criteria expectedOutput overrides evaluation-level."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"result": "evaluation-level"},
+                "evaluationCriterias": {
+                    evaluator_id: {"expectedOutput": {"result": "per-evaluator"}}
+                },
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert criteria.expected_output == {"result": "per-evaluator"}
+
+    @pytest.mark.asyncio
+    async def test_evaluation_level_injected_when_criteria_lacks_expected_output(
+        self,
+    ) -> None:
+        """When criteria has other fields but no expectedOutput, evaluation-level is injected."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"result": 4},
+                "evaluationCriterias": {evaluator_id: {"someOtherField": "value"}},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert criteria.expected_output == {"result": 4}
+
+    @pytest.mark.asyncio
+    async def test_non_output_evaluator_unaffected_by_evaluation_level(self) -> None:
+        """Non-output evaluators (ContainsEvaluator) ignore evaluation-level expectedOutput."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ContainsEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "hello"},
+                "expectedOutput": {"result": "should be ignored"},
+                "evaluationCriterias": {evaluator_id: {"searchText": "hello"}},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert isinstance(criteria, ContainsEvaluationCriteria)
+        assert criteria.search_text == "hello"
+        # expectedOutput was NOT injected
+        assert not hasattr(criteria, "expected_output")
+
+    @pytest.mark.asyncio
+    async def test_no_evaluation_level_expected_output_no_injection(self) -> None:
+        """When evaluation-level expectedOutput is None, no injection happens."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "2+2"},
+                "evaluationCriterias": {evaluator_id: None},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        # No evaluation-level, no criteria -> None (will fall to default or error)
+        assert criteria is None
+
+    @pytest.mark.asyncio
+    async def test_evaluation_level_string_expected_output(self) -> None:
+        """String evaluation-level expectedOutput is injected correctly."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "hello"},
+                "expectedOutput": "Hello World",
+                "evaluationCriterias": {evaluator_id: None},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert criteria.expected_output == "Hello World"
+
+    @pytest.mark.asyncio
+    async def test_evaluation_level_empty_dict_expected_output(self) -> None:
+        """Empty dict evaluation-level expectedOutput is still treated as present."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {},
+                "evaluationCriterias": {evaluator_id: None},
+            }
+        )
+
+        criteria = self._build_criteria(evaluator, evaluation_item, evaluator_id)
+
+        assert criteria is not None
+        assert criteria.expected_output == {}
+
+
+# ─────────────────────────────────────────────────────────────────
+# Evaluator Integration Tests
+# ─────────────────────────────────────────────────────────────────
+
+
+class TestExactMatchWithEvaluationLevelExpectedOutput:
+    """Test ExactMatchEvaluator with evaluation-level expectedOutput."""
+
+    @pytest.mark.asyncio
+    async def test_exact_match_with_evaluation_level_expected_output(self) -> None:
+        """ExactMatchEvaluator uses evaluation-level expectedOutput when criteria is null."""
+        execution = AgentExecution(
+            agent_input={"query": "2+2"},
+            agent_output={"result": 4},
+            agent_trace=[],
+        )
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": str(uuid.uuid4())}
+        )
+
+        # Simulate runtime injection: evaluation-level expectedOutput -> criteria
+        criteria = OutputEvaluationCriteria(
+            expected_output={"result": 4}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_per_evaluator_overrides_evaluation_level(self) -> None:
+        """Per-evaluator expectedOutput overrides evaluation-level."""
+        execution = AgentExecution(
+            agent_input={"query": "2+2"},
+            agent_output={"result": 4},
+            agent_trace=[],
+        )
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": str(uuid.uuid4())}
+        )
+
+        # Per-evaluator has different expectedOutput (mismatch)
+        criteria = OutputEvaluationCriteria(
+            expected_output={"result": 5}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+
+class TestJsonSimilarityWithEvaluationLevelExpectedOutput:
+    """Test JsonSimilarityEvaluator with evaluation-level expectedOutput."""
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_with_evaluation_level_expected_output(self) -> None:
+        """JsonSimilarityEvaluator uses evaluation-level expectedOutput."""
+        execution = AgentExecution(
+            agent_input={"input": "Test"},
+            agent_output={"name": "John", "age": 30, "city": "NYC"},
+            agent_trace=[],
+        )
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": str(uuid.uuid4())}
+        )
+
+        criteria = OutputEvaluationCriteria(
+            expected_output={"name": "John", "age": 30, "city": "NYC"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestLLMJudgeWithEvaluationLevelExpectedOutput:
+    """Test LLMJudgeOutputEvaluator with evaluation-level expectedOutput."""
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_output_with_evaluation_level_expected_output(
+        self, mocker: MockerFixture
+    ) -> None:
+        """LLMJudgeOutputEvaluator uses evaluation-level expectedOutput."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 90,
+            "justification": "Output matches expected",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        config = {
+            "name": "LlmJudgeTest",
+            "prompt": "Rate: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "gpt-4o",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": config,
+                "llm_service": mock_chat_completions,
+                "id": str(uuid.uuid4()),
+            }
+        )
+
+        execution = AgentExecution(
+            agent_input={"query": "test"},
+            agent_output={"result": "test output"},
+            agent_trace=[],
+        )
+
+        # Criteria built from evaluation-level expectedOutput
+        criteria = OutputEvaluationCriteria(
+            expected_output={"result": "test output"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.9
+        assert isinstance(result.details, LLMJudgeJustification)
+
+
+# ─────────────────────────────────────────────────────────────────
+# Legacy Migration Compatibility Tests
+# ─────────────────────────────────────────────────────────────────
+
+
+class TestLegacyMigrationCompatibility:
+    """Test that legacy migration path is unaffected by the new field."""
+
+    def test_legacy_evaluation_set_still_migrates(self) -> None:
+        """Legacy evaluation set without evaluation-level expectedOutput migrates correctly."""
+        from uipath.eval.helpers import discriminate_eval_set
+
+        legacy_data = {
+            "id": "set-1",
+            "fileName": "test.json",
+            "name": "Legacy Set",
+            "evaluatorRefs": ["exact-match"],
+            "evaluations": [
+                {
+                    "id": "eval-1",
+                    "name": "Test Evaluation",
+                    "inputs": {"query": "2+2"},
+                    "expectedOutput": {"result": 4},
+                    "expectedAgentBehavior": "",
+                    "evalSetId": "set-1",
+                    "createdAt": "2024-01-01T00:00:00Z",
+                    "updatedAt": "2024-01-01T00:00:00Z",
+                }
+            ],
+            "batchSize": 10,
+            "timeoutMinutes": 20,
+            "createdAt": "2024-01-01T00:00:00Z",
+            "updatedAt": "2024-01-01T00:00:00Z",
+        }
+
+        result = discriminate_eval_set(legacy_data)
+
+        # Should parse as LegacyEvaluationSet (no version field)
+        from uipath.eval.models.evaluation_set import LegacyEvaluationSet
+
+        assert isinstance(result, LegacyEvaluationSet)
+
+    def test_v1_evaluation_set_with_evaluation_level_expected_output(self) -> None:
+        """v1.0 evaluation set with evaluation-level expectedOutput parses correctly."""
+        from uipath.eval.helpers import discriminate_eval_set
+
+        v1_data = {
+            "id": "set-1",
+            "name": "V1 Set",
+            "version": "1.0",
+            "evaluatorConfigs": ["exact-match"],
+            "evaluations": [
+                {
+                    "id": "eval-1",
+                    "name": "Test Evaluation",
+                    "inputs": {"query": "2+2"},
+                    "expectedOutput": {"result": 4},
+                    "evaluationCriterias": {
+                        "exact-match": None,
+                    },
+                }
+            ],
+        }
+
+        result = discriminate_eval_set(v1_data)
+
+        assert isinstance(result, EvaluationSet)
+        assert result.evaluations[0].expected_output == {"result": 4}
+
+    def test_v1_evaluation_set_without_evaluation_level_expected_output(self) -> None:
+        """v1.0 evaluation set without evaluation-level expectedOutput still works."""
+        from uipath.eval.helpers import discriminate_eval_set
+
+        v1_data = {
+            "id": "set-1",
+            "name": "V1 Set",
+            "version": "1.0",
+            "evaluatorConfigs": ["exact-match"],
+            "evaluations": [
+                {
+                    "id": "eval-1",
+                    "name": "Test Evaluation",
+                    "inputs": {"query": "2+2"},
+                    "evaluationCriterias": {
+                        "exact-match": {"expectedOutput": {"result": 4}},
+                    },
+                }
+            ],
+        }
+
+        result = discriminate_eval_set(v1_data)
+
+        assert isinstance(result, EvaluationSet)
+        assert result.evaluations[0].expected_output is None
+
+
+# ─────────────────────────────────────────────────────────────────
+# End-to-End Criteria Resolution Tests
+# ─────────────────────────────────────────────────────────────────
+
+
+class TestEndToEndCriteriaResolution:
+    """End-to-end tests that simulate the full runtime flow."""
+
+    @pytest.mark.asyncio
+    async def test_e2e_exact_match_null_criteria_with_evaluation_level(self) -> None:
+        """Full flow: null criteria + evaluation-level -> ExactMatch evaluator gets expectedOutput."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Calculator Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"result": 4},
+                "evaluationCriterias": {evaluator_id: None},
+            }
+        )
+        execution = AgentExecution(
+            agent_input={"query": "2+2"},
+            agent_output={"result": 4},
+            agent_trace=[],
+        )
+
+        # Simulate runtime merge
+        evaluation_criteria = evaluation_item.evaluation_criterias[evaluator_id]
+        if evaluation_item.expected_output is not None and issubclass(
+            evaluator.evaluation_criteria_type, OutputEvaluationCriteria
+        ):
+            if evaluation_criteria is None:
+                evaluation_criteria = {
+                    "expectedOutput": evaluation_item.expected_output
+                }
+            elif "expectedOutput" not in evaluation_criteria:
+                evaluation_criteria = {
+                    **evaluation_criteria,
+                    "expectedOutput": evaluation_item.expected_output,
+                }
+
+        assert evaluation_criteria is not None
+        typed_criteria = evaluator.evaluation_criteria_type(**evaluation_criteria)
+        result = await evaluator.evaluate(execution, typed_criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_e2e_mixed_evaluators_with_evaluation_level(self) -> None:
+        """Multiple evaluators: output-based gets evaluation-level, non-output ignores it."""
+        exact_match_id = str(uuid.uuid4())
+        contains_id = str(uuid.uuid4())
+
+        exact_match_evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "ExactMatch"}, "id": exact_match_id}
+        )
+        contains_evaluator = ContainsEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Contains"}, "id": contains_id}
+        )
+
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Mixed Test",
+                "inputs": {"query": "hello"},
+                "expectedOutput": "Hello World",
+                "evaluationCriterias": {
+                    exact_match_id: None,  # Will get evaluation-level expectedOutput
+                    contains_id: {"searchText": "Hello"},  # Unaffected
+                },
+            }
+        )
+        execution = AgentExecution(
+            agent_input={"query": "hello"},
+            agent_output="Hello World",
+            agent_trace=[],
+        )
+
+        # Process exact-match (output-based)
+        em_criteria = evaluation_item.evaluation_criterias[exact_match_id]
+        if evaluation_item.expected_output is not None and issubclass(
+            exact_match_evaluator.evaluation_criteria_type,
+            OutputEvaluationCriteria,
+        ):
+            if em_criteria is None:
+                em_criteria = {"expectedOutput": evaluation_item.expected_output}
+
+        assert em_criteria is not None
+        em_typed = exact_match_evaluator.evaluation_criteria_type(**em_criteria)
+        em_result = await exact_match_evaluator.evaluate(execution, em_typed)
+        assert em_result.score == 1.0
+
+        # Process contains (non-output-based)
+        c_criteria = evaluation_item.evaluation_criterias[contains_id]
+        assert not issubclass(
+            contains_evaluator.evaluation_criteria_type,
+            OutputEvaluationCriteria,
+        )
+        assert c_criteria is not None
+        c_typed = contains_evaluator.evaluation_criteria_type(**c_criteria)
+        c_result = await contains_evaluator.evaluate(execution, c_typed)
+        assert c_result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_e2e_per_evaluator_override_with_evaluation_level(self) -> None:
+        """Per-evaluator criteria overrides evaluation-level in full flow."""
+        evaluator_id = str(uuid.uuid4())
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {"name": "Test"}, "id": evaluator_id}
+        )
+        evaluation_item = EvaluationItem.model_validate(
+            {
+                "id": "eval-1",
+                "name": "Override Test",
+                "inputs": {"query": "2+2"},
+                "expectedOutput": {"result": "wrong"},
+                "evaluationCriterias": {
+                    evaluator_id: {"expectedOutput": {"result": 4}}
+                },
+            }
+        )
+        execution = AgentExecution(
+            agent_input={"query": "2+2"},
+            agent_output={"result": 4},
+            agent_trace=[],
+        )
+
+        # Simulate runtime merge
+        evaluation_criteria = evaluation_item.evaluation_criterias[evaluator_id]
+        if evaluation_item.expected_output is not None and issubclass(
+            evaluator.evaluation_criteria_type, OutputEvaluationCriteria
+        ):
+            if evaluation_criteria is None:
+                evaluation_criteria = {
+                    "expectedOutput": evaluation_item.expected_output
+                }
+            elif "expectedOutput" not in evaluation_criteria:
+                evaluation_criteria = {
+                    **evaluation_criteria,
+                    "expectedOutput": evaluation_item.expected_output,
+                }
+            # else: per-evaluator wins (this case)
+
+        assert evaluation_criteria is not None
+        typed_criteria = evaluator.evaluation_criteria_type(**evaluation_criteria)
+        result = await evaluator.evaluate(execution, typed_criteria)
+
+        # Per-evaluator says {"result": 4}, agent output is {"result": 4} -> match
+        assert result.score == 1.0
+        # Verify evaluation-level "wrong" was NOT used
+        assert typed_criteria.expected_output == {"result": 4}
diff --git a/packages/uipath/tests/evaluators/test_evaluator_aggregation.py b/packages/uipath/tests/evaluators/test_evaluator_aggregation.py
new file mode 100644
index 000000000..2d15b8ae4
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_evaluator_aggregation.py
@@ -0,0 +1,1021 @@
+"""Test module for evaluation result aggregation logic.
+
+This module tests the compute_evaluator_scores() standalone function,
+which handles deduplication, per-evaluator reduction, and weighted scoring.
+"""
+
+import uuid
+from typing import Any, Callable
+
+import pytest
+
+from uipath.eval.evaluators import ExactMatchEvaluator
+from uipath.eval.models.models import EvaluationResultDto
+from uipath.eval.runtime._types import (
+    UiPathEvalRunResult,
+    UiPathEvalRunResultDto,
+)
+from uipath.eval.runtime.runtime import compute_evaluator_scores
+
+
+def _make_evaluator(
+    name: str, reducer: Callable[[list[EvaluationResultDto]], float] | None = None
+) -> Any:
+    """Create a minimal mock evaluator with a name and optional custom reduce_scores."""
+    _reducer = reducer or (
+        lambda results: sum(r.score for r in results) / len(results) if results else 0.0
+    )
+
+    class MockEvaluator:
+        def reduce_scores(self, results: list[EvaluationResultDto]) -> float:
+            return _reducer(results)
+
+    obj = MockEvaluator()
+    obj.name = name  # type: ignore[attr-defined]
+    return obj
+
+
+class TestEvaluationResultAggregation:
+    """Test evaluation result aggregation with deduplication."""
+
+    def test_compute_evaluator_scores_empty(self) -> None:
+        """Test with empty results."""
+        final_score, agg_metrics = compute_evaluator_scores([], [])
+
+        assert final_score == 0.0
+        assert agg_metrics == {}
+
+    def test_compute_evaluator_scores_single_evaluator(self) -> None:
+        """Test with single evaluator across multiple datapoints."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    )
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    )
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test3",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.6),
+                    )
+                ],
+            ),
+        ]
+
+        evaluators = [_make_evaluator("ExactMatchEvaluator")]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        expected_avg = (0.8 + 1.0 + 0.6) / 3  # 0.8
+        assert final_score == pytest.approx(expected_avg)
+        assert agg_metrics == {"ExactMatchEvaluator": pytest.approx(expected_avg)}
+
+    def test_compute_evaluator_scores_multiple_evaluators(self) -> None:
+        """Test with multiple evaluators."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ContainsEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.9),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ContainsEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.7),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [
+            _make_evaluator("ExactMatchEvaluator"),
+            _make_evaluator("ContainsEvaluator"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        # ExactMatch avg: (0.8 + 1.0) / 2 = 0.9
+        # Contains avg: (0.9 + 0.7) / 2 = 0.8
+        # Final avg: (0.9 + 0.8) / 2 = 0.85
+        assert final_score == pytest.approx(0.85)
+        assert agg_metrics == {
+            "ExactMatchEvaluator": pytest.approx(0.9),
+            "ContainsEvaluator": pytest.approx(0.8),
+        }
+
+    def test_compute_evaluator_scores_with_deduplication(self) -> None:
+        """Test with duplicate evaluator results on same datapoint."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    # Multiple ExactMatch results for same datapoint (should be averaged)
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",  # Duplicate!
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",  # Another duplicate!
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.6),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.5),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [_make_evaluator("ExactMatchEvaluator")]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        # datapoint1 ExactMatch avg: (0.8 + 1.0 + 0.6) / 3 = 0.8
+        # datapoint2 ExactMatch: 0.5
+        # Overall ExactMatch avg: (0.8 + 0.5) / 2 = 0.65
+        assert final_score == pytest.approx(0.65)
+        assert agg_metrics == {"ExactMatchEvaluator": pytest.approx(0.65)}
+
+    def test_compute_evaluator_scores_with_weights(self) -> None:
+        """Test with evaluator weights."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ContainsEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.6),
+                    ),
+                ],
+            ),
+        ]
+
+        # Give ExactMatch twice the weight of Contains
+        weights = {
+            "ExactMatchEvaluator": 2.0,
+            "ContainsEvaluator": 1.0,
+        }
+
+        evaluators = [
+            _make_evaluator("ExactMatchEvaluator"),
+            _make_evaluator("ContainsEvaluator"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(
+            results, evaluators, evaluator_weights=weights
+        )
+
+        # Weighted average: (0.8 * 2.0 + 0.6 * 1.0) / (2.0 + 1.0) = 2.2 / 3 = 0.733...
+        expected_weighted_avg = (0.8 * 2.0 + 0.6 * 1.0) / 3.0
+        assert final_score == pytest.approx(expected_weighted_avg)
+        assert agg_metrics == {
+            "ExactMatchEvaluator": pytest.approx(0.8),
+            "ContainsEvaluator": pytest.approx(0.6),
+        }
+
+    def test_compute_evaluator_scores_missing_weights(self) -> None:
+        """Test when some evaluators are missing from weights dict."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="UnknownEvaluator",  # Not in weights
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.6),
+                    ),
+                ],
+            ),
+        ]
+
+        weights = {"ExactMatchEvaluator": 2.0}  # Missing UnknownEvaluator weight
+
+        evaluators = [
+            _make_evaluator("ExactMatchEvaluator"),
+            _make_evaluator("UnknownEvaluator"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(
+            results, evaluators, evaluator_weights=weights
+        )
+
+        # UnknownEvaluator gets default weight of 1.0
+        # Weighted average: (0.8 * 2.0 + 0.6 * 1.0) / (2.0 + 1.0) = 2.2 / 3
+        expected_weighted_avg = (0.8 * 2.0 + 0.6 * 1.0) / 3.0
+        assert final_score == pytest.approx(expected_weighted_avg)
+
+    def test_compute_evaluator_scores_custom_default_weight(self) -> None:
+        """Test with custom default weight."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="UnknownEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.6),
+                    ),
+                ],
+            ),
+        ]
+
+        weights = {"ExactMatchEvaluator": 2.0}
+        default_weight = 0.5  # Custom default weight
+
+        evaluators = [
+            _make_evaluator("ExactMatchEvaluator"),
+            _make_evaluator("UnknownEvaluator"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(
+            results,
+            evaluators,
+            evaluator_weights=weights,
+            default_weight=default_weight,
+        )
+
+        # UnknownEvaluator gets default weight of 0.5
+        # Weighted average: (0.8 * 2.0 + 0.6 * 0.5) / (2.0 + 0.5) = 1.9 / 2.5 = 0.76
+        expected_weighted_avg = (0.8 * 2.0 + 0.6 * 0.5) / 2.5
+        assert final_score == pytest.approx(expected_weighted_avg)
+
+    def test_compute_evaluator_scores_complex_scenario(self) -> None:
+        """Test complex scenario with dedup, multiple evaluators, and multiple datapoints."""
+        # Scenario:
+        # datapoint1: ExactMatch[0.5, 1.0] (avg=0.75), Contains[1.0], ToolCallCount[1.0]
+        # datapoint2: ExactMatch[0.0], Contains[1.0]
+        # datapoint3: ExactMatch[1.0], ToolCallCount[1.0]
+        # Expected per evaluator:
+        # ExactMatch: (0.75 + 0.0 + 1.0) / 3 = 0.583
+        # Contains: (1.0 + 1.0) / 2 = 1.0
+        # ToolCallCount: (1.0 + 1.0) / 2 = 1.0
+
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatch",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.5),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatch",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="Contains",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ToolCallCount",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatch",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="Contains",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test3",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatch",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ToolCallCount",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [
+            _make_evaluator("ExactMatch"),
+            _make_evaluator("Contains"),
+            _make_evaluator("ToolCallCount"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        expected_exact_match = (0.75 + 0.0 + 1.0) / 3  # 0.583
+        expected_contains = 1.0
+        expected_tool_count = 1.0
+        expected_final = (
+            expected_exact_match + expected_contains + expected_tool_count
+        ) / 3
+
+        assert final_score == pytest.approx(expected_final)
+        assert agg_metrics == {
+            "ExactMatch": pytest.approx(expected_exact_match),
+            "Contains": pytest.approx(expected_contains),
+            "ToolCallCount": pytest.approx(expected_tool_count),
+        }
+
+    def test_compute_evaluator_scores_single_datapoint_single_evaluator(self) -> None:
+        """Test simplest case: single datapoint, single evaluator."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.85),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [_make_evaluator("ExactMatchEvaluator")]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        assert final_score == pytest.approx(0.85)
+        assert agg_metrics == {"ExactMatchEvaluator": pytest.approx(0.85)}
+
+    def test_compute_evaluator_scores_different_evaluators_per_datapoint(self) -> None:
+        """Test when different datapoints have different evaluators."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ContainsEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.9),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test3",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ExactMatchEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="ContainsEvaluator",
+                        evaluator_id=str(uuid.uuid4()),
+                        result=EvaluationResultDto(score=0.7),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [
+            _make_evaluator("ExactMatchEvaluator"),
+            _make_evaluator("ContainsEvaluator"),
+        ]
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        # ExactMatch: (0.8 + 1.0) / 2 = 0.9 (appears in test1 and test3)
+        # Contains: (0.9 + 0.7) / 2 = 0.8 (appears in test2 and test3)
+        # Final: (0.9 + 0.8) / 2 = 0.85
+        assert final_score == pytest.approx(0.85)
+        assert agg_metrics == {
+            "ExactMatchEvaluator": pytest.approx(0.9),
+            "ContainsEvaluator": pytest.approx(0.8),
+        }
+
+
+class TestBaseEvaluatorReduceScores:
+    """Test the default reduce_scores method on GenericBaseEvaluator."""
+
+    @pytest.fixture()
+    def evaluator(self) -> Any:
+        """Create a minimal ExactMatchEvaluator for testing reduce_scores."""
+        return ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": {}, "id": str(uuid.uuid4())}
+        )
+
+    def test_reduce_scores_default_average(self, evaluator: Any) -> None:
+        """Default reduce_scores computes simple average."""
+        results = [
+            EvaluationResultDto(score=0.8),
+            EvaluationResultDto(score=1.0),
+            EvaluationResultDto(score=0.6),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(0.8)
+
+    def test_reduce_scores_empty_list(self, evaluator: Any) -> None:
+        """Default reduce_scores returns 0.0 for empty list."""
+        assert evaluator.reduce_scores([]) == 0.0
+
+    def test_reduce_scores_single_score(self, evaluator: Any) -> None:
+        """Default reduce_scores returns the single score."""
+        assert evaluator.reduce_scores(
+            [EvaluationResultDto(score=0.75)]
+        ) == pytest.approx(0.75)
+
+    def test_reduce_scores_all_zeros(self, evaluator: Any) -> None:
+        """Default reduce_scores with all zeros."""
+        results = [
+            EvaluationResultDto(score=0.0),
+            EvaluationResultDto(score=0.0),
+            EvaluationResultDto(score=0.0),
+        ]
+        assert evaluator.reduce_scores(results) == 0.0
+
+    def test_reduce_scores_all_ones(self, evaluator: Any) -> None:
+        """Default reduce_scores with all ones."""
+        results = [
+            EvaluationResultDto(score=1.0),
+            EvaluationResultDto(score=1.0),
+            EvaluationResultDto(score=1.0),
+        ]
+        assert evaluator.reduce_scores(results) == 1.0
+
+
+class TestCustomReducerIntegration:
+    """Test that compute_evaluator_scores uses evaluator reduce_scores correctly."""
+
+    def test_uses_evaluator_reducer(self) -> None:
+        """Test that an evaluator's reduce_scores is used instead of default average."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="MyEvaluator",
+                        evaluator_id="my-eval",
+                        result=EvaluationResultDto(score=0.5),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="MyEvaluator",
+                        evaluator_id="my-eval",
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                ],
+            ),
+        ]
+
+        # Custom reducer: sum instead of average
+        evaluators = [
+            _make_evaluator(
+                "MyEvaluator", lambda results: sum(r.score for r in results)
+            )
+        ]
+
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        # sum([0.5, 1.0]) = 1.5, not average 0.75
+        assert agg_metrics == {"MyEvaluator": pytest.approx(1.5)}
+        assert final_score == pytest.approx(1.5)
+
+    def test_missing_evaluator_raises_error(self) -> None:
+        """Test that a missing evaluator raises a clear ValueError."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="UnknownEval",
+                        evaluator_id="unknown-type",
+                        result=EvaluationResultDto(score=0.4),
+                    ),
+                ],
+            ),
+        ]
+
+        with pytest.raises(ValueError, match="UnknownEval"):
+            compute_evaluator_scores(results, [])
+
+    def test_details_passed_to_reducer(self) -> None:
+        """Test that EvaluationResultDto.details are passed through to reduce_scores."""
+        captured_details: list[dict[str, Any] | str | None] = []
+
+        def capturing_reducer(results: list[EvaluationResultDto]) -> float:
+            for r in results:
+                captured_details.append(r.details)
+            return sum(r.score for r in results) / len(results) if results else 0.0
+
+        details_a = {"predicted": "cat", "expected": "dog"}
+        details_b = {"predicted": "cat", "expected": "cat"}
+
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="MyEval",
+                        evaluator_id="my-eval",
+                        result=EvaluationResultDto(score=0.0, details=details_a),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="MyEval",
+                        evaluator_id="my-eval",
+                        result=EvaluationResultDto(score=1.0, details=details_b),
+                    ),
+                ],
+            ),
+        ]
+
+        evaluators = [_make_evaluator("MyEval", capturing_reducer)]
+        compute_evaluator_scores(results, evaluators)
+
+        assert len(captured_details) == 2
+        assert captured_details[0] == {"predicted": "cat", "expected": "dog"}
+        assert captured_details[1] == {"predicted": "cat", "expected": "cat"}
+
+    def test_mixed_custom_and_default_reducers(self) -> None:
+        """Test with one custom reducer and one falling back to default."""
+        results = [
+            UiPathEvalRunResult(
+                evaluation_name="test1",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="CustomEval",
+                        evaluator_id="custom-type",
+                        result=EvaluationResultDto(score=0.8),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="DefaultEval",
+                        evaluator_id="default-type",
+                        result=EvaluationResultDto(score=0.6),
+                    ),
+                ],
+            ),
+            UiPathEvalRunResult(
+                evaluation_name="test2",
+                evaluation_run_results=[
+                    UiPathEvalRunResultDto(
+                        evaluator_name="CustomEval",
+                        evaluator_id="custom-type",
+                        result=EvaluationResultDto(score=1.0),
+                    ),
+                    UiPathEvalRunResultDto(
+                        evaluator_name="DefaultEval",
+                        evaluator_id="default-type",
+                        result=EvaluationResultDto(score=0.4),
+                    ),
+                ],
+            ),
+        ]
+
+        # CustomEval uses min, DefaultEval uses default average
+        evaluators = [
+            _make_evaluator(
+                "CustomEval", lambda results: min(r.score for r in results)
+            ),
+            _make_evaluator("DefaultEval"),
+        ]
+
+        final_score, agg_metrics = compute_evaluator_scores(results, evaluators)
+
+        # CustomEval: min([0.8, 1.0]) = 0.8
+        # DefaultEval: avg([0.6, 0.4]) = 0.5
+        # Final: (0.8 + 0.5) / 2 = 0.65
+        assert agg_metrics == {
+            "CustomEval": pytest.approx(0.8),
+            "DefaultEval": pytest.approx(0.5),
+        }
+        assert final_score == pytest.approx(0.65)
+
+
+class TestBinaryClassificationReduceScores:
+    """Test BinaryClassificationEvaluator.reduce_scores for precision/recall/f-score."""
+
+    def _make_binary_evaluator(
+        self,
+        metric_type: str = "precision",
+        f_value: float = 1.0,
+    ):
+        from uipath.eval.evaluators.binary_classification_evaluator import (
+            BinaryClassificationEvaluator,
+        )
+
+        config = {
+            "name": "BinaryTest",
+            "target_output_key": "class",
+            "positive_class": "spam",
+            "metric_type": metric_type,
+            "f_value": f_value,
+        }
+        return BinaryClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": "binary-test"}
+        )
+
+    def _dp(self, predicted: str, expected: str) -> EvaluationResultDto:
+        """Create a EvaluationResultDto with BaseEvaluatorJustification."""
+        from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+
+        score = 1.0 if predicted == expected else 0.0
+        return EvaluationResultDto(
+            score=score,
+            details=BaseEvaluatorJustification(
+                expected=expected,
+                actual=predicted,
+            ).model_dump(),
+        )
+
+    def test_binary_precision(self) -> None:
+        """2 TP + 1 FP + 1 FN + 1 TN → precision = 2/(2+1) = 2/3."""
+        evaluator = self._make_binary_evaluator("precision")
+        results = [
+            self._dp("spam", "spam"),  # TP
+            self._dp("spam", "spam"),  # TP
+            self._dp("spam", "ham"),  # FP
+            self._dp("ham", "spam"),  # FN
+            self._dp("ham", "ham"),  # TN
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(2 / 3)
+
+    def test_binary_recall(self) -> None:
+        """2 TP + 1 FP + 1 FN + 1 TN → recall = 2/(2+1) = 2/3."""
+        evaluator = self._make_binary_evaluator("recall")
+        results = [
+            self._dp("spam", "spam"),
+            self._dp("spam", "spam"),
+            self._dp("spam", "ham"),
+            self._dp("ham", "spam"),
+            self._dp("ham", "ham"),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(2 / 3)
+
+    def test_binary_f1(self) -> None:
+        """2 TP + 1 FP + 1 FN → P=R=2/3, F1 = 2*P*R/(P+R) = 2/3."""
+        evaluator = self._make_binary_evaluator("f-score", f_value=1.0)
+        results = [
+            self._dp("spam", "spam"),
+            self._dp("spam", "spam"),
+            self._dp("spam", "ham"),
+            self._dp("ham", "spam"),
+            self._dp("ham", "ham"),
+        ]
+        p = 2 / 3
+        r = 2 / 3
+        expected_f1 = 2 * p * r / (p + r)
+        assert evaluator.reduce_scores(results) == pytest.approx(expected_f1)
+
+    def test_binary_f2(self) -> None:
+        """F2 weights recall more: (1+4)*P*R / (4*P+R)."""
+        evaluator = self._make_binary_evaluator("f-score", f_value=2.0)
+        # 3 TP, 1 FP, 2 FN → P=3/4, R=3/5
+        results = [
+            self._dp("spam", "spam"),  # TP
+            self._dp("spam", "spam"),  # TP
+            self._dp("spam", "spam"),  # TP
+            self._dp("spam", "ham"),  # FP
+            self._dp("ham", "spam"),  # FN
+            self._dp("ham", "spam"),  # FN
+        ]
+        p = 3 / 4
+        r = 3 / 5
+        beta_sq = 4.0
+        expected = (1 + beta_sq) * p * r / (beta_sq * p + r)
+        assert evaluator.reduce_scores(results) == pytest.approx(expected)
+
+    def test_binary_precision_no_positive_predictions(self) -> None:
+        """No positive predictions → precision = 0."""
+        evaluator = self._make_binary_evaluator("precision")
+        results = [
+            self._dp("ham", "spam"),  # FN
+            self._dp("ham", "spam"),  # FN
+            self._dp("ham", "ham"),  # TN
+            self._dp("ham", "ham"),  # TN
+        ]
+        assert evaluator.reduce_scores(results) == 0.0
+
+    def test_binary_recall_no_positive_expected(self) -> None:
+        """No positive expected → recall = 0."""
+        evaluator = self._make_binary_evaluator("recall")
+        results = [
+            self._dp("spam", "ham"),  # FP
+            self._dp("spam", "ham"),  # FP
+            self._dp("ham", "ham"),  # TN
+            self._dp("ham", "ham"),  # TN
+        ]
+        assert evaluator.reduce_scores(results) == 0.0
+
+    def test_binary_empty_scores(self) -> None:
+        """Empty results returns 0."""
+        evaluator = self._make_binary_evaluator("precision")
+        assert evaluator.reduce_scores([]) == 0.0
+
+    def test_binary_perfect_precision(self) -> None:
+        """All TP, no FP → precision = 1.0."""
+        evaluator = self._make_binary_evaluator("precision")
+        results = [
+            self._dp("spam", "spam"),
+            self._dp("spam", "spam"),
+            self._dp("spam", "spam"),
+        ]
+        assert evaluator.reduce_scores(results) == 1.0
+
+
+class TestMulticlassClassificationReduceScores:
+    """Test MulticlassClassificationEvaluator.reduce_scores for micro/macro metrics."""
+
+    def _make_multiclass_evaluator(
+        self,
+        classes: list[str],
+        metric_type: str = "precision",
+        averaging: str = "macro",
+        f_value: float = 1.0,
+    ):
+        from uipath.eval.evaluators.multiclass_classification_evaluator import (
+            MulticlassClassificationEvaluator,
+        )
+
+        config = {
+            "name": "MulticlassTest",
+            "target_output_key": "class",
+            "classes": classes,
+            "metric_type": metric_type,
+            "averaging": averaging,
+            "f_value": f_value,
+        }
+        return MulticlassClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": "multiclass-test"}
+        )
+
+    def _dp(self, predicted: str, expected: str) -> EvaluationResultDto:
+        """Create a EvaluationResultDto with BaseEvaluatorJustification."""
+        from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+
+        score = 1.0 if predicted == expected else 0.0
+        return EvaluationResultDto(
+            score=score,
+            details=BaseEvaluatorJustification(
+                expected=expected,
+                actual=predicted,
+            ).model_dump(),
+        )
+
+    def test_multiclass_macro_precision_perfect(self) -> None:
+        """All correct predictions → macro precision = 1.0."""
+        classes = ["cat", "dog", "bird"]
+        evaluator = self._make_multiclass_evaluator(classes, "precision", "macro")
+        results = [
+            self._dp("cat", "cat"),
+            self._dp("dog", "dog"),
+            self._dp("bird", "bird"),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(1.0)
+
+    def test_multiclass_macro_precision_known_confusion(self) -> None:
+        """Known confusion matrix → verify macro precision.
+
+        classes: [a, b, c]
+        Confusion matrix (confusion[pred][exp]):
+          pred a: [2, 1, 0]  → TP_a=2, FP_a=1
+          pred b: [0, 3, 1]  → TP_b=3, FP_b=1
+          pred c: [1, 0, 2]  → TP_c=2, FP_c=1
+
+        Precision: a=2/3, b=3/4, c=2/3
+        Macro precision = (2/3 + 3/4 + 2/3) / 3
+        """
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(classes, "precision", "macro")
+        results = [
+            # pred=a, exp=a (TP for a) ×2
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            # pred=a, exp=b (FP for a) ×1
+            self._dp("a", "b"),
+            # pred=b, exp=b (TP for b) ×3
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            # pred=b, exp=c (FP for b) ×1
+            self._dp("b", "c"),
+            # pred=c, exp=a (FP for c) ×1
+            self._dp("c", "a"),
+            # pred=c, exp=c (TP for c) ×2
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        expected = (2 / 3 + 3 / 4 + 2 / 3) / 3
+        assert evaluator.reduce_scores(results) == pytest.approx(expected)
+
+    def test_multiclass_macro_recall_known_confusion(self) -> None:
+        """Same confusion matrix, test macro recall.
+
+        Recall: a=2/(2+1)=2/3, b=3/(3+1)=3/4, c=2/(2+1)=2/3
+        Macro recall = (2/3 + 3/4 + 2/3) / 3
+        """
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(classes, "recall", "macro")
+        results = [
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            self._dp("a", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "c"),
+            self._dp("c", "a"),
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        expected = (2 / 3 + 3 / 4 + 2 / 3) / 3
+        assert evaluator.reduce_scores(results) == pytest.approx(expected)
+
+    def test_multiclass_micro_precision_known_confusion(self) -> None:
+        """Micro precision: global TP / (global TP + global FP).
+
+        Total TP = 2+3+2 = 7, Total FP = 1+1+1 = 3
+        Micro precision = 7/10 = 0.7
+        """
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(classes, "precision", "micro")
+        results = [
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            self._dp("a", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "c"),
+            self._dp("c", "a"),
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(7 / 10)
+
+    def test_multiclass_micro_recall_known_confusion(self) -> None:
+        """Micro recall: global TP / (global TP + global FN).
+
+        Total TP = 7, Total FN = 1+1+1 = 3
+        Micro recall = 7/10 = 0.7
+        """
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(classes, "recall", "micro")
+        results = [
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            self._dp("a", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "c"),
+            self._dp("c", "a"),
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(7 / 10)
+
+    def test_multiclass_micro_f1(self) -> None:
+        """Micro F1 with the same data. Since micro P = micro R = 0.7, F1 = 0.7."""
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(
+            classes, "f-score", "micro", f_value=1.0
+        )
+        results = [
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            self._dp("a", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "c"),
+            self._dp("c", "a"),
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        assert evaluator.reduce_scores(results) == pytest.approx(0.7)
+
+    def test_multiclass_macro_f1(self) -> None:
+        """Macro F1 from per-class F1 values."""
+        classes = ["a", "b", "c"]
+        evaluator = self._make_multiclass_evaluator(
+            classes, "f-score", "macro", f_value=1.0
+        )
+        results = [
+            self._dp("a", "a"),
+            self._dp("a", "a"),
+            self._dp("a", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "b"),
+            self._dp("b", "c"),
+            self._dp("c", "a"),
+            self._dp("c", "c"),
+            self._dp("c", "c"),
+        ]
+        # Per-class: P_a=R_a=2/3→F1_a=2/3, P_b=R_b=3/4→F1_b=3/4, P_c=R_c=2/3→F1_c=2/3
+        expected = (2 / 3 + 3 / 4 + 2 / 3) / 3
+        assert evaluator.reduce_scores(results) == pytest.approx(expected)
+
+    def test_multiclass_empty_scores(self) -> None:
+        """Empty results returns 0."""
+        evaluator = self._make_multiclass_evaluator(["a", "b"], "precision", "macro")
+        assert evaluator.reduce_scores([]) == 0.0
+
+    def test_multiclass_two_classes(self) -> None:
+        """Binary-like scenario with 2 classes via multiclass evaluator.
+
+        classes: [pos, neg]
+        2 TP, 1 FP, 1 FN → precision_pos=2/3, precision_neg=1/2
+        Macro precision = (2/3 + 1/2) / 2
+        """
+        classes = ["pos", "neg"]
+        evaluator = self._make_multiclass_evaluator(classes, "precision", "macro")
+        results = [
+            self._dp("pos", "pos"),  # TP for pos
+            self._dp("pos", "pos"),  # TP for pos
+            self._dp("pos", "neg"),  # FP for pos
+            self._dp("neg", "pos"),  # FN for pos
+            self._dp("neg", "neg"),  # TN for pos / TP for neg
+        ]
+        # confusion: pred_pos=[2, 1], pred_neg=[1, 1]
+        # P_pos = 2/3, P_neg = 1/2
+        expected = (2 / 3 + 1 / 2) / 2
+        assert evaluator.reduce_scores(results) == pytest.approx(expected)
diff --git a/packages/uipath/tests/evaluators/test_evaluator_factory.py b/packages/uipath/tests/evaluators/test_evaluator_factory.py
new file mode 100644
index 000000000..0e44c4697
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_evaluator_factory.py
@@ -0,0 +1,450 @@
+"""Tests for evaluator factory functionality.
+
+This module tests:
+- EvaluatorFactory.create_evaluator() with various configurations
+- Flexible name and description field handling (top-level vs config-level)
+- Field precedence when specified in multiple locations
+- Proper instantiation across all evaluator types
+"""
+
+from typing import Any
+
+import pytest
+from pytest_mock.plugin import MockerFixture
+
+from uipath.eval.evaluators.contains_evaluator import ContainsEvaluator
+from uipath.eval.evaluators.evaluator_factory import EvaluatorFactory
+from uipath.eval.evaluators.exact_match_evaluator import ExactMatchEvaluator
+from uipath.eval.evaluators.json_similarity_evaluator import JsonSimilarityEvaluator
+from uipath.eval.evaluators.llm_judge_output_evaluator import LLMJudgeOutputEvaluator
+from uipath.eval.evaluators.llm_judge_trajectory_evaluator import (
+    LLMJudgeTrajectoryEvaluator,
+    LLMJudgeTrajectorySimulationEvaluator,
+)
+from uipath.eval.evaluators.tool_call_args_evaluator import ToolCallArgsEvaluator
+from uipath.eval.evaluators.tool_call_count_evaluator import ToolCallCountEvaluator
+from uipath.eval.evaluators.tool_call_order_evaluator import ToolCallOrderEvaluator
+from uipath.eval.evaluators.tool_call_output_evaluator import ToolCallOutputEvaluator
+
+
+class TestEvaluatorFactoryFieldHandling:
+    """Test field handling (name, description) in evaluator factory."""
+
+    @pytest.fixture
+    def base_exact_match_config(self) -> dict[str, Any]:
+        """Base configuration for ExactMatchEvaluator."""
+        return {
+            "version": "1.0",
+            "id": "TestExactMatch",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {
+                "targetOutputKey": "*",
+                "negated": False,
+                "ignoreCase": False,
+            },
+        }
+
+    def test_name_in_config_only(self, base_exact_match_config: dict[str, Any]) -> None:
+        """Test that name specified in evaluatorConfig is correctly set.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["evaluatorConfig"]["name"] = "NameFromConfig"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.name == "NameFromConfig"
+
+    def test_name_at_top_level_only(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that name specified at top level is correctly merged into config.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = "NameFromTopLevel"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.name == "NameFromTopLevel"
+
+    def test_name_in_both_locations_top_level_wins(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that top-level name takes precedence over config-level name.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = "TopLevelName"
+        base_exact_match_config["evaluatorConfig"]["name"] = "ConfigLevelName"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.name == "TopLevelName"
+
+    def test_description_in_config_only(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that description specified in evaluatorConfig is correctly set.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["evaluatorConfig"]["name"] = "TestEvaluator"
+        base_exact_match_config["evaluatorConfig"]["description"] = (
+            "Description from config"
+        )
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.description == "Description from config"
+
+    def test_description_at_top_level_only(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that description specified at top level is correctly merged into config.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = "TestEvaluator"
+        base_exact_match_config["description"] = "Description from top level"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.description == "Description from top level"
+
+    def test_description_in_both_locations_top_level_wins(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that top-level description takes precedence over config-level description.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = "TestEvaluator"
+        base_exact_match_config["description"] = "Top level description"
+        base_exact_match_config["evaluatorConfig"]["description"] = (
+            "Config level description"
+        )
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.description == "Top level description"
+
+    def test_both_name_and_description_at_top_level(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that both name and description can be specified at top level.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = "CustomName"
+        base_exact_match_config["description"] = "Custom description"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        assert evaluator.name == "CustomName"
+        assert evaluator.description == "Custom description"
+
+    def test_no_name_or_description_uses_defaults(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that evaluator uses defaults when name/description not specified.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        # Name should have a default from the config class
+        assert evaluator.name is not None
+        # Description defaults to empty string
+        assert evaluator.description == ""
+
+    def test_empty_string_values_are_handled_correctly(
+        self, base_exact_match_config: dict[str, Any]
+    ) -> None:
+        """Test that empty string values for name/description are handled properly.
+
+        Args:
+            base_exact_match_config: Base evaluator configuration fixture
+        """
+        base_exact_match_config["name"] = ""
+        base_exact_match_config["description"] = ""
+        base_exact_match_config["evaluatorConfig"]["name"] = "ConfigName"
+        base_exact_match_config["evaluatorConfig"]["description"] = "ConfigDescription"
+
+        evaluator = EvaluatorFactory.create_evaluator(base_exact_match_config)
+
+        assert isinstance(evaluator, ExactMatchEvaluator)
+        # Empty strings should still override (top-level takes precedence)
+        assert evaluator.name == ""
+        assert evaluator.description == ""
+
+
+class TestEvaluatorFactoryAcrossTypes:
+    """Test that field handling works consistently across all evaluator types."""
+
+    @pytest.mark.parametrize(
+        "evaluator_type_id,expected_class",
+        [
+            ("uipath-exact-match", ExactMatchEvaluator),
+            ("uipath-contains", ContainsEvaluator),
+            ("uipath-json-similarity", JsonSimilarityEvaluator),
+            ("uipath-tool-call-count", ToolCallCountEvaluator),
+            ("uipath-tool-call-order", ToolCallOrderEvaluator),
+            ("uipath-tool-call-args", ToolCallArgsEvaluator),
+            ("uipath-tool-call-output", ToolCallOutputEvaluator),
+        ],
+    )
+    def test_top_level_name_and_description_across_evaluator_types(
+        self, evaluator_type_id: str, expected_class: type
+    ) -> None:
+        """Test that top-level name and description work for various evaluator types.
+
+        Args:
+            evaluator_type_id: The evaluator type identifier
+            expected_class: The expected evaluator class type
+        """
+        config = {
+            "version": "1.0",
+            "id": f"Test{evaluator_type_id}",
+            "name": f"Custom{evaluator_type_id}Name",
+            "description": f"Custom {evaluator_type_id} description",
+            "evaluatorTypeId": evaluator_type_id,
+            "evaluatorConfig": {},
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        assert isinstance(evaluator, expected_class)
+        assert evaluator.name == f"Custom{evaluator_type_id}Name"
+        assert evaluator.description == f"Custom {evaluator_type_id} description"
+
+    def test_llm_judge_output_evaluator_field_handling(
+        self, mocker: "MockerFixture"
+    ) -> None:
+        """Test field handling for LLMJudgeOutputEvaluator.
+
+        Args:
+            mocker: Pytest mock fixture
+        """
+        # Mock the UiPath SDK to avoid needing credentials
+        mock_llm_service = mocker.MagicMock()
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.LLMJudgeMixin._get_llm_service",
+            return_value=mock_llm_service,
+        )
+
+        config = {
+            "version": "1.0",
+            "id": "TestLLMJudgeOutput",
+            "name": "CustomLLMJudgeName",
+            "description": "Custom LLM judge description",
+            "evaluatorTypeId": "uipath-llm-judge-output-semantic-similarity",
+            "evaluatorConfig": {
+                "model": "gpt-4",
+                "temperature": 0.0,
+            },
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        assert isinstance(evaluator, LLMJudgeOutputEvaluator)
+        assert evaluator.name == "CustomLLMJudgeName"
+        assert evaluator.description == "Custom LLM judge description"
+
+    def test_llm_judge_trajectory_evaluator_field_handling(
+        self, mocker: "MockerFixture"
+    ) -> None:
+        """Test field handling for LLMJudgeTrajectoryEvaluator.
+
+        Args:
+            mocker: Pytest mock fixture
+        """
+        # Mock the UiPath SDK to avoid needing credentials
+        mock_llm_service = mocker.MagicMock()
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.LLMJudgeMixin._get_llm_service",
+            return_value=mock_llm_service,
+        )
+
+        config = {
+            "version": "1.0",
+            "id": "TestLLMJudgeTrajectory",
+            "name": "CustomTrajectoryName",
+            "description": "Custom trajectory description",
+            "evaluatorTypeId": "uipath-llm-judge-trajectory-similarity",
+            "evaluatorConfig": {
+                "model": "gpt-4",
+                "temperature": 0.0,
+            },
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        assert isinstance(evaluator, LLMJudgeTrajectoryEvaluator)
+        assert evaluator.name == "CustomTrajectoryName"
+        assert evaluator.description == "Custom trajectory description"
+
+    def test_llm_judge_trajectory_simulation_evaluator_field_handling(
+        self, mocker: "MockerFixture"
+    ) -> None:
+        """Test field handling for LLMJudgeTrajectorySimulationEvaluator.
+
+        Args:
+            mocker: Pytest mock fixture
+        """
+        # Mock the UiPath SDK to avoid needing credentials
+        mock_llm_service = mocker.MagicMock()
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.LLMJudgeMixin._get_llm_service",
+            return_value=mock_llm_service,
+        )
+
+        config = {
+            "version": "1.0",
+            "id": "TestLLMJudgeTrajectorySimulation",
+            "name": "CustomSimulationName",
+            "description": "Custom simulation description",
+            "evaluatorTypeId": "uipath-llm-judge-trajectory-simulation",
+            "evaluatorConfig": {
+                "model": "gpt-4",
+                "temperature": 0.0,
+            },
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        assert isinstance(evaluator, LLMJudgeTrajectorySimulationEvaluator)
+        assert evaluator.name == "CustomSimulationName"
+        assert evaluator.description == "Custom simulation description"
+
+
+class TestEvaluatorFactoryPrepareConfig:
+    """Test the _prepare_evaluator_config helper method."""
+
+    def test_prepare_config_empty_input(self) -> None:
+        """Test _prepare_evaluator_config with empty input."""
+        result = EvaluatorFactory._prepare_evaluator_config({})
+
+        assert isinstance(result, dict)
+        assert result == {}
+
+    def test_prepare_config_only_evaluator_config(self) -> None:
+        """Test _prepare_evaluator_config with only evaluatorConfig."""
+        data = {
+            "evaluatorConfig": {
+                "name": "TestName",
+                "description": "TestDescription",
+                "someOtherField": "value",
+            }
+        }
+
+        result = EvaluatorFactory._prepare_evaluator_config(data)
+
+        assert result == {
+            "name": "TestName",
+            "description": "TestDescription",
+            "someOtherField": "value",
+        }
+
+    def test_prepare_config_top_level_overrides(self) -> None:
+        """Test that top-level fields override config-level fields."""
+        data = {
+            "name": "TopLevelName",
+            "description": "TopLevelDescription",
+            "evaluatorConfig": {
+                "name": "ConfigName",
+                "description": "ConfigDescription",
+                "otherField": "value",
+            },
+        }
+
+        result = EvaluatorFactory._prepare_evaluator_config(data)
+
+        assert result["name"] == "TopLevelName"
+        assert result["description"] == "TopLevelDescription"
+        assert result["otherField"] == "value"
+
+    def test_prepare_config_preserves_other_fields(self) -> None:
+        """Test that other config fields are preserved."""
+        data = {
+            "name": "NewName",
+            "evaluatorConfig": {
+                "name": "OldName",
+                "targetOutputKey": "*",
+                "caseSensitive": False,
+                "nested": {"key": "value"},
+            },
+        }
+
+        result = EvaluatorFactory._prepare_evaluator_config(data)
+
+        assert result["name"] == "NewName"
+        assert result["targetOutputKey"] == "*"
+        assert result["caseSensitive"] is False
+        assert result["nested"] == {"key": "value"}
+
+    def test_prepare_config_handles_non_dict_evaluator_config(self) -> None:
+        """Test that non-dict evaluatorConfig is handled gracefully."""
+        data = {"name": "TestName", "evaluatorConfig": "not a dict"}
+
+        result = EvaluatorFactory._prepare_evaluator_config(data)
+
+        assert isinstance(result, dict)
+        assert result["name"] == "TestName"
+
+
+class TestEvaluatorFactoryPropertyAccess:
+    """Test that name and description properties work after factory instantiation."""
+
+    def test_property_getters_work(self) -> None:
+        """Test that property getters return correct values."""
+        config = {
+            "version": "1.0",
+            "id": "TestEvaluator",
+            "name": "InitialName",
+            "description": "Initial description",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {},
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        # Test getters
+        assert evaluator.name == "InitialName"
+        assert evaluator.description == "Initial description"
+
+    def test_property_setters_work(self) -> None:
+        """Test that property setters correctly update values."""
+        config = {
+            "version": "1.0",
+            "id": "TestEvaluator",
+            "name": "InitialName",
+            "description": "Initial description",
+            "evaluatorTypeId": "uipath-exact-match",
+            "evaluatorConfig": {},
+        }
+
+        evaluator = EvaluatorFactory.create_evaluator(config)
+
+        # Test setters
+        evaluator.name = "UpdatedName"
+        evaluator.description = "Updated description"
+
+        assert evaluator.name == "UpdatedName"
+        assert evaluator.description == "Updated description"
diff --git a/packages/uipath/tests/evaluators/test_evaluator_helpers.py b/packages/uipath/tests/evaluators/test_evaluator_helpers.py
new file mode 100644
index 000000000..6064381cb
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_evaluator_helpers.py
@@ -0,0 +1,1200 @@
+"""Test module for evaluator helper functions.
+
+This module contains comprehensive tests for helper functions used by coded evaluators,
+including functions for tool call extraction (`extract_tool_calls`, `extract_tool_calls_names`,
+`extract_tool_calls_outputs`) and various scoring functions (`tool_calls_args_score`,
+`tool_calls_count_score`, `tool_calls_order_score`, `tool_calls_output_score`).
+These tests ensure consistent behavior and proper justification structures for each helper.
+"""
+
+from typing import Any
+
+import pytest
+
+from uipath.eval._helpers.evaluators_helpers import (
+    _calls_match,
+    _match_key,
+    _sanitize_tool_name,
+    extract_tool_calls,
+    extract_tool_calls_names,
+    extract_tool_calls_outputs,
+    tool_calls_args_score,
+    tool_calls_count_score,
+    tool_calls_order_score,
+    tool_calls_output_score,
+)
+from uipath.eval.models.models import ToolCall, ToolOutput
+
+
+class TestToolCallsOrderScore:
+    """Test tool_calls_order_score helper function."""
+
+    def test_empty_both_lists(self) -> None:
+        """Test when both expected and actual lists are empty."""
+        score, justification = tool_calls_order_score([], [], strict=False)
+
+        assert score == 1.0
+        assert isinstance(justification, dict)
+        assert "actual" in justification
+        assert "expected" in justification
+        assert "lcs" in justification
+        assert justification["lcs"] == []
+
+    def test_empty_actual_list(self) -> None:
+        """Test when actual list is empty but expected is not."""
+        score, justification = tool_calls_order_score([], ["tool1"], strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification, dict)
+        assert justification["actual"] == str([])
+        assert justification["expected"] == str(["tool1"])
+        assert justification["lcs"] == []
+
+    def test_empty_expected_list(self) -> None:
+        """Test when expected list is empty but actual is not."""
+        score, justification = tool_calls_order_score(["tool1"], [], strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification, dict)
+        assert justification["actual"] == str(["tool1"])
+        assert justification["expected"] == str([])
+        assert justification["lcs"] == []
+
+    def test_perfect_match_non_strict(self) -> None:
+        """Test perfect match in non-strict mode."""
+        actual = ["tool1", "tool2", "tool3"]
+        expected = ["tool1", "tool2", "tool3"]
+        score, justification = tool_calls_order_score(actual, expected, strict=False)
+
+        assert score == 1.0
+        assert justification["lcs"] == expected
+        assert justification["actual"] == str(actual)
+        assert justification["expected"] == str(expected)
+
+    def test_perfect_match_strict(self) -> None:
+        """Test perfect match in strict mode."""
+        actual = ["tool1", "tool2", "tool3"]
+        expected = ["tool1", "tool2", "tool3"]
+        score, justification = tool_calls_order_score(actual, expected, strict=True)
+
+        assert score == 1.0
+        assert justification["lcs"] == expected
+
+    def test_partial_match_non_strict(self) -> None:
+        """Test partial match in non-strict mode (LCS calculation)."""
+        actual = ["tool1", "tool3", "tool2"]
+        expected = ["tool1", "tool2", "tool3"]
+        score, justification = tool_calls_order_score(actual, expected, strict=False)
+
+        # LCS should be calculated - score should be between 0 and 1
+        assert 0.0 < score < 1.0
+        assert len(justification["lcs"]) > 0
+
+    def test_mismatch_strict(self) -> None:
+        """Test mismatch in strict mode."""
+        actual = ["tool2", "tool1"]
+        expected = ["tool1", "tool2"]
+        score, justification = tool_calls_order_score(actual, expected, strict=True)
+
+        assert score == 0.0
+        assert justification["lcs"] == []
+
+
+class TestToolCallsCountScore:
+    """Test tool_calls_count_score helper function."""
+
+    def test_empty_both_dicts(self) -> None:
+        """Test when both expected and actual dicts are empty."""
+        score, justification = tool_calls_count_score({}, {}, strict=False)
+
+        assert score == 1.0
+        assert isinstance(justification, dict)
+        assert "explained_tool_calls_count" in justification
+        assert isinstance(justification["explained_tool_calls_count"], dict)
+        assert "_result" in justification["explained_tool_calls_count"]
+
+    def test_empty_actual_dict(self) -> None:
+        """Test when actual dict is empty but expected is not."""
+        expected = {"tool1": ("==", 1)}
+        score, justification = tool_calls_count_score({}, expected, strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_count"], dict)
+        assert "_result" in justification["explained_tool_calls_count"]
+
+    def test_empty_expected_dict(self) -> None:
+        """Test when expected dict is empty but actual is not."""
+        actual = {"tool1": 1}
+        score, justification = tool_calls_count_score(actual, {}, strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_count"], dict)
+        assert "_result" in justification["explained_tool_calls_count"]
+
+    def test_perfect_match_non_strict(self) -> None:
+        """Test perfect match in non-strict mode."""
+        actual = {"tool1": 2, "tool2": 1}
+        expected = {"tool1": ("==", 2), "tool2": ("==", 1)}
+        score, justification = tool_calls_count_score(actual, expected, strict=False)
+
+        assert score == 1.0
+        assert "tool1" in justification["explained_tool_calls_count"]
+        assert "tool2" in justification["explained_tool_calls_count"]
+        assert "Score: 1.0" in justification["explained_tool_calls_count"]["tool1"]
+        assert "Score: 1.0" in justification["explained_tool_calls_count"]["tool2"]
+
+    def test_partial_match_non_strict(self) -> None:
+        """Test partial match in non-strict mode."""
+        actual = {"tool1": 2, "tool2": 0}
+        expected = {"tool1": ("==", 2), "tool2": ("==", 1)}
+        score, justification = tool_calls_count_score(actual, expected, strict=False)
+
+        assert score == 0.5  # 1 out of 2 matches
+        assert "Score: 1.0" in justification["explained_tool_calls_count"]["tool1"]
+        assert "Score: 0.0" in justification["explained_tool_calls_count"]["tool2"]
+
+    def test_mismatch_strict(self) -> None:
+        """Test mismatch in strict mode (early return)."""
+        actual = {"tool1": 2, "tool2": 0}
+        expected = {"tool1": ("==", 2), "tool2": ("==", 1)}
+        score, justification = tool_calls_count_score(actual, expected, strict=True)
+
+        # Should return 0 and only include the failing tool
+        assert score == 0.0
+        assert len(justification["explained_tool_calls_count"]) == 1
+        assert "tool2" in justification["explained_tool_calls_count"]
+
+    def test_comparator_operations(self) -> None:
+        """Test different comparator operations."""
+        actual = {"tool1": 5}
+
+        # Test greater than
+        expected_gt = {"tool1": (">", 3)}
+        score, justification = tool_calls_count_score(actual, expected_gt, strict=False)
+        assert score == 1.0
+
+        # Test less than or equal
+        expected_le = {"tool1": ("<=", 5)}
+        score, justification = tool_calls_count_score(actual, expected_le, strict=False)
+        assert score == 1.0
+
+        # Test not equal
+        expected_ne = {"tool1": ("!=", 3)}
+        score, justification = tool_calls_count_score(actual, expected_ne, strict=False)
+        assert score == 1.0
+
+
+class TestToolCallsArgsScore:
+    """Test tool_calls_args_score helper function."""
+
+    def test_empty_both_lists(self) -> None:
+        """Test when both expected and actual lists are empty."""
+        score, justification = tool_calls_args_score([], [], strict=False)
+
+        assert score == 1.0
+        assert isinstance(justification, dict)
+        assert "explained_tool_calls_args" in justification
+        assert isinstance(justification["explained_tool_calls_args"], dict)
+        assert "_result" in justification["explained_tool_calls_args"]
+
+    def test_empty_actual_list(self) -> None:
+        """Test when actual list is empty but expected is not."""
+        expected = [ToolCall(name="tool1", args={"arg": "val"})]
+        score, justification = tool_calls_args_score([], expected, strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_args"], dict)
+        assert "_result" in justification["explained_tool_calls_args"]
+
+    def test_empty_expected_list(self) -> None:
+        """Test when expected list is empty but actual is not."""
+        actual = [ToolCall(name="tool1", args={"arg": "val"})]
+        score, justification = tool_calls_args_score(actual, [], strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_args"], dict)
+        assert "_result" in justification["explained_tool_calls_args"]
+
+    def test_perfect_match_exact_mode(self) -> None:
+        """Test perfect match in exact mode (default)."""
+        actual = [ToolCall(name="tool1", args={"arg1": "val1", "arg2": "val2"})]
+        expected = [ToolCall(name="tool1", args={"arg1": "val1", "arg2": "val2"})]
+        score, justification = tool_calls_args_score(
+            actual, expected, strict=False, subset=False
+        )
+
+        assert score == 1.0
+        assert "tool1_0" in justification["explained_tool_calls_args"]
+        assert "Score: 1.0" in justification["explained_tool_calls_args"]["tool1_0"]
+
+    def test_perfect_match_subset_mode(self) -> None:
+        """Test perfect match in subset mode."""
+        actual = [
+            ToolCall(
+                name="tool1", args={"arg1": "val1", "arg2": "val2", "extra": "val"}
+            )
+        ]
+        expected = [ToolCall(name="tool1", args={"arg1": "val1", "arg2": "val2"})]
+        score, justification = tool_calls_args_score(
+            actual, expected, strict=False, subset=True
+        )
+
+        assert score == 1.0
+        assert "Score: 1.0" in justification["explained_tool_calls_args"]["tool1_0"]
+
+    def test_mismatch_exact_mode(self) -> None:
+        """Test mismatch in exact mode."""
+        actual = [ToolCall(name="tool1", args={"arg1": "val1"})]
+        expected = [ToolCall(name="tool1", args={"arg1": "val1", "arg2": "val2"})]
+        score, justification = tool_calls_args_score(
+            actual, expected, strict=False, subset=False
+        )
+
+        assert score == 0.0
+        assert "Score: 0.0" in justification["explained_tool_calls_args"]["tool1_0"]
+
+    def test_multiple_tool_calls(self) -> None:
+        """Test with multiple tool calls."""
+        actual = [
+            ToolCall(name="tool1", args={"arg1": "val1"}),
+            ToolCall(name="tool2", args={"arg2": "val2"}),
+        ]
+        expected = [
+            ToolCall(name="tool1", args={"arg1": "val1"}),
+            ToolCall(name="tool2", args={"arg2": "val2"}),
+        ]
+        score, justification = tool_calls_args_score(actual, expected, strict=False)
+
+        assert score == 1.0
+        assert len(justification["explained_tool_calls_args"]) == 2
+        assert "tool1_0" in justification["explained_tool_calls_args"]
+        assert "tool2_0" in justification["explained_tool_calls_args"]
+
+    def test_strict_mode_with_mismatch(self) -> None:
+        """Test strict mode with partial matches."""
+        actual = [
+            ToolCall(name="tool1", args={"arg1": "val1"}),
+            ToolCall(name="tool2", args={"arg2": "wrong"}),
+        ]
+        expected = [
+            ToolCall(name="tool1", args={"arg1": "val1"}),
+            ToolCall(name="tool2", args={"arg2": "val2"}),
+        ]
+        score, justification = tool_calls_args_score(actual, expected, strict=True)
+
+        # In strict mode, partial match should still score proportionally unless all match
+        assert score == 0.0  # strict mode requires all to match
+
+
+class TestToolCallsOutputScore:
+    """Test tool_calls_output_score helper function."""
+
+    def test_empty_both_lists(self) -> None:
+        """Test when both expected and actual lists are empty."""
+        score, justification = tool_calls_output_score([], [], strict=False)
+
+        assert score == 1.0
+        assert isinstance(justification, dict)
+        assert "explained_tool_calls_outputs" in justification
+        assert isinstance(justification["explained_tool_calls_outputs"], dict)
+        assert "_result" in justification["explained_tool_calls_outputs"]
+
+    def test_empty_actual_list(self) -> None:
+        """Test when actual list is empty but expected is not."""
+        expected = [ToolOutput(name="tool1", output="output1")]
+        score, justification = tool_calls_output_score([], expected, strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_outputs"], dict)
+        assert "_result" in justification["explained_tool_calls_outputs"]
+
+    def test_empty_expected_list(self) -> None:
+        """Test when expected list is empty but actual is not."""
+        actual = [ToolOutput(name="tool1", output="output1")]
+        score, justification = tool_calls_output_score(actual, [], strict=False)
+
+        assert score == 0.0
+        assert isinstance(justification["explained_tool_calls_outputs"], dict)
+        assert "_result" in justification["explained_tool_calls_outputs"]
+
+    def test_perfect_match_non_strict(self) -> None:
+        """Test perfect match in non-strict mode."""
+        actual = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        expected = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        score, justification = tool_calls_output_score(actual, expected, strict=False)
+
+        assert score == 1.0
+        # Check that justifications use per-tool indexed keys
+        justification_keys = list(justification["explained_tool_calls_outputs"].keys())
+        assert "tool1_0" in justification_keys
+        assert "tool2_0" in justification_keys
+
+    def test_perfect_match_strict(self) -> None:
+        """Test perfect match in strict mode."""
+        actual = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        expected = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        score, justification = tool_calls_output_score(actual, expected, strict=True)
+
+        assert score == 1.0
+
+    def test_partial_match_non_strict(self) -> None:
+        """Test partial match in non-strict mode."""
+        actual = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="wrong_output"),
+        ]
+        expected = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        score, justification = tool_calls_output_score(actual, expected, strict=False)
+
+        assert score == 0.5  # 1 out of 2 matches
+        # Check individual scores in justification
+        justification_values = list(
+            justification["explained_tool_calls_outputs"].values()
+        )
+        assert any("Score: 1.0" in val for val in justification_values)
+        assert any("Score: 0.0" in val for val in justification_values)
+
+    def test_mismatch_strict_early_return(self) -> None:
+        """Test mismatch in strict mode (early return)."""
+        actual = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="wrong_output"),
+        ]
+        expected = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool2", output="output2"),
+        ]
+        score, justification = tool_calls_output_score(actual, expected, strict=True)
+
+        # Should return 0 immediately on first mismatch
+        assert score == 0.0
+        # Should only contain the failing tool call in justification
+        assert len(justification["explained_tool_calls_outputs"]) == 1
+
+    def test_duplicate_tool_names(self) -> None:
+        """Test with duplicate tool names (one-to-one matching)."""
+        actual = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool1", output="output2"),
+        ]
+        expected = [
+            ToolOutput(name="tool1", output="output1"),
+            ToolOutput(name="tool1", output="output2"),
+        ]
+        score, justification = tool_calls_output_score(actual, expected, strict=False)
+
+        assert score == 1.0
+        # Should have per-tool indexed keys to distinguish duplicate tool names
+        justification_keys = list(justification["explained_tool_calls_outputs"].keys())
+        assert "tool1_0" in justification_keys
+        assert "tool1_1" in justification_keys
+
+
+class TestExtractionFunctions:
+    """Test extraction functions used by evaluators."""
+
+    @pytest.fixture
+    def sample_spans(self) -> list[Any]:
+        """Create sample ReadableSpan objects for testing."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        return [
+            ReadableSpan(
+                name="tool1",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "tool1",
+                    "input.value": "{'arg1': 'value1', 'arg2': 42}",
+                    "output.value": '{"content": "result1"}',
+                },
+            ),
+            ReadableSpan(
+                name="tool2",
+                start_time=1,
+                end_time=2,
+                attributes={
+                    "tool.name": "tool2",
+                    "input.value": "{'param': 'test'}",
+                    "output.value": '{"content": "result2"}',
+                },
+            ),
+            ReadableSpan(
+                name="non_tool_span",
+                start_time=2,
+                end_time=3,
+                attributes={
+                    "span.type": "other",
+                    "some.data": "value",
+                },
+            ),
+            ReadableSpan(
+                name="tool3",
+                start_time=3,
+                end_time=4,
+                attributes={
+                    "tool.name": "tool3",
+                    "input.value": "{}",
+                    "output.value": '{"content": ""}',
+                },
+            ),
+        ]
+
+    @pytest.fixture
+    def spans_with_json_input(self) -> list[Any]:
+        """Create spans with JSON string input values."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        return [
+            ReadableSpan(
+                name="json_tool",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "json_tool",
+                    "input.value": '{"key": "value", "number": 123}',
+                    "output.value": '{"content": "json_result"}',
+                },
+            ),
+        ]
+
+    @pytest.fixture
+    def spans_with_dict_input(self) -> list[Any]:
+        """Create spans with dict input values."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        return [
+            ReadableSpan(
+                name="dict_tool",
+                start_time=0,
+                end_time=1,
+                attributes={  # pyright: ignore[reportArgumentType]
+                    "tool.name": "dict_tool",
+                    "input.value": {"direct": "dict", "num": 456},  # type: ignore[dict-item]
+                    "output.value": {"content": "dict_result"},  # type: ignore[dict-item]
+                },
+            ),
+        ]
+
+    @pytest.fixture
+    def spans_with_invalid_input(self) -> list[Any]:
+        """Create spans with invalid input values (for testing input parsing)."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        return [
+            ReadableSpan(
+                name="invalid_tool",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "invalid_tool",
+                    "input.value": "invalid json {",
+                    "output.value": '{"content": "invalid_result"}',
+                },
+            ),
+        ]
+
+    def test_extract_tool_calls_names_empty(self) -> None:
+        """Test tool call name extraction with empty list."""
+        result = extract_tool_calls_names([])
+        assert isinstance(result, list)
+        assert result == []
+
+    def test_extract_tool_calls_names_with_tools(self, sample_spans: list[Any]) -> None:
+        """Test tool call name extraction with actual tool spans."""
+        result = extract_tool_calls_names(sample_spans)
+
+        assert isinstance(result, list)
+        assert len(result) == 3  # Only spans with tool.name attribute
+        assert result == ["tool1", "tool2", "tool3"]
+
+    def test_extract_tool_calls_names_preserves_order(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test that tool call name extraction preserves order."""
+        # Reverse the spans to test order preservation
+        reversed_spans = list(reversed(sample_spans))
+        result = extract_tool_calls_names(reversed_spans)
+
+        # Should be in reverse order since we reversed the input
+        expected = ["tool3", "tool2", "tool1"]
+        assert result == expected
+
+    def test_extract_tool_calls_names_filters_non_tool_spans(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test that non-tool spans are filtered out."""
+        result = extract_tool_calls_names(sample_spans)
+
+        # Should not include 'non_tool_span' which doesn't have tool.name
+        assert "non_tool_span" not in result
+        assert len(result) == 3
+
+    def test_extract_tool_calls_empty(self) -> None:
+        """Test tool call extraction with empty list."""
+        result = extract_tool_calls([])
+        assert isinstance(result, list)
+        assert result == []
+
+    def test_extract_tool_calls_with_string_input(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test tool call extraction with string input values."""
+        result = extract_tool_calls(sample_spans)
+
+        assert isinstance(result, list)
+        assert len(result) == 3
+
+        # Check first tool call
+        tool1 = result[0]
+        assert tool1.name == "tool1"
+        assert tool1.args == {"arg1": "value1", "arg2": 42}
+
+        # Check second tool call
+        tool2 = result[1]
+        assert tool2.name == "tool2"
+        assert tool2.args == {"param": "test"}
+
+        # Check third tool call (empty args)
+        tool3 = result[2]
+        assert tool3.name == "tool3"
+        assert tool3.args == {}
+
+    def test_extract_tool_calls_with_dict_input(
+        self, spans_with_dict_input: list[Any]
+    ) -> None:
+        """Test tool call extraction with direct dict input values."""
+        result = extract_tool_calls(spans_with_dict_input)
+
+        assert len(result) == 1
+        tool_call = result[0]
+        assert tool_call.name == "dict_tool"
+        assert tool_call.args == {"direct": "dict", "num": 456}
+
+    def test_extract_tool_calls_with_invalid_input(
+        self, spans_with_invalid_input: list[Any]
+    ) -> None:
+        """Test tool call extraction with invalid JSON input."""
+        result = extract_tool_calls(spans_with_invalid_input)
+
+        assert len(result) == 1
+        tool_call = result[0]
+        assert tool_call.name == "invalid_tool"
+        assert tool_call.args == {}  # Should default to empty dict on parse error
+
+    def test_extract_tool_calls_missing_input_value(self) -> None:
+        """Test tool call extraction when input.value is missing."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="missing_input_tool",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "missing_input_tool",
+                # No input.value attribute
+                "output.value": "result",
+            },
+        )
+
+        result = extract_tool_calls([span])
+        assert len(result) == 1
+        assert result[0].name == "missing_input_tool"
+        assert result[0].args == {}
+
+    def test_extract_tool_calls_outputs_empty(self) -> None:
+        """Test tool call output extraction with empty list."""
+        result = extract_tool_calls_outputs([])
+        assert isinstance(result, list)
+        assert result == []
+
+    def test_extract_tool_calls_outputs_with_tools(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test tool call output extraction with actual tool spans."""
+        result = extract_tool_calls_outputs(sample_spans)
+
+        assert isinstance(result, list)
+        assert len(result) == 3  # Only spans with tool.name attribute
+
+        # Check outputs
+        assert result[0].name == "tool1"
+        assert result[0].output == "result1"
+
+        assert result[1].name == "tool2"
+        assert result[1].output == "result2"
+
+        assert result[2].name == "tool3"
+        assert result[2].output == ""
+
+    def test_extract_tool_calls_outputs_missing_output_value(self) -> None:
+        """Test tool call output extraction when output.value is missing."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="missing_output_tool",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "missing_output_tool",
+                "input.value": "{}",
+                # No output.value attribute
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "missing_output_tool"
+        assert result[0].output == ""  # Should default to empty string
+
+    def test_extract_tool_calls_outputs_preserves_order(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test that tool call output extraction preserves order."""
+        result = extract_tool_calls_outputs(sample_spans)
+
+        # Should match the order of spans with tool.name
+        expected_names = ["tool1", "tool2", "tool3"]
+        actual_names = [output.name for output in result]
+        assert actual_names == expected_names
+
+    def test_extract_tool_calls_outputs_filters_non_tool_spans(
+        self, sample_spans: list[Any]
+    ) -> None:
+        """Test that non-tool spans are filtered out from outputs."""
+        result = extract_tool_calls_outputs(sample_spans)
+
+        # Should not include outputs from spans without tool.name
+        output_names = [output.name for output in result]
+        assert "non_tool_span" not in output_names
+        assert len(result) == 3
+
+    def test_extractors_skip_synthesized_tool_spans(self) -> None:
+        """Spans tagged with tool.synthesized=True (BPMN container spans
+        synthesized for trajectory rendering) must be filtered from all three
+        per-call extractors so they don't pollute tool-call evaluator actuals.
+        """
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        synth_process = ReadableSpan(
+            name="Instance: abc",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "FlowExecution",
+                "tool.synthesized": True,
+                "input.value": '{"instanceId": "abc"}',
+                "output.value": "Status: Completed",
+            },
+        )
+        synth_element = ReadableSpan(
+            name="Autonomous Agent",
+            start_time=2,
+            end_time=3,
+            attributes={
+                "tool.name": "ServiceTask: Autonomous Agent",
+                "tool.synthesized": True,
+                "input.value": "{}",
+                "output.value": "Status: Completed",
+            },
+        )
+        real_tool = ReadableSpan(
+            name="Tool call - web_search",
+            start_time=4,
+            end_time=5,
+            attributes={
+                "tool.name": "web_search",
+                "input.value": '{"query": "x"}',
+                "output.value": '{"content": "ok"}',
+            },
+        )
+
+        spans = [synth_process, synth_element, real_tool]
+
+        assert extract_tool_calls_names(spans) == ["web_search"]
+        calls = extract_tool_calls(spans)
+        assert [c.name for c in calls] == ["web_search"]
+        outputs = extract_tool_calls_outputs(spans)
+        assert [o.name for o in outputs] == ["web_search"]
+
+    def test_all_extraction_functions_consistent(self, sample_spans: list[Any]) -> None:
+        """Test that all extraction functions return consistent results."""
+        names = extract_tool_calls_names(sample_spans)
+        calls = extract_tool_calls(sample_spans)
+        outputs = extract_tool_calls_outputs(sample_spans)
+
+        # All should return the same number of items
+        assert len(names) == len(calls) == len(outputs)
+
+        # Names should match across all extractions
+        call_names = [call.name for call in calls]
+        output_names = [output.name for output in outputs]
+
+        assert names == call_names == output_names
+
+    def test_extract_tool_calls_outputs_with_invalid_json(self) -> None:
+        """Test tool call output extraction with invalid JSON in output.value."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="invalid_json_output_tool",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "invalid_json_output_tool",
+                "input.value": "{}",
+                "output.value": "not valid json {",
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "invalid_json_output_tool"
+        # Should use the string as-is when JSON parsing fails
+        assert result[0].output == "not valid json {"
+
+    def test_extract_tool_calls_outputs_json_without_content(self) -> None:
+        """Test tool call output extraction with JSON that has no content field."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="no_content_tool",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "no_content_tool",
+                "input.value": "{}",
+                "output.value": '{"status": "success", "data": "some data"}',
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "no_content_tool"
+        # Should default to empty string when content field is missing
+        assert result[0].output == ""
+
+    def test_extract_tool_calls_outputs_with_dict_output(self) -> None:
+        """Test tool call output extraction when output.value is already a dict."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="dict_output_tool",
+            start_time=0,
+            end_time=1,
+            attributes={  # pyright: ignore[reportArgumentType]
+                "tool.name": "dict_output_tool",
+                "input.value": "{}",
+                "output.value": {"content": "dict output value"},  # type: ignore[dict-item]
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "dict_output_tool"
+        assert result[0].output == "dict output value"
+
+    def test_extract_tool_calls_outputs_with_dict_without_content(self) -> None:
+        """Test tool call output extraction when output.value is a dict without content field."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="dict_no_content_tool",
+            start_time=0,
+            end_time=1,
+            attributes={  # pyright: ignore[reportArgumentType]
+                "tool.name": "dict_no_content_tool",
+                "input.value": "{}",
+                "output.value": {"result": "some result", "status": "ok"},  # type: ignore[dict-item]
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "dict_no_content_tool"
+        # Should default to empty string when content field is missing from dict
+        assert result[0].output == ""
+
+    def test_extract_tool_calls_outputs_with_non_string_non_dict(self) -> None:
+        """Test tool call output extraction with non-string, non-dict output.value."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="numeric_output_tool",
+            start_time=0,
+            end_time=1,
+            attributes={  # pyright: ignore[reportArgumentType]
+                "tool.name": "numeric_output_tool",
+                "input.value": "{}",
+                "output.value": 12345,
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "numeric_output_tool"
+        # Should convert to string for non-string, non-dict types
+        assert result[0].output == "12345"
+
+    def test_extract_tool_calls_outputs_with_json_non_dict_value(self) -> None:
+        """Test tool call output extraction when JSON parses to non-dict (e.g., array)."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="json_array_tool",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "json_array_tool",
+                "input.value": "{}",
+                "output.value": '["item1", "item2", "item3"]',
+            },
+        )
+
+        result = extract_tool_calls_outputs([span])
+        assert len(result) == 1
+        assert result[0].name == "json_array_tool"
+        # Should use the original string when parsed JSON is not a dict
+        assert result[0].output == '["item1", "item2", "item3"]'
+
+
+class TestIdAwareExtraction:
+    """Verify tool.id propagation through the three extractors, plus the
+    include_args=False optimization and the JSON-first parse fallback.
+    """
+
+    def test_extractors_read_tool_id_when_present(self) -> None:
+        """When a span carries `tool.id`, it must surface on ToolCall/ToolOutput.id."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="Tool call - Web_Search",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "Web_Search",
+                "tool.id": "7abae702-f898-4cc9-95f1-c365b9a857f9",
+                "input.value": "{}",
+                "output.value": '{"content": "ok"}',
+            },
+        )
+        calls = extract_tool_calls([span])
+        outputs = extract_tool_calls_outputs([span])
+        assert calls[0].id == "7abae702-f898-4cc9-95f1-c365b9a857f9"
+        assert calls[0].name == "Web_Search"
+        assert outputs[0].id == "7abae702-f898-4cc9-95f1-c365b9a857f9"
+        assert outputs[0].name == "Web_Search"
+
+    def test_extractors_preserve_falsy_but_present_tool_id(self) -> None:
+        """tool.id of 0 or empty string is unusual but legal — must not be silently dropped.
+
+        Original code used `if tool_id` which would treat 0 / '' as missing.
+        Fix uses `is not None`.
+        """
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        for falsy_id in (0, "", False):
+            span = ReadableSpan(
+                name="t",
+                start_time=0,
+                end_time=1,
+                attributes={
+                    "tool.name": "f",
+                    "tool.id": falsy_id,
+                    "input.value": "{}",
+                    "output.value": '{"content": "ok"}',
+                },
+            )
+            calls = extract_tool_calls([span])
+            outputs = extract_tool_calls_outputs([span])
+            assert calls[0].id == str(falsy_id), f"falsy id {falsy_id!r} was dropped"
+            assert outputs[0].id == str(falsy_id), f"falsy id {falsy_id!r} was dropped"
+
+    def test_extract_tool_calls_parses_json_literals(self) -> None:
+        """input.value with JSON `true`/`false`/`null` should parse cleanly.
+
+        `ast.literal_eval` doesn't recognise those tokens (Python uses
+        True/False/None); the extractor now tries `json.loads` first and only
+        falls back to `ast.literal_eval` on JSON parse failure.
+        """
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="t",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "t",
+                "input.value": '{"a": true, "b": false, "c": null}',
+            },
+        )
+        calls = extract_tool_calls([span])
+        assert calls[0].args == {"a": True, "b": False, "c": None}
+
+    def test_extract_tool_calls_falls_back_to_python_literal(self) -> None:
+        """Single-quoted Python dict repr (the historical input shape) still parses."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="t",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "t",
+                "input.value": "{'a': 1, 'b': 'two'}",  # JSON-invalid, Python-valid
+            },
+        )
+        calls = extract_tool_calls([span])
+        assert calls[0].args == {"a": 1, "b": "two"}
+
+    def test_extract_tool_calls_non_dict_parsed_result_yields_empty_args(self) -> None:
+        """If input.value parses to a non-dict (e.g. a bare string), args→{}.
+
+        Avoids pydantic validation failures from feeding a non-dict into
+        ToolCall(args=...).
+        """
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="t",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "t",
+                "input.value": '"hello"',  # JSON-valid string, not a dict
+            },
+        )
+        calls = extract_tool_calls([span])
+        assert calls[0].args == {}
+
+    def test_extract_tool_calls_include_args_false_skips_parse(self) -> None:
+        """With include_args=False, broken input.value is not parsed and doesn't raise.
+
+        Used by count / order evaluators that don't need args.
+        """
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="t",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "t",
+                "tool.id": "abc",
+                "input.value": "this is not valid python or json{{{",
+            },
+        )
+        calls = extract_tool_calls([span], include_args=False)
+        assert len(calls) == 1
+        assert calls[0].name == "t"
+        assert calls[0].id == "abc"
+        assert calls[0].args == {}  # short-circuited, not parsed
+
+    def test_extractors_default_id_to_none_when_absent(self) -> None:
+        """Spans without `tool.id` produce ToolCall/ToolOutput with id=None (back-compat)."""
+        from opentelemetry.sdk.trace import ReadableSpan
+
+        span = ReadableSpan(
+            name="Tool call - legacy",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "legacy_tool",
+                "input.value": "{}",
+                "output.value": '{"content": "ok"}',
+            },
+        )
+        calls = extract_tool_calls([span])
+        outputs = extract_tool_calls_outputs([span])
+        assert calls[0].id is None
+        assert outputs[0].id is None
+
+
+class TestIdAwareMatching:
+    """Verify id-aware matching across all four tool-call scoring functions.
+
+    For each function: an Expected criterion authored against the tool's id
+    matches the actual call when the actual carries the same id, even if the
+    `name` differs (the common case after a tool rename or the
+    'Web Search' → 'Web_Search' display-vs-runtime divergence).
+    """
+
+    def test_args_score_matches_by_id_when_names_differ(self) -> None:
+        """Expected keyed by id matches actual with same id but different name."""
+        from uipath.eval._helpers.evaluators_helpers import tool_calls_args_score
+
+        actual = [ToolCall(name="Web_Search", id="uuid-1", args={"q": "x"})]
+        expected = [ToolCall(name="Web Search", id="uuid-1", args={"q": "x"})]
+        score, _ = tool_calls_args_score(actual, expected)
+        assert score == 1.0
+
+    def test_args_score_strict_kind_no_id_fallback(self) -> None:
+        """Strict kind: actual has id → id-only mode, no name fallback even when actual.name matches expected.name."""
+        from uipath.eval._helpers.evaluators_helpers import tool_calls_args_score
+
+        actual = [ToolCall(name="Web_Search", id="uuid-1", args={"q": "x"})]
+        expected = [ToolCall(name="Web_Search", args={"q": "x"})]
+        score, _ = tool_calls_args_score(actual, expected)
+        assert score == 0.0  # actual.id="uuid-1" != expected.name="Web_Search"
+
+    def test_args_score_name_only_when_actual_has_no_id(self) -> None:
+        """When actual has no id, sanitised-name comparison is the only path."""
+        from uipath.eval._helpers.evaluators_helpers import tool_calls_args_score
+
+        actual = [ToolCall(name="Web_Search", args={"q": "x"})]
+        expected = [ToolCall(name="Web Search", args={"q": "x"})]
+        score, _ = tool_calls_args_score(actual, expected)
+        assert score == 1.0
+
+    def test_args_score_no_match_when_ids_differ(self) -> None:
+        """Different ids → no match even with same name."""
+        from uipath.eval._helpers.evaluators_helpers import tool_calls_args_score
+
+        actual = [ToolCall(name="Web_Search", id="uuid-A", args={"q": "x"})]
+        expected = [ToolCall(name="Web_Search", id="uuid-B", args={"q": "x"})]
+        score, _ = tool_calls_args_score(actual, expected)
+        assert score == 0.0
+
+    def test_output_score_matches_by_id(self) -> None:
+        from uipath.eval._helpers.evaluators_helpers import tool_calls_output_score
+
+        actual = [ToolOutput(name="Web_Search", id="uuid-1", output="ok")]
+        expected = [ToolOutput(name="Web Search", id="uuid-1", output="ok")]
+        score, _ = tool_calls_output_score(actual, expected)
+        assert score == 1.0
+
+    def test_count_by_name_and_id_helper(self) -> None:
+        """Strict per-call kind: id-keyed when call has id, name-keyed otherwise — never both."""
+        from uipath.eval._helpers.evaluators_helpers import (
+            count_tool_calls_by_name_and_id,
+        )
+
+        calls = [
+            ToolCall(name="Web_Search", id="uuid-1", args={}),
+            ToolCall(name="Web_Search", id="uuid-1", args={}),
+            ToolCall(name="get_temp", args={}),  # no id
+        ]
+        counts = count_tool_calls_by_name_and_id(calls)
+        assert counts == {"uuid-1": 2, "get_temp": 1}
+        # Name key is NOT populated when id is present — kind separation.
+        assert "Web_Search" not in counts
+
+    def test_order_score_with_ids_matches_id_keyed_expected(self) -> None:
+        """Strict kind: actual has id → only id-keyed expected matches; legacy name-keyed against id-bearing actual is a miss."""
+        from uipath.eval._helpers.evaluators_helpers import (
+            tool_calls_order_score_with_ids,
+        )
+
+        actual = [
+            ToolCall(name="Web_Search", id="uuid-1", args={}),
+            ToolCall(name="Web_Search", id="uuid-1", args={}),
+        ]
+        # Expected authored by id matches.
+        score, _ = tool_calls_order_score_with_ids(actual, ["uuid-1", "uuid-1"])
+        assert score == 1.0
+        # Expected authored by name against id-bearing actual is a miss (no cross-kind).
+        score, _ = tool_calls_order_score_with_ids(actual, ["Web_Search", "Web_Search"])
+        assert score == 0.0
+        # Mixed expected: only the id-keyed element matches.
+        score, _ = tool_calls_order_score_with_ids(actual, ["uuid-1", "Web_Search"])
+        assert 0.0 < score < 1.0
+
+    def test_order_score_with_ids_back_compat_when_id_absent(self) -> None:
+        """When actual has no ids (legacy traces), comparison is name-only."""
+        from uipath.eval._helpers.evaluators_helpers import (
+            tool_calls_order_score_with_ids,
+        )
+
+        actual = [
+            ToolCall(name="get_temp", args={}),
+            ToolCall(name="get_humidity", args={}),
+        ]
+        score, _ = tool_calls_order_score_with_ids(actual, ["get_temp", "get_humidity"])
+        assert score == 1.0
+
+
+class TestSanitizedNameMatch:
+    """Sanitised-name fallback in ``_match_key`` / ``_calls_match`` — id-equality wins first."""
+
+    @staticmethod
+    def _reference_sanitize(name: str) -> str:
+        """Pinned copy of ``uipath_langchain.agent.tools.utils.sanitize_tool_name``."""
+        import re
+
+        trim_whitespaces = "_".join(name.split())
+        sanitized = re.sub(r"[^a-zA-Z0-9_-]", "", trim_whitespaces)
+        return sanitized[:64]
+
+    @pytest.mark.parametrize(
+        "raw",
+        [
+            "Web Search",
+            "Google Sheets / Read",
+            "Add Numbers",
+            "tool with spaces and (parens)",
+            "snake_case_tool",
+            "kebab-case-tool",
+            "alreadySanitised",
+            "  multiple   whitespace  ",
+            "very-long-name-" + "x" * 100,
+            "",
+        ],
+    )
+    def test_normalize_matches_langchain_reference(self, raw: str) -> None:
+        assert _sanitize_tool_name(raw) == self._reference_sanitize(raw)
+
+    def test_normalize_handles_none(self) -> None:
+        assert _sanitize_tool_name(None) == ""
+
+    def test_match_key_display_vs_sanitised(self) -> None:
+        assert _match_key("Web_Search", None, "Web Search") is True
+
+    def test_match_key_id_wins_when_present(self) -> None:
+        assert _match_key("Web_Search", "webSearch1", "webSearch1") is True
+        # Strict kind: actual has id → display-name expected is rejected (no cross-kind).
+        assert _match_key("Web_Search", "webSearch1", "Web Search") is False
+
+    def test_match_key_mismatch_after_sanitising(self) -> None:
+        assert _match_key("Web_Search", None, "Image_Search") is False
+
+    def test_calls_match_display_vs_sanitised(self) -> None:
+        actual = ToolCall(name="Web_Search", args={})
+        expected = ToolCall(name="Web Search", args={})
+        assert _calls_match(actual, expected) is True
+
+    def test_calls_match_id_equality_unchanged(self) -> None:
+        actual = ToolCall(name="Web_Search", id="webSearch1", args={})
+        expected = ToolCall(name="totally different", id="webSearch1", args={})
+        assert _calls_match(actual, expected) is True
+
+    def test_calls_match_output_display_vs_sanitised(self) -> None:
+        actual = ToolOutput(name="Web_Search", output="x")
+        expected = ToolOutput(name="Web Search", output="x")
+        assert _calls_match(actual, expected) is True
+
+    def test_count_score_display_name_matches_sanitised_actual(self) -> None:
+        actual = {"Web_Search": 2}
+        expected = {"Web Search": ("==", 2)}
+        score, _ = tool_calls_count_score(actual, expected)
+        assert score == 1.0
+
+    def test_count_score_id_keyed_expected_still_wins(self) -> None:
+        actual = {"Web_Search": 1, "webSearch1": 1}
+        expected = {"webSearch1": (">=", 1)}
+        score, _ = tool_calls_count_score(actual, expected)
+        assert score == 1.0
diff --git a/packages/uipath/tests/evaluators/test_evaluator_methods.py b/packages/uipath/tests/evaluators/test_evaluator_methods.py
new file mode 100644
index 000000000..ec795499d
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_evaluator_methods.py
@@ -0,0 +1,2634 @@
+"""Tests for evaluator evaluate() methods.
+
+This module tests the actual evaluation functionality of all evaluators:
+- ExactMatchEvaluator.evaluate()
+- JsonSimilarityEvaluator.evaluate()
+- LlmAsAJudgeEvaluator.evaluate()
+- ToolCallOrderEvaluator.evaluate()
+- ToolCallCountEvaluator.evaluate()
+- LlmJudgeTrajectoryEvaluator.evaluate()
+"""
+
+import math
+import uuid
+from typing import Any
+
+import pytest
+from opentelemetry.sdk.trace import ReadableSpan
+from pytest_mock.plugin import MockerFixture
+
+from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+from uipath.eval.evaluators.contains_evaluator import (
+    ContainsEvaluationCriteria,
+    ContainsEvaluator,
+)
+from uipath.eval.evaluators.exact_match_evaluator import ExactMatchEvaluator
+from uipath.eval.evaluators.json_similarity_evaluator import (
+    JsonSimilarityEvaluator,
+    JsonSimilarityJustification,
+)
+from uipath.eval.evaluators.llm_as_judge_evaluator import LLMJudgeJustification
+from uipath.eval.evaluators.llm_judge_output_evaluator import (
+    LLMJudgeOutputEvaluator,
+)
+from uipath.eval.evaluators.llm_judge_trajectory_evaluator import (
+    LLMJudgeTrajectoryEvaluator,
+    TrajectoryEvaluationCriteria,
+)
+from uipath.eval.evaluators.output_evaluator import OutputEvaluationCriteria
+from uipath.eval.evaluators.tool_call_args_evaluator import (
+    ToolCallArgsEvaluationCriteria,
+    ToolCallArgsEvaluator,
+    ToolCallArgsEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_count_evaluator import (
+    ToolCallCountEvaluationCriteria,
+    ToolCallCountEvaluator,
+    ToolCallCountEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_order_evaluator import (
+    ToolCallOrderEvaluationCriteria,
+    ToolCallOrderEvaluator,
+    ToolCallOrderEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_output_evaluator import (
+    ToolCallOutputEvaluationCriteria,
+    ToolCallOutputEvaluator,
+    ToolCallOutputEvaluatorJustification,
+)
+from uipath.eval.models import NumericEvaluationResult
+from uipath.eval.models.models import (
+    AgentExecution,
+    ToolCall,
+    ToolOutput,
+    UiPathEvaluationError,
+)
+
+
+@pytest.fixture
+def sample_agent_execution() -> AgentExecution:
+    """Create a sample AgentExecution for testing."""
+    return AgentExecution(
+        agent_input={"input": "Test input"},
+        agent_output={"output": "Test output"},
+        agent_trace=[],  # Empty trace for basic tests
+    )
+
+
+@pytest.fixture
+def sample_agent_execution_with_trace() -> AgentExecution:
+    """Create a sample AgentExecution with tool call trace."""
+    # Mock spans that represent tool calls - simplified for testing
+    mock_spans = [
+        ReadableSpan(
+            name="tool1",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "tool.name": "tool1",
+                "input.value": "{'arg1': 'value1'}",
+                "output.value": '{"content": "output1"}',
+            },
+        ),
+        ReadableSpan(
+            name="tool2",
+            start_time=1,
+            end_time=2,
+            attributes={
+                "tool.name": "tool2",
+                "input.value": "{'arg2': 'value2'}",
+                "output.value": '{"content": "output2"}',
+            },
+        ),
+        ReadableSpan(
+            name="tool1",
+            start_time=2,
+            end_time=3,
+            attributes={
+                "tool.name": "tool1",
+                "input.value": "{'arg1': 'value1'}",
+                "output.value": '{"content": "output1"}',
+            },
+        ),
+        ReadableSpan(
+            name="tool2",
+            start_time=3,
+            end_time=4,
+            attributes={
+                "tool.name": "tool2",
+                "input.value": "{'arg2': 'value2'}",
+                "output.value": '{"content": "output2"}',
+            },
+        ),
+    ]
+
+    return AgentExecution(
+        agent_input={"input": "Test input with tools"},
+        agent_output={
+            "output": "Test output with tools",
+        },
+        agent_trace=mock_spans,
+    )
+
+
+class TestExactMatchEvaluator:
+    """Test ExactMatchEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_exact_match_string_success(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test exact match with matching strings."""
+        config = {
+            "name": "ExactMatchTest",
+            "case_sensitive": True,
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output={"output": "Test output"})  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_string_failure(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test exact match with non-matching strings."""
+        config = {
+            "name": "ExactMatchTest",
+            "case_sensitive": True,
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"output": "Different output"}  # pyright: ignore[reportCallIssue]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_negated(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test exact match with negated criteria."""
+        config = {
+            "name": "ExactMatchTest",
+            "case_sensitive": True,
+            "negated": True,
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"output": "Test output"},  # pyright: ignore[reportCallIssue]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "actual_output, expected_output, expected_score",
+        [
+            # Scalar int/float normalization — the core fix
+            (1, 1.0, 1.0),
+            (1.0, 1, 1.0),
+            (0, 0.0, 1.0),
+            (-3, -3.0, 1.0),
+            (1.5, 1, 0.0),
+            (2, 3, 0.0),
+        ],
+    )
+    async def test_exact_match_numeric_normalization(
+        self, actual_output: Any, expected_output: Any, expected_score: float
+    ) -> None:
+        """Test that int and float scalar values are normalized before comparison."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"value": actual_output},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchNumericTest", "target_output_key": "value"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output={"value": expected_output})  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "actual_output, expected_output, target_key, expected_score",
+        [
+            # Flat dict: int vs float value
+            ({"v": 1}, {"v": 1.0}, "*", 1.0),
+            ({"v": 1.0}, {"v": 1}, "*", 1.0),
+            ({"v": 1.5}, {"v": 1}, "*", 0.0),
+            # Nested dict
+            ({"a": {"b": 1}}, {"a": {"b": 1.0}}, "*", 1.0),
+            ({"a": {"b": 1.5}}, {"a": {"b": 1}}, "*", 0.0),
+            # List of numbers
+            ({"vals": [1, 2, 3]}, {"vals": [1.0, 2.0, 3.0]}, "*", 1.0),
+            ({"vals": [1, 2, 4]}, {"vals": [1.0, 2.0, 3.0]}, "*", 0.0),
+            # target_output_key resolves to a dict containing int/float
+            ({"result": {"count": 1}}, {"result": {"count": 1.0}}, "result", 1.0),
+            # target_output_key resolves to a scalar int/float
+            ({"result": 1}, {"result": 1.0}, "result", 1.0),
+            ({"result": 1.5}, {"result": 1}, "result", 0.0),
+        ],
+    )
+    async def test_exact_match_recursive_normalization(
+        self,
+        actual_output: Any,
+        expected_output: Any,
+        target_key: str,
+        expected_score: float,
+    ) -> None:
+        """Test that int/float normalization works recursively for dicts, lists, and nested structures."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output=actual_output,
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchRecursiveTest", "target_output_key": target_key}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output=expected_output)  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+
+    @pytest.mark.asyncio
+    async def test_exact_match_validate_and_evaluate_criteria(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test exact match using validate_and_evaluate_criteria."""
+        config = {
+            "name": "ExactMatchTest",
+            "case_sensitive": True,
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"expected_output": {"output": "Test output"}}
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution, raw_criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_line_by_line_all_match(self) -> None:
+        """Test line-by-line evaluation with all lines matching."""
+        config = {
+            "name": "ExactMatchLineByLineTest",
+            "case_sensitive": False,
+            "line_by_line_evaluator": True,
+            "line_delimiter": "\n",
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        # Multi-line output
+        agent_execution = AgentExecution(
+            agent_input={"input": "Test input"},
+            agent_output="line1\nline2\nline3",
+            agent_trace=[],
+        )
+        criteria = OutputEvaluationCriteria(expected_output="line1\nline2\nline3")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution, criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0  # All 3 lines match
+        assert result.details is not None
+        assert hasattr(result.details, "line_by_line_results")
+        assert hasattr(result.details, "total_lines_actual")
+        assert hasattr(result.details, "total_lines_expected")
+        assert result.details.total_lines_actual == 3
+        assert result.details.total_lines_expected == 3
+        assert len(result.details.line_by_line_results) == 3
+
+    @pytest.mark.asyncio
+    async def test_exact_match_line_by_line_partial_match(self) -> None:
+        """Test line-by-line evaluation with some lines not matching."""
+        config = {
+            "name": "ExactMatchLineByLineTest",
+            "case_sensitive": False,
+            "line_by_line_evaluator": True,
+            "line_delimiter": "\n",
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        # Multi-line output with 2 out of 3 lines matching
+        agent_execution = AgentExecution(
+            agent_input={"input": "Test input"},
+            agent_output="line1\nwrong\nline3",
+            agent_trace=[],
+        )
+        criteria = OutputEvaluationCriteria(expected_output="line1\nline2\nline3")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution, criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        # 2 out of 3 lines match = 0.666...
+        assert math.isclose(result.score, 2.0 / 3.0, rel_tol=0.01)
+        assert result.details is not None
+        assert hasattr(result.details, "line_by_line_results")
+        assert len(result.details.line_by_line_results) == 3
+        # Check first line matches
+        assert result.details.line_by_line_results[0].score == 1.0
+        # Check second line doesn't match
+        assert result.details.line_by_line_results[1].score == 0.0
+        # Check third line matches
+        assert result.details.line_by_line_results[2].score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_line_by_line_custom_delimiter(self) -> None:
+        """Test line-by-line evaluation with custom delimiter."""
+        config = {
+            "name": "ExactMatchLineByLineTest",
+            "case_sensitive": False,
+            "line_by_line_evaluator": True,
+            "line_delimiter": "|",
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        # Pipe-delimited output
+        agent_execution = AgentExecution(
+            agent_input={"input": "Test input"},
+            agent_output="part1|part2|part3",
+            agent_trace=[],
+        )
+        criteria = OutputEvaluationCriteria(expected_output="part1|part2|part3")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution, criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert result.details is not None
+        assert hasattr(result.details, "line_by_line_results")
+        assert len(result.details.line_by_line_results) == 3
+
+    @pytest.mark.asyncio
+    async def test_exact_match_line_by_line_has_individual_results(self) -> None:
+        """Test that line-by-line evaluation attaches individual line results."""
+        config = {
+            "name": "ExactMatchLineByLineTest",
+            "case_sensitive": False,
+            "line_by_line_evaluator": True,
+            "line_delimiter": "\n",
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        # Multi-line output with 2 out of 3 lines matching
+        agent_execution = AgentExecution(
+            agent_input={"input": "Test input"},
+            agent_output="line1\nwrong\nline3",
+            agent_trace=[],
+        )
+        criteria = OutputEvaluationCriteria(expected_output="line1\nline2\nline3")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            agent_execution, criteria
+        )
+
+        # Check that the result has the _line_by_line_results attribute
+        assert hasattr(result, "_line_by_line_results")
+        line_by_line_container = result._line_by_line_results
+
+        # Verify we have 3 individual line results
+        assert len(line_by_line_container.line_results) == 3
+
+        # Check each line result
+        line1_num, line1_result = line_by_line_container.line_results[0]
+        assert line1_num == 1
+        assert line1_result.score == 1.0
+
+        line2_num, line2_result = line_by_line_container.line_results[1]
+        assert line2_num == 2
+        assert line2_result.score == 0.0
+
+        line3_num, line3_result = line_by_line_container.line_results[2]
+        assert line3_num == 3
+        assert line3_result.score == 1.0
+
+
+class TestListTargetOutputKey:
+    """Test target_output_key as a list of keys."""
+
+    @pytest.mark.asyncio
+    async def test_exact_match_list_keys_all_match(self) -> None:
+        """All listed keys match → score 1.0."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok", "total": 42, "extra": "ignored"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListKeys",
+            "target_output_key": ["status", "total"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"status": "ok", "total": 42}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_list_keys_value_mismatch(self) -> None:
+        """One key's value differs → score 0.0."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok", "total": 99},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListKeys",
+            "target_output_key": ["status", "total"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"status": "ok", "total": 42}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_exact_match_list_keys_dot_notation(self) -> None:
+        """Nested dot-notation paths inside a list of keys."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"order": {"status": "shipped"}, "qty": 3},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListDotKeys",
+            "target_output_key": ["order.status", "qty"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"order": {"status": "shipped"}, "qty": 3}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_missing_key_in_actual_raises(self) -> None:
+        """Missing key in actual output returns an ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},  # 'total' is missing
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListKeys",
+            "target_output_key": ["status", "total"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"status": "ok", "total": 42}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_missing_key_in_expected_raises(self) -> None:
+        """Missing key in expected output returns an ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok", "total": 42},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListKeys",
+            "target_output_key": ["status", "total"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={
+                "status": "ok"
+            }  # 'total' missing  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_expected_as_json_string(self) -> None:
+        """Expected output as a JSON string is parsed when key is a list."""
+        import json
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok", "total": 5},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListKeys",
+            "target_output_key": ["status", "total"],
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output=json.dumps({"status": "ok", "total": 5})  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_invalid_json_string_expected_raises(self) -> None:
+        """Invalid JSON string for expected output returns an ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchListKeys", "target_output_key": ["status"]}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output="not valid json"  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_disables_line_by_line(self) -> None:
+        """line_by_line_evaluator=True is ignored when target_output_key is a list."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"a": "x", "b": "y"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "ExactMatchListLbl",
+            "target_output_key": ["a", "b"],
+            "line_by_line_evaluator": True,
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"expected_output": {"a": "x", "b": "y"}}
+        # Should not raise or split into lines; returns a plain NumericEvaluationResult
+        result = await evaluator.validate_and_evaluate_criteria(execution, raw_criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        # No line-by-line details attached
+        assert (
+            not hasattr(result, "_line_by_line_results")
+            or result._line_by_line_results is None
+        )
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_list_keys_perfect_match(self) -> None:
+        """JsonSimilarityEvaluator with list keys scores 1.0 on exact match."""
+        from uipath.eval.evaluators.json_similarity_evaluator import (
+            JsonSimilarityEvaluator,
+        )
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"name": "Alice", "score": 100, "extra": "ignored"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "JsonSimListKeys",
+            "target_output_key": ["name", "score"],
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"name": "Alice", "score": 100}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_non_dict_actual_raises(self) -> None:
+        """Non-dict agent_output with list key returns ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output="just a string",  # pyright: ignore[reportArgumentType]
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchListKeys", "target_output_key": ["status"]}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"status": "ok"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_non_dict_json_expected_raises(self) -> None:
+        """Valid JSON that parses to a non-dict returns ErrorEvaluationResult."""
+        import json
+
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchListKeys", "target_output_key": ["status"]}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        # Valid JSON but not an object — triggers the isinstance(expected_output, dict) guard
+        criteria = OutputEvaluationCriteria(
+            expected_output=json.dumps("just a string")  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_list_keys_attachment_uri_downloaded(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Attachment URIs within list-key actual output values are downloaded."""
+        att_uri = (
+            "urn:uipath:cas:file:orchestrator:00000000-0000-0000-0000-000000000001"
+        )
+        mocker.patch(
+            "uipath.eval.evaluators.output_evaluator.download_attachment_as_string",
+            return_value="downloaded_content",
+        )
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"file": att_uri, "status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchListKeys", "target_output_key": ["file", "status"]}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"file": "downloaded_content", "status": "ok"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_scalar_key_attachment_uri_downloaded(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Attachment URI in scalar-key actual output is downloaded."""
+        att_uri = (
+            "urn:uipath:cas:file:orchestrator:00000000-0000-0000-0000-000000000002"
+        )
+        mocker.patch(
+            "uipath.eval.evaluators.output_evaluator.download_attachment_as_string",
+            return_value="file_content",
+        )
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"report": att_uri},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchScalarAtt", "target_output_key": "report"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"report": "file_content"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_scalar_key_missing_in_actual_raises(self) -> None:
+        """Missing scalar target_output_key in actual output returns ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"other": "value"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchMissingActual", "target_output_key": "missing_key"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"missing_key": "val"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_scalar_key_missing_in_expected_raises(self) -> None:
+        """Missing scalar target_output_key in expected output returns ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchMissingExpected", "target_output_key": "status"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        # expected output dict doesn't contain the target key
+        criteria = OutputEvaluationCriteria(
+            expected_output={"other_key": "ok"}  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_scalar_key_invalid_json_expected_raises(self) -> None:
+        """Invalid JSON string for expected output with scalar key returns ErrorEvaluationResult."""
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchInvalidJson", "target_output_key": "status"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output="not valid json"  # pyright: ignore[reportCallIssue]
+        )
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_validate_and_evaluate_criteria_none_raises(self) -> None:
+        """None criteria with no default configured raises UiPathEvaluationError."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"status": "ok"},
+            agent_trace=[],
+        )
+        config = {"name": "ExactMatchNoCriteria"}
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        with pytest.raises(UiPathEvaluationError) as exc_info:
+            await evaluator.validate_and_evaluate_criteria(execution, None)
+        assert "MISSING_EVALUATION_CRITERIA" in exc_info.value.error_info.code
+
+    def test_base_output_evaluator_get_full_expected_output_raises(self) -> None:
+        """BaseOutputEvaluator._get_full_expected_output raises NOT_IMPLEMENTED."""
+        from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+        from uipath.eval.evaluators.output_evaluator import (
+            BaseOutputEvaluator,
+            OutputEvaluationCriteria,
+            OutputEvaluatorConfig,
+        )
+        from uipath.eval.models import EvaluationResult
+
+        class _MinimalEvaluator(
+            BaseOutputEvaluator[
+                OutputEvaluationCriteria,
+                OutputEvaluatorConfig[OutputEvaluationCriteria],
+                BaseEvaluatorJustification,
+            ]
+        ):
+            @classmethod
+            def get_evaluator_id(cls) -> str:
+                return "uipath-minimal-test"
+
+            async def evaluate(
+                self, agent_execution: Any, evaluation_criteria: Any
+            ) -> EvaluationResult:
+                return None  # type: ignore[return-value]
+
+            def validate_evaluation_criteria(
+                self, raw: Any
+            ) -> OutputEvaluationCriteria:
+                return OutputEvaluationCriteria.model_validate(raw)
+
+        evaluator = _MinimalEvaluator.model_validate(
+            {
+                "evaluatorConfig": {"name": "minimal"},
+                "id": str(uuid.uuid4()),
+            }
+        )
+        with pytest.raises(UiPathEvaluationError) as exc_info:
+            evaluator._get_full_expected_output(  # pyright: ignore[reportArgumentType]
+                OutputEvaluationCriteria(expected_output={})  # pyright: ignore[reportCallIssue]
+            )
+        assert "NOT_IMPLEMENTED" in exc_info.value.error_info.code
+
+
+class TestContainsEvaluator:
+    """Test ContainsEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "agent_output, search_text, target_key, case_sensitive, negated, expected_score",
+        [
+            # Basic match
+            ("Test output", "Test output", "*", False, False, 1.0),
+            # Substring match
+            ("Hello World", "World", "*", False, False, 1.0),
+            # No match
+            ("Hello World", "Goodbye", "*", False, False, 0.0),
+            # Case-insensitive match (default)
+            ("Hello World", "hello world", "*", False, False, 1.0),
+            # Case-sensitive hit
+            ("Hello World", "Hello", "*", True, False, 1.0),
+            # Case-sensitive miss
+            ("Hello World", "hello", "*", True, False, 0.0),
+            # Negated hit becomes miss
+            ("Test output", "Test output", "*", False, True, 0.0),
+            # Negated miss becomes hit
+            ("Hello World", "Goodbye", "*", False, True, 1.0),
+            # target_output_key extraction
+            ("Test output", "Test output", "output", False, False, 1.0),
+        ],
+    )
+    async def test_contains_evaluator(
+        self,
+        agent_output: Any,
+        search_text: str,
+        target_key: str,
+        case_sensitive: bool,
+        negated: bool,
+        expected_score: float,
+        sample_agent_execution: AgentExecution,
+    ) -> None:
+        """Test ContainsEvaluator across match, no-match, case sensitivity, and negation cases."""
+        if target_key == "output":
+            execution = (
+                sample_agent_execution  # has agent_output={"output": "Test output"}
+            )
+        else:
+            execution = AgentExecution(
+                agent_input={},
+                agent_output=agent_output,
+                agent_trace=[],
+            )
+        config = {
+            "name": "ContainsTest",
+            "target_output_key": target_key,
+            "case_sensitive": case_sensitive,
+            "negated": negated,
+        }
+        evaluator = ContainsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ContainsEvaluationCriteria(search_text=search_text)
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+
+    @pytest.mark.asyncio
+    async def test_contains_evaluator_validate_and_evaluate_criteria(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test contains evaluator with validate_and_evaluate_criteria."""
+        config = {
+            "name": "ContainsTest",
+            "target_output_key": "*",
+        }
+        evaluator = ContainsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ContainsEvaluationCriteria(search_text="Test output")
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution, criteria
+        )
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestJsonSimilarityEvaluator:
+    """Test JsonSimilarityEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_identical(self) -> None:
+        """Test JSON similarity with identical structures."""
+        execution = AgentExecution(
+            agent_input={"input": "Test"},
+            agent_output={"name": "John", "age": 30, "city": "NYC"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "JsonSimilarityTest",
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"name": "John", "age": 30, "city": "NYC"}  # pyright: ignore[reportCallIssue]
+        )
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_partial_match(self) -> None:
+        """Test JSON similarity with partial matches."""
+        execution = AgentExecution(
+            agent_input={"input": "Test"},
+            agent_output={"name": "John", "age": 30, "city": "LA"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "JsonSimilarityTest",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"name": "John", "age": 30, "city": "NYC"}  # pyright: ignore[reportCallIssue]
+        )
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert math.isclose(result.score, 0.666, abs_tol=1e-3)
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "actual_output, expected_output, expected_score",
+        [
+            # int/float normalization — identical after normalization
+            ({"count": 1}, {"count": 1.0}, 1.0),
+            ({"count": 1.0}, {"count": 1}, 1.0),
+            # Nested int/float
+            ({"a": {"b": 1}}, {"a": {"b": 1.0}}, 1.0),
+            # List of ints vs floats
+            ({"vals": [1, 2, 3]}, {"vals": [1.0, 2.0, 3.0]}, 1.0),
+            # Different numeric values — partial score: 1.0 - |expected-actual|/|expected|
+            ({"count": 1.5}, {"count": 1}, 0.5),
+        ],
+    )
+    async def test_json_similarity_numeric_normalization(
+        self,
+        actual_output: Any,
+        expected_output: Any,
+        expected_score: float,
+    ) -> None:
+        """Test that int/float normalization is applied before JSON similarity comparison."""
+        execution = AgentExecution(
+            agent_input={},
+            agent_output=actual_output,
+            agent_trace=[],
+        )
+        config = {"name": "JsonSimilarityTest"}
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output=expected_output)  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_validate_and_evaluate_criteria(self) -> None:
+        """Test JSON similarity using validate_and_evaluate_criteria."""
+        execution = AgentExecution(
+            agent_input={"input": "Test"},
+            agent_output={"name": "John", "age": 30, "city": "NYC"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "JsonSimilarityTest",
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"expected_output": {"name": "John", "age": 30, "city": "NYC"}}
+
+        result = await evaluator.validate_and_evaluate_criteria(execution, raw_criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestToolCallOrderEvaluator:
+    """Test ToolCallOrderEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_tool_call_order_perfect_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call order with perfect order match."""
+
+        config = {
+            "name": "ToolOrderTest",
+            "strict": True,
+        }
+
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOrderEvaluationCriteria(
+            tool_calls_order=["tool1", "tool2", "tool1", "tool2"]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_order_no_perfect_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call order with perfect order match."""
+
+        config = {
+            "name": "ToolOrderTest",
+            "strict": True,
+        }
+
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOrderEvaluationCriteria(
+            tool_calls_order=["tool1", "tool1", "tool2", "tool2"]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_order_lcs_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call order with lcs order match."""
+
+        config = {
+            "name": "ToolOrderTest",
+            "strict": False,
+        }
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOrderEvaluationCriteria(
+            tool_calls_order=["tool1", "tool1", "tool2", "tool2"]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.75
+
+    @pytest.mark.asyncio
+    async def test_tool_call_order_validate_and_evaluate_criteria(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call order using validate_and_evaluate_criteria."""
+        config = {
+            "name": "ToolOrderTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"tool_calls_order": ["tool1", "tool2", "tool1", "tool2"]}
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution_with_trace, raw_criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestToolCallCountEvaluator:
+    """Test ToolCallCountEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_exact_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call count with exact count match."""
+        config = {
+            "name": "ToolCountTest",
+            "strict": True,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallCountEvaluationCriteria(
+            tool_calls_count={"tool1": ("=", 2), "tool2": ("=", 2)}
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_with_gt(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call count with strict count match."""
+        config = {
+            "name": "ToolCountTest",
+            "strict": True,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallCountEvaluationCriteria(
+            tool_calls_count={"tool1": (">", 1), "tool2": (">", 1)}
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_no_exact_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call count with no exact count match."""
+        config = {
+            "name": "ToolCountTest",
+            "strict": True,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallCountEvaluationCriteria(
+            tool_calls_count={"tool1": ("=", 2), "tool2": ("=", 1)}
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_partial_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call count with partial count match."""
+        config = {
+            "name": "ToolCountTest",
+            "strict": False,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallCountEvaluationCriteria(
+            tool_calls_count={"tool1": ("=", 2), "tool2": ("=", 1)}
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.5
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_validate_and_evaluate_criteria(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call count using validate_and_evaluate_criteria."""
+        config = {
+            "name": "ToolCountTest",
+            "strict": True,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"tool_calls_count": {"tool1": ("=", 2), "tool2": ("=", 2)}}
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution_with_trace, raw_criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestToolCallArgsEvaluator:
+    """Test ToolCallArgsEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_tool_call_args_perfect_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call args with perfect match."""
+        config = {
+            "name": "ToolArgsTest",
+            "strict": True,
+        }
+        evaluator = ToolCallArgsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallArgsEvaluationCriteria(
+            tool_calls=[
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value2"}),
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value2"}),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_args_partial_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call args with partial match."""
+        config = {
+            "name": "ToolArgsTest",
+            "strict": False,
+        }
+        evaluator = ToolCallArgsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallArgsEvaluationCriteria(
+            tool_calls=[
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value1"}),
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value2"}),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.75
+
+    @pytest.mark.asyncio
+    async def test_tool_call_args_validate_and_evaluate_criteria(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call args using validate_and_evaluate_criteria."""
+        config = {
+            "name": "ToolArgsTest",
+            "strict": True,
+        }
+        evaluator = ToolCallArgsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {
+            "tool_calls": [
+                {"name": "tool1", "args": {"arg1": "value1"}},
+                {"name": "tool2", "args": {"arg2": "value2"}},
+                {"name": "tool1", "args": {"arg1": "value1"}},
+                {"name": "tool2", "args": {"arg2": "value2"}},
+            ]
+        }
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution_with_trace, raw_criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestToolCallOutputEvaluator:
+    """Test ToolCallOutputEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_perfect_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output with perfect output match."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(
+            tool_outputs=[
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_partial_match(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output with partial output match."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": False,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(
+            tool_outputs=[
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="wrong_output"),
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.75
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_no_match_strict(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output with no match in strict mode."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(
+            tool_outputs=[
+                ToolOutput(name="tool1", output="wrong_output1"),
+                ToolOutput(name="tool2", output="output2"),
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_partial_match_non_strict(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output with partial match in non-strict mode."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": False,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(
+            tool_outputs=[
+                ToolOutput(name="tool1", output="wrong_output1"),
+                ToolOutput(name="tool2", output="output2"),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.5
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_empty_criteria(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output with empty criteria."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": False,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(tool_outputs=[])
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_validate_and_evaluate_criteria(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test tool call output using validate_and_evaluate_criteria."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {
+            "tool_outputs": [
+                {"name": "tool1", "output": "output1"},
+                {"name": "tool2", "output": "output2"},
+                {"name": "tool1", "output": "output1"},
+                {"name": "tool2", "output": "output2"},
+            ]
+        }
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution_with_trace, raw_criteria
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+
+
+class TestLlmAsAJudgeEvaluator:
+    """Test LlmAsAJudgeEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_basic_evaluation(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test LLM as judge basic evaluation functionality with function calling."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 80,
+            "justification": "Good response that meets criteria",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmJudgeTest",
+            "prompt": "Rate this output: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "gpt-4o-2024-08-06",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        criteria = OutputEvaluationCriteria(expected_output="Expected output")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Verify the result
+        assert hasattr(result, "score")
+        assert isinstance(result, NumericEvaluationResult), f"Result is {result}"
+        assert result.score == 0.8, f"Result score is {result.score}"
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_basic_evaluation_with_llm_service(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test LLM judge basic evaluation functionality with a custom LLM service and function calling."""
+        # Mock tool call for function calling approach
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 80,
+            "justification": "Good response that meets criteria",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        # Make chat_completions an async method
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        config = {
+            "name": "LlmJudgeTest",
+            "prompt": "Rate this output: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "gpt-4o-2024-08-06",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": config,
+                "llm_service": mock_chat_completions,
+                "id": str(uuid.uuid4()),
+            }
+        )
+
+        criteria = OutputEvaluationCriteria(expected_output="Expected output")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Verify the result
+        assert hasattr(result, "score")
+        assert isinstance(result, NumericEvaluationResult), f"Result is {result}"
+        assert result.score == 0.8, f"Result score is {result.score}"
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_validate_and_evaluate_criteria(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test LLM judge using validate_and_evaluate_criteria with function calling."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 75,
+            "justification": "Good response using raw criteria",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmJudgeTest",
+            "prompt": "Rate this output: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "gpt-4",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"expected_output": "Expected output"}
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution, raw_criteria
+        )
+
+        # Verify the result
+        assert hasattr(result, "score")
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.75
+
+
+class TestLlmJudgeTrajectoryEvaluator:
+    """Test LlmJudgeTrajectoryEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    async def test_llm_trajectory_basic_evaluation(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test LLM trajectory judge basic evaluation functionality with function calling."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 90,
+            "justification": "The agent followed the expected behavior and met the criteria",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmTrajectoryTest",
+            "prompt": "Evaluate this trajectory: {{AgentRunHistory}} vs {{ExpectedAgentBehavior}} given the following input: {{UserOrSyntheticInput}} instructions: {{SimulationInstructions}}",
+            "model": "gpt-4",
+        }
+        evaluator = LLMJudgeTrajectoryEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        criteria = TrajectoryEvaluationCriteria(
+            expected_agent_behavior="Agent should respond helpfully"
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Verify the result
+        assert hasattr(result, "score")
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.9
+
+    @pytest.mark.asyncio
+    async def test_llm_trajectory_validate_and_evaluate_criteria(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test LLM trajectory judge using validate_and_evaluate_criteria with function calling."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 85,
+            "justification": "The agent behavior was good using raw criteria",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmTrajectoryTest",
+            "prompt": "Evaluate this trajectory: {{AgentRunHistory}} vs {{ExpectedAgentBehavior}} given the following input: {{UserOrSyntheticInput}} instructions: {{SimulationInstructions}}",
+            "model": "gpt-4",
+        }
+        evaluator = LLMJudgeTrajectoryEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        raw_criteria = {"expected_agent_behavior": "Agent should respond helpfully"}
+
+        result = await evaluator.validate_and_evaluate_criteria(
+            sample_agent_execution, raw_criteria
+        )
+
+        # Verify the result
+        assert hasattr(result, "score")
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.85
+
+
+class TestEvaluatorErrorHandling:
+    """Test error handling in evaluators."""
+
+    @pytest.mark.asyncio
+    async def test_invalid_criteria_type(self) -> None:
+        """Test that evaluators handle invalid criteria types properly."""
+        config = {
+            "name": "ErrorTest",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        with pytest.raises(UiPathEvaluationError):
+            # Try to validate invalid criteria
+            evaluator.validate_evaluation_criteria("invalid_criteria")
+
+    @pytest.mark.asyncio
+    async def test_missing_config_fields(self, mocker: MockerFixture) -> None:
+        """Test that evaluators properly validate config fields."""
+        # Mock the UiPath constructor to avoid authentication
+        mock_uipath = mocker.MagicMock()
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPath",
+            return_value=mock_uipath,
+        )
+
+        config = {
+            "name": "LLMJudgeEvaluator",
+            "default_evaluation_criteria": {},
+        }
+
+        with pytest.raises(UiPathEvaluationError):
+            # Invalid default_evaluation_criteria (missing expectedOutput)
+            LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+
+class TestEvaluationResultTypes:
+    """Test that all evaluators return proper result types."""
+
+    @pytest.mark.asyncio
+    async def test_evaluators_return_results_with_scores(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test that evaluators return results with scores."""
+        config = {
+            "name": "Test",
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output={"output": "Test output"})  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert hasattr(result, "score")
+        assert isinstance(result.score, (int, float))
+
+
+class TestJustificationHandling:
+    """Test justification handling in all evaluators."""
+
+    @pytest.mark.asyncio
+    async def test_exact_match_evaluator_justification(
+        self, sample_agent_execution: AgentExecution
+    ) -> None:
+        """Test that ExactMatchEvaluator provides BaseEvaluatorJustification."""
+
+        config = {
+            "name": "ExactMatchTest",
+            "case_sensitive": True,
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output={"output": "Test output"})  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert isinstance(result.details, BaseEvaluatorJustification)
+        assert result.details.expected is not None
+        assert result.details.actual is not None
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_evaluator_justification(self) -> None:
+        """Test that JsonSimilarityEvaluator provides JsonSimilarityJustification."""
+
+        execution = AgentExecution(
+            agent_input={"input": "Test"},
+            agent_output={"name": "John", "age": 30, "city": "NYC"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "JsonSimilarityTest",
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(
+            expected_output={"name": "John", "age": 30, "city": "NYC"}  # pyright: ignore[reportCallIssue]
+        )
+
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert isinstance(result.details, JsonSimilarityJustification)
+        assert result.details.matched_leaves == 3.0
+        assert result.details.total_leaves == 3.0
+
+    @pytest.mark.asyncio
+    async def test_tool_call_order_evaluator_justification(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test that ToolCallOrderEvaluator provides structured justification."""
+
+        config = {
+            "name": "ToolOrderTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOrderEvaluationCriteria(
+            tool_calls_order=["tool1", "tool2", "tool1", "tool2"]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert isinstance(result.details, ToolCallOrderEvaluatorJustification)
+
+    @pytest.mark.asyncio
+    async def test_tool_call_count_evaluator_justification(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test that ToolCallCountEvaluator provides structured justification."""
+
+        config = {
+            "name": "ToolCountTest",
+            "strict": True,
+        }
+        evaluator = ToolCallCountEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallCountEvaluationCriteria(
+            tool_calls_count={"tool1": ("=", 2), "tool2": ("=", 2)}
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert isinstance(result.details, ToolCallCountEvaluatorJustification)
+
+    @pytest.mark.asyncio
+    async def test_tool_call_args_evaluator_justification(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test that ToolCallArgsEvaluator provides structured justification."""
+
+        config = {
+            "name": "ToolArgsTest",
+            "strict": True,
+        }
+        evaluator = ToolCallArgsEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallArgsEvaluationCriteria(
+            tool_calls=[
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value2"}),
+                ToolCall(name="tool1", args={"arg1": "value1"}),
+                ToolCall(name="tool2", args={"arg2": "value2"}),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert isinstance(result.details, ToolCallArgsEvaluatorJustification)
+
+    @pytest.mark.asyncio
+    async def test_tool_call_output_evaluator_justification(
+        self, sample_agent_execution_with_trace: AgentExecution
+    ) -> None:
+        """Test that ToolCallOutputEvaluator handles justification correctly."""
+        config = {
+            "name": "ToolOutputTest",
+            "strict": True,
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = ToolCallOutputEvaluationCriteria(
+            tool_outputs=[
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+                ToolOutput(name="tool1", output="output1"),
+                ToolOutput(name="tool2", output="output2"),
+            ]
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution_with_trace, criteria)
+
+        # Should have justification with tool call output details
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        # The justification is stored in the details field for tool call evaluators
+        assert hasattr(result, "details")
+        assert isinstance(result.details, ToolCallOutputEvaluatorJustification)
+        assert hasattr(result.details, "explained_tool_calls_outputs")
+        assert isinstance(result.details.explained_tool_calls_outputs, dict)
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_output_evaluator_justification(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test that LLMJudgeOutputEvaluator handles str justification correctly with function calling."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 80,
+            "justification": "The response meets most criteria but could be more detailed",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmJudgeTest",
+            "prompt": "Rate this output: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "gpt-4o-2024-08-06",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = OutputEvaluationCriteria(expected_output="Expected output")  # pyright: ignore[reportCallIssue]
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Should have LLMJudgeJustification in details field
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.8
+        assert hasattr(result, "details")
+        # The justification is stored in the details field for LLM evaluators
+        assert isinstance(result.details, LLMJudgeJustification)
+        assert (
+            result.details.justification
+            == "The response meets most criteria but could be more detailed"
+        )
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_trajectory_evaluator_justification(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test that LLMJudgeTrajectoryEvaluator handles str justification correctly."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 85,
+            "justification": "The agent trajectory shows good decision making and follows expected behavior patterns",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        async def mock_chat_completions(*args: Any, **kwargs: Any) -> Any:
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = mock_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "LlmTrajectoryTest",
+            "prompt": "Evaluate this trajectory: {{AgentRunHistory}} vs {{ExpectedAgentBehavior}}",
+            "model": "gpt-4",
+        }
+        evaluator = LLMJudgeTrajectoryEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = TrajectoryEvaluationCriteria(
+            expected_agent_behavior="Agent should respond helpfully"
+        )
+
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Should have LLMJudgeJustification in details field
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.85
+        assert isinstance(result.details, LLMJudgeJustification)
+        assert (
+            result.details.justification
+            == "The agent trajectory shows good decision making and follows expected behavior patterns"
+        )
+
+    def test_justification_validation_edge_cases(self, mocker: MockerFixture) -> None:
+        """Test edge cases for justification validation."""
+
+        # Test BaseEvaluatorJustification type evaluator
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        output_evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Valid BaseEvaluatorJustification should pass through
+        justification = BaseEvaluatorJustification(expected="expected", actual="actual")
+        result = output_evaluator.validate_justification(justification)
+        assert isinstance(result, BaseEvaluatorJustification)
+        assert result.expected == "expected"
+
+        # Dict should be validated into BaseEvaluatorJustification
+        result = output_evaluator.validate_justification(
+            {"expected": "exp", "actual": "act"}
+        )
+        assert isinstance(result, BaseEvaluatorJustification)
+        assert result.expected == "exp"
+
+        # Test LLMJudgeJustification type evaluator - need to provide llm_service to avoid authentication
+
+        llm_config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+            "model": "gpt-4o-2024-08-06",
+        }
+        mock_llm_service = mocker.MagicMock()
+        llm_evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": llm_config_dict,
+                "llm_service": mock_llm_service,
+                "id": str(uuid.uuid4()),
+            }
+        )
+
+        # LLMJudgeJustification validation
+        llm_justification = LLMJudgeJustification(
+            expected="expected", actual="actual", justification="test"
+        )
+        llm_result = llm_evaluator.validate_justification(llm_justification)
+        assert isinstance(llm_result, LLMJudgeJustification)
+        assert llm_result.justification == "test"
+
+    def test_justification_type_extraction_all_evaluators(self) -> None:
+        """Test that all evaluators have correct justification type extraction."""
+
+        # Different evaluators have different justification types
+        assert (
+            ExactMatchEvaluator._extract_justification_type()
+            is BaseEvaluatorJustification
+        )
+        assert (
+            JsonSimilarityEvaluator._extract_justification_type()
+            is JsonSimilarityJustification
+        )
+
+        # Tool call evaluators have their own justification types
+        assert (
+            ToolCallOrderEvaluator._extract_justification_type()
+            is ToolCallOrderEvaluatorJustification
+        )
+        assert (
+            ToolCallCountEvaluator._extract_justification_type()
+            is ToolCallCountEvaluatorJustification
+        )
+        assert (
+            ToolCallArgsEvaluator._extract_justification_type()
+            is ToolCallArgsEvaluatorJustification
+        )
+        assert (
+            ToolCallOutputEvaluator._extract_justification_type()
+            is ToolCallOutputEvaluatorJustification
+        )
+
+        # LLM evaluators should have LLMJudgeJustification justification type
+        assert (
+            LLMJudgeOutputEvaluator._extract_justification_type()
+            is LLMJudgeJustification
+        )
+        assert (
+            LLMJudgeTrajectoryEvaluator._extract_justification_type()
+            is LLMJudgeJustification
+        )
+
+    @pytest.mark.asyncio
+    async def test_llm_judge_omits_max_tokens_when_none(
+        self, sample_agent_execution: AgentExecution, mocker: MockerFixture
+    ) -> None:
+        """Test that max_tokens is omitted from API request when None (fixes 400 error)."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 80,
+            "justification": "Good response",
+        }
+
+        mock_message = mocker.MagicMock()
+        mock_message.tool_calls = [mock_tool_call]
+        mock_message.content = None
+
+        mock_choice = mocker.MagicMock()
+        mock_choice.message = mock_message
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [mock_choice]
+
+        captured_request = {}
+
+        async def capture_chat_completions(**kwargs: Any) -> Any:
+            nonlocal captured_request
+            captured_request = kwargs
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = capture_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "TestMaxTokensNone",
+            "model": "gpt-4o-mini-2024-07-18",
+            "prompt": "Evaluate the output",
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        result = await evaluator.evaluate(
+            agent_execution=sample_agent_execution,
+            evaluation_criteria=OutputEvaluationCriteria(expected_output="42"),
+        )
+
+        assert "max_tokens" not in captured_request, (
+            "max_tokens should be omitted when None, not passed as None "
+            "(this was causing 400 errors from LLM Gateway API)"
+        )
+
+        assert "model" in captured_request
+        assert "temperature" in captured_request
+        assert "tools" in captured_request
+        assert "tool_choice" in captured_request
+        assert "messages" in captured_request
+
+        assert result.score == 0.8
+        assert isinstance(result.details, LLMJudgeJustification)
+        assert result.details.justification == "Good response"
+
+
+class TestClaude45ModelSupport:
+    """Tests for Claude 4.5 model-specific behavior in LLM evaluators.
+
+    Claude 4.5 models (Haiku, Sonnet) require special handling:
+    - max_tokens must be set (defaults to 8000 when not configured)
+    - Function calling (tools/tool_choice) is used for structured output
+    - OpenAI-specific parameters (n, frequency_penalty, etc.) must NOT be sent
+    """
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "model_name",
+        [
+            "anthropic.claude-haiku-4-5-20251001-v1:0",
+            "anthropic.claude-sonnet-4-5-20250929-v1:0",
+        ],
+    )
+    async def test_claude_45_evaluator_uses_function_calling(
+        self,
+        model_name: str,
+        sample_agent_execution: AgentExecution,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test that Claude 4.5 evaluators use function calling (tools/tool_choice)."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {
+            "score": 95,
+            "justification": "Perfect match",
+        }
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        captured_request: dict[str, Any] = {}
+
+        async def capture_chat_completions(**kwargs: Any) -> Any:
+            nonlocal captured_request
+            captured_request = kwargs
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = capture_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": f"Claude45Test-{model_name}",
+            "prompt": "Rate this output: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": model_name,
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        criteria = OutputEvaluationCriteria(expected_output="Expected output")  # pyright: ignore[reportCallIssue]
+        result = await evaluator.evaluate(sample_agent_execution, criteria)
+
+        # Verify function calling is used
+        assert "tools" in captured_request, (
+            "Claude 4.5 models must use function calling"
+        )
+        assert "tool_choice" in captured_request, (
+            "tool_choice must be set for Claude 4.5"
+        )
+        assert captured_request["model"] == model_name
+
+        # Verify result is correct
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 0.95
+        assert isinstance(result.details, LLMJudgeJustification)
+        assert result.details.justification == "Perfect match"
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "model_name",
+        [
+            "anthropic.claude-haiku-4-5-20251001-v1:0",
+            "anthropic.claude-sonnet-4-5-20250929-v1:0",
+        ],
+    )
+    async def test_claude_45_sets_default_max_tokens(
+        self,
+        model_name: str,
+        sample_agent_execution: AgentExecution,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test that Claude 4.5 models get default max_tokens=8000 when not configured."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {"score": 80, "justification": "Good"}
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        captured_request: dict[str, Any] = {}
+
+        async def capture_chat_completions(**kwargs: Any) -> Any:
+            nonlocal captured_request
+            captured_request = kwargs
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = capture_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        # No max_tokens in config - should default to 8000 for Claude 4.5
+        config = {
+            "name": f"Claude45MaxTokensTest-{model_name}",
+            "prompt": "Rate: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": model_name,
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        criteria = OutputEvaluationCriteria(expected_output="Expected")  # pyright: ignore[reportCallIssue]
+        await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert "max_tokens" in captured_request, (
+            "Claude 4.5 models require max_tokens to be set"
+        )
+        assert captured_request["max_tokens"] == 8000, (
+            "Default max_tokens for Claude 4.5 should be 8000"
+        )
+
+    @pytest.mark.asyncio
+    async def test_claude_45_respects_configured_max_tokens(
+        self,
+        sample_agent_execution: AgentExecution,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test that explicitly configured max_tokens overrides the Claude 4.5 default."""
+        mock_tool_call = mocker.MagicMock()
+        mock_tool_call.id = "call_1"
+        mock_tool_call.name = "submit_evaluation"
+        mock_tool_call.arguments = {"score": 80, "justification": "Good"}
+
+        mock_response = mocker.MagicMock()
+        mock_response.choices = [
+            mocker.MagicMock(
+                message=mocker.MagicMock(content=None, tool_calls=[mock_tool_call])
+            )
+        ]
+
+        captured_request: dict[str, Any] = {}
+
+        async def capture_chat_completions(**kwargs: Any) -> Any:
+            nonlocal captured_request
+            captured_request = kwargs
+            return mock_response
+
+        mock_llm_instance = mocker.MagicMock()
+        mock_llm_instance.chat_completions = capture_chat_completions
+
+        mocker.patch("uipath.eval.evaluators.llm_as_judge_evaluator.UiPath")
+        mocker.patch(
+            "uipath.eval.evaluators.llm_as_judge_evaluator.UiPathLlmChatService",
+            return_value=mock_llm_instance,
+        )
+
+        config = {
+            "name": "Claude45CustomMaxTokens",
+            "prompt": "Rate: {{ActualOutput}} vs {{ExpectedOutput}}",
+            "model": "anthropic.claude-haiku-4-5-20251001-v1:0",
+            "maxTokens": 4096,
+        }
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+
+        criteria = OutputEvaluationCriteria(expected_output="Expected")  # pyright: ignore[reportCallIssue]
+        await evaluator.evaluate(sample_agent_execution, criteria)
+
+        assert captured_request["max_tokens"] == 4096, (
+            "Configured max_tokens should override the Claude 4.5 default"
+        )
+
+
+class TestBinaryClassificationEvaluator:
+    """Test BinaryClassificationEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "predicted, expected_class, positive_class, expected_score",
+        [
+            # TP: pred=positive, exp=positive → match → 1.0
+            ("spam", "spam", "spam", 1.0),
+            # FP: pred=positive, exp=negative → mismatch → 0.0
+            ("spam", "ham", "spam", 0.0),
+            # FN: pred=negative, exp=positive → mismatch → 0.0
+            ("ham", "spam", "spam", 0.0),
+            # TN: pred=negative, exp=negative → match → 1.0
+            ("ham", "ham", "spam", 1.0),
+            # Case insensitive TP
+            ("Spam", "SPAM", "spam", 1.0),
+        ],
+    )
+    async def test_binary_classification_scoring(
+        self,
+        predicted: str,
+        expected_class: str,
+        positive_class: str,
+        expected_score: float,
+    ) -> None:
+        """Test BinaryClassificationEvaluator returns 1.0 for match, 0.0 for mismatch."""
+        from uipath.eval.evaluators.binary_classification_evaluator import (
+            BinaryClassificationEvaluationCriteria,
+            BinaryClassificationEvaluator,
+        )
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"class": predicted},
+            agent_trace=[],
+        )
+        config = {
+            "name": "BinaryClassificationTest",
+            "target_output_key": "class",
+            "positive_class": positive_class,
+        }
+        evaluator = BinaryClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = BinaryClassificationEvaluationCriteria(
+            expected_class=expected_class,
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+        assert isinstance(result.details, BaseEvaluatorJustification)
+
+
+class TestMulticlassClassificationEvaluator:
+    """Test MulticlassClassificationEvaluator.evaluate() method."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "predicted, expected_class, classes, expected_score",
+        [
+            # Correct prediction → 1.0
+            ("cat", "cat", ["cat", "dog", "bird"], 1.0),
+            # Mismatch → 0.0
+            ("dog", "cat", ["cat", "dog", "bird"], 0.0),
+            # Mismatch → 0.0
+            ("cat", "dog", ["cat", "dog", "bird"], 0.0),
+            # Correct prediction → 1.0
+            ("bird", "bird", ["cat", "dog", "bird"], 1.0),
+            # Case insensitive match → 1.0
+            ("Cat", "CAT", ["cat", "dog", "bird"], 1.0),
+        ],
+    )
+    async def test_multiclass_classification_scoring(
+        self,
+        predicted: str,
+        expected_class: str,
+        classes: list[str],
+        expected_score: float,
+    ) -> None:
+        """Test MulticlassClassificationEvaluator returns 1.0 for match, 0.0 for mismatch."""
+        from uipath.eval.evaluators.multiclass_classification_evaluator import (
+            MulticlassClassificationEvaluationCriteria,
+            MulticlassClassificationEvaluator,
+        )
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"class": predicted},
+            agent_trace=[],
+        )
+        config = {
+            "name": "MulticlassClassificationTest",
+            "target_output_key": "class",
+            "classes": classes,
+        }
+        evaluator = MulticlassClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = MulticlassClassificationEvaluationCriteria(
+            expected_class=expected_class,
+        )
+        result = await evaluator.evaluate(execution, criteria)
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == expected_score
+        assert isinstance(result.details, BaseEvaluatorJustification)
+
+    @pytest.mark.asyncio
+    async def test_multiclass_classification_invalid_expected_class(self) -> None:
+        """Test that an invalid expected class returns an error result."""
+        from uipath.eval.evaluators.multiclass_classification_evaluator import (
+            MulticlassClassificationEvaluationCriteria,
+            MulticlassClassificationEvaluator,
+        )
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"class": "cat"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "MulticlassClassificationTest",
+            "target_output_key": "class",
+            "classes": ["cat", "dog"],
+        }
+        evaluator = MulticlassClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = MulticlassClassificationEvaluationCriteria(expected_class="bird")
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
+
+    @pytest.mark.asyncio
+    async def test_multiclass_classification_invalid_predicted_class(self) -> None:
+        """Test that an invalid predicted class returns an error result."""
+        from uipath.eval.evaluators.multiclass_classification_evaluator import (
+            MulticlassClassificationEvaluationCriteria,
+            MulticlassClassificationEvaluator,
+        )
+        from uipath.eval.models.models import ErrorEvaluationResult
+
+        execution = AgentExecution(
+            agent_input={},
+            agent_output={"class": "fish"},
+            agent_trace=[],
+        )
+        config = {
+            "name": "MulticlassClassificationTest",
+            "target_output_key": "class",
+            "classes": ["cat", "dog"],
+        }
+        evaluator = MulticlassClassificationEvaluator.model_validate(
+            {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+        )
+        criteria = MulticlassClassificationEvaluationCriteria(expected_class="cat")
+        result = await evaluator.evaluate(execution, criteria)
+        assert isinstance(result, ErrorEvaluationResult)
+        assert result.score == 0.0
diff --git a/packages/uipath/tests/evaluators/test_evaluator_schemas.py b/packages/uipath/tests/evaluators/test_evaluator_schemas.py
new file mode 100644
index 000000000..f46902562
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_evaluator_schemas.py
@@ -0,0 +1,694 @@
+"""Tests for evaluator schema functionality and base evaluator features.
+
+This module tests:
+- Config schema generation for all evaluators
+- Evaluation criteria schema generation for all evaluators
+- Base evaluator functionality (type extraction, validation)
+- Generic type parameter handling
+"""
+
+import uuid
+
+import pytest
+from pydantic import ValidationError
+from pytest_mock.plugin import MockerFixture
+
+from uipath.eval.evaluators.base_evaluator import BaseEvaluatorJustification
+from uipath.eval.evaluators.exact_match_evaluator import (
+    ExactMatchEvaluator,
+    ExactMatchEvaluatorConfig,
+)
+from uipath.eval.evaluators.json_similarity_evaluator import (
+    JsonSimilarityEvaluator,
+    JsonSimilarityEvaluatorConfig,
+    JsonSimilarityJustification,
+)
+from uipath.eval.evaluators.llm_as_judge_evaluator import (
+    LLMJudgeJustification,
+    LLMJudgeMixin,
+)
+from uipath.eval.evaluators.llm_judge_output_evaluator import (
+    LLMJudgeOutputEvaluator,
+    LLMJudgeOutputEvaluatorConfig,
+)
+from uipath.eval.evaluators.llm_judge_trajectory_evaluator import (
+    LLMJudgeTrajectoryEvaluator,
+)
+from uipath.eval.evaluators.output_evaluator import (
+    OutputEvaluationCriteria,
+)
+from uipath.eval.evaluators.tool_call_args_evaluator import (
+    ToolCallArgsEvaluationCriteria,
+    ToolCallArgsEvaluator,
+    ToolCallArgsEvaluatorConfig,
+    ToolCallArgsEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_count_evaluator import (
+    ToolCallCountEvaluationCriteria,
+    ToolCallCountEvaluator,
+    ToolCallCountEvaluatorConfig,
+    ToolCallCountEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_order_evaluator import (
+    ToolCallOrderEvaluationCriteria,
+    ToolCallOrderEvaluator,
+    ToolCallOrderEvaluatorConfig,
+    ToolCallOrderEvaluatorJustification,
+)
+from uipath.eval.evaluators.tool_call_output_evaluator import (
+    ToolCallOutputEvaluationCriteria,
+    ToolCallOutputEvaluator,
+    ToolCallOutputEvaluatorConfig,
+    ToolCallOutputEvaluatorJustification,
+)
+
+
+@pytest.fixture
+def sample_config_data() -> dict[str, str | bool | int | float]:
+    """Sample config data for testing."""
+    return {
+        "name": "TestEvaluator",
+        "threshold": 0.8,
+        "case_sensitive": False,
+        "strict": True,
+    }
+
+
+class TestEvaluatorSchemas:
+    """Test schema generation for all evaluators."""
+
+    def test_exact_match_evaluator_schemas(self) -> None:
+        """Test ExactMatchEvaluator schema generation."""
+        # Test config schema
+        config_schema = ExactMatchEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "case_sensitive" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = ExactMatchEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "expected_output" in criteria_schema["properties"]
+
+    def test_json_similarity_evaluator_schemas(self) -> None:
+        """Test JsonSimilarityEvaluator schema generation."""
+        # Test config schema
+        config_schema = JsonSimilarityEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = JsonSimilarityEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "expected_output" in criteria_schema["properties"]
+
+    def test_tool_call_order_evaluator_schemas(self) -> None:
+        """Test ToolCallOrderEvaluator schema generation."""
+        # Test config schema
+        config_schema = ToolCallOrderEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "strict" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = ToolCallOrderEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "tool_calls_order" in criteria_schema["properties"]
+
+    def test_tool_call_count_evaluator_schemas(self) -> None:
+        """Test ToolCallCountEvaluator schema generation."""
+        # Test config schema
+        config_schema = ToolCallCountEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "strict" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = ToolCallCountEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "tool_calls_count" in criteria_schema["properties"]
+
+    def test_tool_call_args_evaluator_schemas(self) -> None:
+        """Test ToolCallArgsEvaluator schema generation."""
+        # Test config schema
+        config_schema = ToolCallArgsEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "strict" in config_schema["properties"]
+        assert "subset" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = ToolCallArgsEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "tool_calls" in criteria_schema["properties"]
+
+    def test_tool_call_output_evaluator_schemas(self) -> None:
+        """Test ToolCallOutputEvaluator schema generation."""
+        # Test config schema
+        config_schema = ToolCallOutputEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "strict" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = ToolCallOutputEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "tool_outputs" in criteria_schema["properties"]
+
+    def test_base_llm_judge_evaluator_schemas(self) -> None:
+        """Test BaseLLMJudgeEvaluator schema generation."""
+        # Test config schema
+        config_schema = LLMJudgeMixin[
+            OutputEvaluationCriteria,
+            LLMJudgeOutputEvaluatorConfig,
+        ].get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "prompt" in config_schema["properties"], (
+            f"Prompt not found in config schema: {config_schema}"
+        )
+        assert "model" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = LLMJudgeMixin[
+            OutputEvaluationCriteria,
+            LLMJudgeOutputEvaluatorConfig,
+        ].get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "expected_output" in criteria_schema["properties"]
+
+    def test_llm_judge_evaluator_schemas(self) -> None:
+        """Test LLMJudgeEvaluator schema generation."""
+        # Test config schema
+        config_schema = LLMJudgeOutputEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "prompt" in config_schema["properties"]
+        assert "model" in config_schema["properties"]
+        assert "target_output_key" in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = LLMJudgeOutputEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "expected_output" in criteria_schema["properties"]
+
+    def test_llm_judge_trajectory_evaluator_schemas(self) -> None:
+        """Test LlmJudgeTrajectoryEvaluator schema generation."""
+        # Test config schema
+        config_schema = LLMJudgeTrajectoryEvaluator.get_config_schema()
+        assert isinstance(config_schema, dict)
+        assert "properties" in config_schema
+        assert "name" in config_schema["properties"]
+        assert "prompt" in config_schema["properties"]
+        assert "model" in config_schema["properties"]
+        assert "target_output_key" not in config_schema["properties"]
+
+        # Test criteria schema
+        criteria_schema = LLMJudgeTrajectoryEvaluator.get_evaluation_criteria_schema()
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in criteria_schema
+        assert "expected_agent_behavior" in criteria_schema["properties"]
+
+
+class TestJustificationSchemas:
+    """Test justification schema generation and validation for all evaluators."""
+
+    def test_exact_match_evaluator_justification_schema(self) -> None:
+        """Test ExactMatchEvaluator justification schema generation."""
+
+        # Test justification type extraction
+        justification_type = ExactMatchEvaluator._extract_justification_type()
+        assert justification_type is BaseEvaluatorJustification
+
+    def test_json_similarity_evaluator_justification_schema(self) -> None:
+        """Test JsonSimilarityEvaluator justification schema generation."""
+
+        # Test justification type extraction - JSON similarity provides structured justification
+        justification_type = JsonSimilarityEvaluator._extract_justification_type()
+        assert justification_type is JsonSimilarityJustification
+
+    def test_tool_call_order_evaluator_justification_schema(self) -> None:
+        """Test ToolCallOrderEvaluator justification schema generation."""
+        # Test justification type extraction - tool call evaluators have their own justification types
+
+        justification_type = ToolCallOrderEvaluator._extract_justification_type()
+        assert justification_type is ToolCallOrderEvaluatorJustification
+
+    def test_tool_call_count_evaluator_justification_schema(self) -> None:
+        """Test ToolCallCountEvaluator justification schema generation."""
+        # Test justification type extraction - tool call evaluators have their own justification types
+
+        justification_type = ToolCallCountEvaluator._extract_justification_type()
+        assert justification_type is ToolCallCountEvaluatorJustification
+
+    def test_tool_call_args_evaluator_justification_schema(self) -> None:
+        """Test ToolCallArgsEvaluator justification schema generation."""
+        # Test justification type extraction - tool call evaluators have their own justification types
+
+        justification_type = ToolCallArgsEvaluator._extract_justification_type()
+        assert justification_type is ToolCallArgsEvaluatorJustification
+
+    def test_tool_call_output_evaluator_justification_schema(self) -> None:
+        """Test ToolCallOutputEvaluator justification schema generation."""
+        # Test justification type extraction - tool call evaluators have their own justification types
+
+        justification_type = ToolCallOutputEvaluator._extract_justification_type()
+        assert justification_type is ToolCallOutputEvaluatorJustification
+
+    def test_llm_judge_output_evaluator_justification_schema(self) -> None:
+        """Test LLMJudgeOutputEvaluator justification schema generation."""
+
+        # Test justification type extraction - LLM evaluators use LLMJudgeJustification for justification
+        justification_type = LLMJudgeOutputEvaluator._extract_justification_type()
+        assert justification_type is LLMJudgeJustification
+
+    def test_llm_judge_trajectory_evaluator_justification_schema(self) -> None:
+        """Test LLMJudgeTrajectoryEvaluator justification schema generation."""
+
+        # Test justification type extraction - LLM evaluators use LLMJudgeJustification for justification
+        justification_type = LLMJudgeTrajectoryEvaluator._extract_justification_type()
+        assert justification_type is LLMJudgeJustification
+
+
+class TestBaseEvaluatorFunctionality:
+    """Test base evaluator functionality."""
+
+    def test_type_extraction_exact_match(self) -> None:
+        """Test type extraction for ExactMatchEvaluator."""
+        criteria_type = ExactMatchEvaluator._extract_evaluation_criteria_type()
+        config_type = ExactMatchEvaluator._extract_config_type()
+
+        assert criteria_type == OutputEvaluationCriteria
+        assert config_type == ExactMatchEvaluatorConfig
+
+    def test_type_extraction_json_similarity(self) -> None:
+        """Test type extraction for JsonSimilarityEvaluator."""
+        criteria_type = JsonSimilarityEvaluator._extract_evaluation_criteria_type()
+        config_type = JsonSimilarityEvaluator._extract_config_type()
+
+        assert criteria_type == OutputEvaluationCriteria
+        assert config_type == JsonSimilarityEvaluatorConfig
+
+    def test_type_extraction_tool_call_order(self) -> None:
+        """Test type extraction for ToolCallOrderEvaluator."""
+        criteria_type = ToolCallOrderEvaluator._extract_evaluation_criteria_type()
+        config_type = ToolCallOrderEvaluator._extract_config_type()
+
+        assert criteria_type == ToolCallOrderEvaluationCriteria
+        assert config_type == ToolCallOrderEvaluatorConfig
+
+    def test_type_extraction_tool_call_count(self) -> None:
+        """Test type extraction for ToolCallCountEvaluator."""
+        criteria_type = ToolCallCountEvaluator._extract_evaluation_criteria_type()
+        config_type = ToolCallCountEvaluator._extract_config_type()
+
+        assert criteria_type == ToolCallCountEvaluationCriteria
+        assert config_type == ToolCallCountEvaluatorConfig
+
+    def test_type_extraction_tool_call_args(self) -> None:
+        """Test type extraction for ToolCallArgsEvaluator."""
+        criteria_type = ToolCallArgsEvaluator._extract_evaluation_criteria_type()
+        config_type = ToolCallArgsEvaluator._extract_config_type()
+
+        assert criteria_type == ToolCallArgsEvaluationCriteria
+        assert config_type == ToolCallArgsEvaluatorConfig
+
+    def test_type_extraction_tool_call_output(self) -> None:
+        """Test type extraction for ToolCallOutputEvaluator."""
+        criteria_type = ToolCallOutputEvaluator._extract_evaluation_criteria_type()
+        config_type = ToolCallOutputEvaluator._extract_config_type()
+
+        assert criteria_type == ToolCallOutputEvaluationCriteria
+        assert config_type == ToolCallOutputEvaluatorConfig
+
+    def test_config_validation_exact_match(self) -> None:
+        """Test config validation for ExactMatchEvaluator."""
+        # Valid config - create minimal required config
+        config_dict = {
+            "name": "TestEvaluator",
+            "case_sensitive": True,
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        assert isinstance(evaluator.evaluator_config, ExactMatchEvaluatorConfig)
+        assert evaluator.evaluator_config.name == "TestEvaluator"
+        assert evaluator.evaluator_config.case_sensitive is True
+
+    def test_criteria_validation_exact_match(self) -> None:
+        """Test criteria validation for ExactMatchEvaluator."""
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Test dict validation
+        criteria_dict = {"expected_output": "test output"}
+        validated = evaluator.validate_evaluation_criteria(criteria_dict)
+
+        assert isinstance(validated, OutputEvaluationCriteria)
+        assert validated.expected_output == "test output"
+
+    def test_criteria_validation_tool_call_order(self) -> None:
+        """Test criteria validation for ToolCallOrderEvaluator."""
+        config_dict = {
+            "name": "Test",
+            "strict": False,
+            "default_evaluation_criteria": {"tool_calls_order": ["tool1", "tool2"]},
+        }
+        evaluator = ToolCallOrderEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Test dict validation
+        criteria_dict = {"tool_calls_order": ["tool1", "tool2", "tool3"]}
+        validated = evaluator.validate_evaluation_criteria(criteria_dict)
+
+        assert isinstance(validated, ToolCallOrderEvaluationCriteria)
+        assert validated.tool_calls_order == ["tool1", "tool2", "tool3"]
+
+    def test_config_validation_tool_call_output(self) -> None:
+        """Test config validation for ToolCallOutputEvaluator."""
+        # Valid config - create minimal required config
+        config_dict = {
+            "name": "TestToolOutputEvaluator",
+            "strict": True,
+            "default_evaluation_criteria": {
+                "tool_outputs": [{"name": "tool1", "output": "output1"}]
+            },
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        assert isinstance(evaluator.evaluator_config, ToolCallOutputEvaluatorConfig)
+        assert evaluator.evaluator_config.name == "TestToolOutputEvaluator"
+        assert evaluator.evaluator_config.strict is True
+
+    def test_criteria_validation_tool_call_output(self) -> None:
+        """Test criteria validation for ToolCallOutputEvaluator."""
+        config_dict = {
+            "name": "Test",
+            "strict": False,
+            "default_evaluation_criteria": {
+                "tool_outputs": [{"name": "tool1", "output": "output1"}]
+            },
+        }
+        evaluator = ToolCallOutputEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Test dict validation
+        criteria_dict = {
+            "tool_outputs": [
+                {"name": "tool1", "output": "output1"},
+                {"name": "tool2", "output": "output2"},
+            ]
+        }
+        validated = evaluator.validate_evaluation_criteria(criteria_dict)
+
+        assert isinstance(validated, ToolCallOutputEvaluationCriteria)
+        assert len(validated.tool_outputs) == 2
+        assert validated.tool_outputs[0].name == "tool1"
+        assert validated.tool_outputs[0].output == "output1"
+        assert validated.tool_outputs[1].name == "tool2"
+        assert validated.tool_outputs[1].output == "output2"
+
+    def test_criteria_validation_llm_judge_output(self, mocker: MockerFixture) -> None:
+        """Test criteria validation for LLMJudgeOutputEvaluator."""
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+            "model": "gpt-4o-2024-08-06",
+        }
+        mock_llm_service = mocker.MagicMock()
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": config_dict,
+                "llm_service": mock_llm_service,
+                "id": str(uuid.uuid4()),
+            }
+        )
+
+        # Test dict validation
+        criteria_dict = {"expected_output": "test output"}
+        validated = evaluator.validate_evaluation_criteria(criteria_dict)
+
+        assert isinstance(validated, OutputEvaluationCriteria)
+        assert validated.expected_output == "test output"
+
+    def test_automatic_type_detection(self) -> None:
+        """Test that types are automatically detected from Generic parameters."""
+        # Create evaluator - test with basic evaluators that don't trigger CLI imports
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Types should be set correctly
+        assert evaluator.evaluation_criteria_type == OutputEvaluationCriteria
+        assert evaluator.config_type.__name__ == "JsonSimilarityEvaluatorConfig"
+
+    def test_justification_validation_output_type(self) -> None:
+        """Test justification validation for evaluators with BaseEvaluatorJustification type."""
+
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Test BaseEvaluatorJustification validation
+        justification = BaseEvaluatorJustification(expected="expected", actual="actual")
+        result = evaluator.validate_justification(justification)
+        assert isinstance(result, BaseEvaluatorJustification)
+        assert result.expected == "expected"
+        assert result.actual == "actual"
+
+    def test_justification_validation_llm_judge_type(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test justification validation for evaluators with LLMJudgeJustification type."""
+
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+            "model": "gpt-4o-2024-08-06",
+        }
+        mock_llm_service = mocker.MagicMock()
+        evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": config_dict,
+                "llm_service": mock_llm_service,
+                "id": str(uuid.uuid4()),
+            }
+        )
+
+        # Test LLMJudgeJustification validation
+        justification = LLMJudgeJustification(
+            expected="expected", actual="actual", justification="test justification"
+        )
+        result = evaluator.validate_justification(justification)
+        assert isinstance(result, LLMJudgeJustification)
+        assert result.justification == "test justification"
+
+    def test_justification_type_consistency(self, mocker: MockerFixture) -> None:
+        """Test that justification_type field matches the generic parameter."""
+
+        # Test BaseEvaluatorJustification type evaluators
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        exact_match_evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+        assert exact_match_evaluator.justification_type is BaseEvaluatorJustification
+
+        # Test LLMJudgeJustification type evaluators
+        llm_config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+            "model": "gpt-4o-2024-08-06",
+        }
+        mock_llm_service = mocker.MagicMock()
+        llm_evaluator = LLMJudgeOutputEvaluator.model_validate(
+            {
+                "evaluatorConfig": llm_config_dict,
+                "llm_service": mock_llm_service,
+                "id": str(uuid.uuid4()),
+            }
+        )
+        assert llm_evaluator.justification_type is LLMJudgeJustification
+
+
+class TestEvaluatorInstances:
+    """Test evaluator instance functionality."""
+
+    def test_instance_config_access(self) -> None:
+        """Test that evaluator instances have properly typed config access."""
+        config_data = {
+            "name": "TestEvaluator",
+            "case_sensitive": False,
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = ExactMatchEvaluator.model_validate(
+            {"evaluatorConfig": config_data, "id": str(uuid.uuid4())}
+        )
+
+        # Test direct config access
+        assert evaluator.evaluator_config.name == "TestEvaluator"
+        assert evaluator.evaluator_config.case_sensitive is False
+
+        # Verify type
+        assert isinstance(evaluator.evaluator_config, ExactMatchEvaluatorConfig)
+
+    def test_instance_schema_access(self) -> None:
+        """Test that evaluator instances can access schemas."""
+        config_dict = {
+            "name": "Test",
+            "default_evaluation_criteria": {"expected_output": "test"},
+        }
+        evaluator = JsonSimilarityEvaluator.model_validate(
+            {"evaluatorConfig": config_dict, "id": str(uuid.uuid4())}
+        )
+
+        # Should be able to get schemas from instances
+        config_schema = evaluator.get_config_schema()
+        criteria_schema = evaluator.get_evaluation_criteria_schema()
+
+        assert isinstance(config_schema, dict)
+        assert isinstance(criteria_schema, dict)
+        assert "properties" in config_schema
+        assert "properties" in criteria_schema
+
+
+class TestEvaluatorReference:
+    """Test EvaluatorReference model functionality."""
+
+    def test_evaluator_reference_from_string(self) -> None:
+        """Test creating EvaluatorReference from a string."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        ref = EvaluatorReference.model_validate("evaluator-id-123")
+        assert ref.ref == "evaluator-id-123"
+        assert ref.weight == 1.0
+
+    def test_evaluator_reference_from_dict_with_weight(self) -> None:
+        """Test creating EvaluatorReference from a dict with weight."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        ref = EvaluatorReference.model_validate(
+            {"ref": "evaluator-id-123", "weight": 2.5}
+        )
+        assert ref.ref == "evaluator-id-123"
+        assert ref.weight == 2.5
+
+    def test_evaluator_reference_from_dict_without_weight(self) -> None:
+        """Test creating EvaluatorReference from a dict without weight."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        ref = EvaluatorReference.model_validate({"ref": "evaluator-id-123"})
+        assert ref.ref == "evaluator-id-123"
+        assert ref.weight == 1.0
+
+    def test_evaluator_reference_serialization_with_weight(self) -> None:
+        """Test serializing EvaluatorReference with weight."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        ref = EvaluatorReference(ref="evaluator-id-123", weight=2.5)
+        serialized = ref.model_dump(mode="json")
+        assert serialized == {"ref": "evaluator-id-123", "weight": 2.5}
+
+    def test_evaluator_reference_serialization_without_weight(self) -> None:
+        """Test serializing EvaluatorReference without weight."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        ref = EvaluatorReference(ref="evaluator-id-123")
+        serialized = ref.model_dump(mode="json")
+        assert serialized == "evaluator-id-123"
+
+    def test_evaluator_reference_weight_validation(self) -> None:
+        """Test that weight must be non-negative."""
+        from uipath.eval.models.evaluation_set import EvaluatorReference
+
+        # Valid weight
+        ref = EvaluatorReference.model_validate(
+            {"ref": "evaluator-id-123", "weight": 0}
+        )
+        assert ref.weight == 0
+
+        # Invalid negative weight should raise error
+        with pytest.raises(ValidationError):
+            EvaluatorReference.model_validate({"ref": "evaluator-id-123", "weight": -1})
+
+    def test_evaluation_set_with_evaluator_references(self) -> None:
+        """Test EvaluationSet with EvaluatorReference objects in evaluatorConfigs."""
+        from uipath.eval.models.evaluation_set import EvaluationSet
+
+        eval_set_data = {
+            "id": "test-set-123",
+            "name": "Test Evaluation Set",
+            "version": "1.0",
+            "evaluatorConfigs": [
+                "evaluator-1",
+                {"ref": "evaluator-2", "weight": 2.0},
+                {"ref": "evaluator-3", "weight": 1.5},
+            ],
+            "evaluations": [],
+        }
+
+        eval_set = EvaluationSet.model_validate(eval_set_data)
+        assert len(eval_set.evaluator_configs) == 3
+        assert eval_set.evaluator_configs[0].ref == "evaluator-1"
+        assert eval_set.evaluator_configs[0].weight == 1.0
+        assert eval_set.evaluator_configs[1].ref == "evaluator-2"
+        assert eval_set.evaluator_configs[1].weight == 2.0
+        assert eval_set.evaluator_configs[2].ref == "evaluator-3"
+        assert eval_set.evaluator_configs[2].weight == 1.5
+
+    def test_evaluation_set_backward_compatibility(self) -> None:
+        """Test EvaluationSet with old evaluatorRefs field (backward compatibility)."""
+        from uipath.eval.models.evaluation_set import EvaluationSet
+
+        eval_set_data = {
+            "id": "test-set-456",
+            "name": "Legacy Evaluation Set",
+            "version": "1.0",
+            "evaluatorRefs": ["evaluator-1", "evaluator-2", "evaluator-3"],
+            "evaluations": [],
+        }
+
+        eval_set = EvaluationSet.model_validate(eval_set_data)
+        assert len(eval_set.evaluator_refs) == 3
+        assert eval_set.evaluator_refs[0] == "evaluator-1"
+        assert eval_set.evaluator_refs[1] == "evaluator-2"
+        assert eval_set.evaluator_refs[2] == "evaluator-3"
+        # evaluator_configs should be empty when using old field
+        assert len(eval_set.evaluator_configs) == 0
diff --git a/packages/uipath/tests/evaluators/test_helpers.py b/packages/uipath/tests/evaluators/test_helpers.py
new file mode 100644
index 000000000..cb376fcbb
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_helpers.py
@@ -0,0 +1,109 @@
+"""Test module for helper functions in uipath.eval._helpers.helpers."""
+
+from uipath.eval._helpers.helpers import is_empty_value
+
+
+class TestIsEmptyValue:
+    """Test is_empty_value helper function.
+
+    These tests are based on realistic evaluation criteria structures:
+    - expectedOutput: typically a dict like {"content": "..."} or empty dict {}
+    - expectedAgentBehavior: typically a string describing expected behavior
+    """
+
+    # --- Empty expectedAgentBehavior (string) cases ---
+
+    def test_empty_string_expected_agent_behavior(self) -> None:
+        """Test empty string expectedAgentBehavior is considered empty."""
+        assert is_empty_value("") is True
+
+    def test_whitespace_only_expected_agent_behavior(self) -> None:
+        """Test whitespace-only expectedAgentBehavior is considered empty."""
+        assert is_empty_value(" ") is True
+        assert is_empty_value("   ") is True
+        assert is_empty_value("\t") is True
+        assert is_empty_value("\n") is True
+        assert is_empty_value(" \t\n ") is True
+
+    def test_valid_expected_agent_behavior(self) -> None:
+        """Test non-empty expectedAgentBehavior strings are not empty."""
+        assert is_empty_value("The agent should search for weather") is False
+        assert is_empty_value("Call the get_user tool with id=123") is False
+        assert is_empty_value(" valid behavior ") is False
+
+    # --- Empty expectedOutput (dict) cases ---
+
+    def test_empty_dict_expected_output(self) -> None:
+        """Test empty dict expectedOutput is considered empty."""
+        # trajectory evaluator: {"expectedOutput": {}}
+        assert is_empty_value({}) is True
+
+    def test_dict_with_empty_content_field(self) -> None:
+        """Test dict with empty content field is considered empty."""
+        # llm-as-a-judge: {"expectedOutput": {"content": ""}}
+        assert is_empty_value({"content": ""}) is True
+
+    def test_dict_with_whitespace_content_field(self) -> None:
+        """Test dict with whitespace-only content field is considered empty."""
+        assert is_empty_value({"content": "   "}) is True
+        assert is_empty_value({"content": "\t\n"}) is True
+
+    def test_dict_with_multiple_empty_string_fields(self) -> None:
+        """Test dict where all values are empty strings is considered empty."""
+        assert is_empty_value({"content": "", "reasoning": ""}) is True
+        assert is_empty_value({"content": "  ", "reasoning": "\t"}) is True
+
+    def test_dict_with_valid_content_field(self) -> None:
+        """Test dict with non-empty content field is not empty."""
+        assert is_empty_value({"content": "Expected response"}) is False
+        assert is_empty_value({"content": "The answer is 42"}) is False
+
+    def test_dict_with_mixed_empty_and_non_empty_fields(self) -> None:
+        """Test dict with at least one non-empty value is not empty."""
+        # If any value is non-empty, the whole dict is not empty
+        assert is_empty_value({"content": "value", "reasoning": ""}) is False
+        assert is_empty_value({"content": "", "reasoning": "some reason"}) is False
+
+    # --- None case ---
+
+    def test_none_is_empty(self) -> None:
+        """Test that None is considered empty."""
+        assert is_empty_value(None) is True
+
+    # --- Empty list case ---
+
+    def test_empty_list_is_empty(self) -> None:
+        """Test that empty list is considered empty."""
+        assert is_empty_value([]) is True
+
+    def test_non_empty_list_is_not_empty(self) -> None:
+        """Test that non-empty lists are not considered empty."""
+        assert is_empty_value(["step1", "step2"]) is False
+        assert is_empty_value([{"content": ""}]) is False
+
+    # --- Edge cases with non-string dict values ---
+
+    def test_dict_with_non_string_values_is_not_empty(self) -> None:
+        """Test that dict with non-string values is not considered empty.
+
+        The function only checks if all values are empty strings.
+        Non-string values (int, bool, None, list, dict) make it non-empty.
+        """
+        assert is_empty_value({"content": 0}) is False
+        assert is_empty_value({"content": False}) is False
+        assert is_empty_value({"content": None}) is False
+        assert is_empty_value({"content": []}) is False
+        assert is_empty_value({"content": {}}) is False
+
+    # --- Other types (not typical in eval criteria but handled) ---
+
+    def test_numeric_values_are_not_empty(self) -> None:
+        """Test that numeric values are not considered empty."""
+        assert is_empty_value(0) is False
+        assert is_empty_value(42) is False
+        assert is_empty_value(0.0) is False
+
+    def test_boolean_values_are_not_empty(self) -> None:
+        """Test that boolean values are not considered empty."""
+        assert is_empty_value(False) is False
+        assert is_empty_value(True) is False
diff --git a/packages/uipath/tests/evaluators/test_legacy_target_output_key_paths.py b/packages/uipath/tests/evaluators/test_legacy_target_output_key_paths.py
new file mode 100644
index 000000000..01d2235c7
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_legacy_target_output_key_paths.py
@@ -0,0 +1,236 @@
+"""Tests for targetOutputKey path resolution in legacy evaluators.
+
+Tests nested dot notation and array indexing in LegacyExactMatchEvaluator
+and LegacyJsonSimilarityEvaluator.
+"""
+
+from typing import Any
+
+import pytest
+
+from uipath.eval.evaluators import (
+    LegacyExactMatchEvaluator,
+    LegacyJsonSimilarityEvaluator,
+)
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.models.models import (
+    AgentExecution,
+    LegacyEvaluatorCategory,
+    LegacyEvaluatorType,
+)
+
+NESTED_OUTPUT = {
+    "order_id": "ORD-001",
+    "customer": {
+        "name": "John Doe",
+        "email": "john.doe@example.com",
+        "address": {
+            "street": "123 Main St",
+            "city": "Springfield",
+            "zip_code": "62701",
+        },
+    },
+    "items": [
+        {"name": "Widget", "quantity": 2, "price": 9.99},
+        {"name": "Gadget", "quantity": 1, "price": 24.99},
+    ],
+    "summary": {"total": 44.97, "item_count": 3, "status": "completed"},
+    "tags": ["priority", "express", "verified"],
+}
+
+
+def _make_exact_match_params(target_output_key: str = "*") -> dict[str, Any]:
+    return {
+        "id": "test-exact",
+        "category": LegacyEvaluatorCategory.Deterministic,
+        "type": LegacyEvaluatorType.Equals,
+        "name": "ExactMatch",
+        "description": "Test",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": target_output_key,
+    }
+
+
+def _make_json_sim_params(target_output_key: str = "*") -> dict[str, Any]:
+    return {
+        "id": "test-json-sim",
+        "category": LegacyEvaluatorCategory.Deterministic,
+        "type": LegacyEvaluatorType.JsonSimilarity,
+        "name": "JsonSimilarity",
+        "description": "Test",
+        "createdAt": "2025-01-01T00:00:00Z",
+        "updatedAt": "2025-01-01T00:00:00Z",
+        "targetOutputKey": target_output_key,
+    }
+
+
+class TestExactMatchWithNestedPaths:
+    """Test LegacyExactMatchEvaluator with nested targetOutputKey paths."""
+
+    @pytest.mark.asyncio
+    async def test_nested_dot_path_summary_status(self) -> None:
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_exact_match_params("summary.status")
+        )
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_nested_dot_path_customer_address_city(self) -> None:
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_exact_match_params("customer.address.city")
+        )
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_array_index_items_0_name(self) -> None:
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_exact_match_params("items[0].name")
+        )
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_array_index_tags_1(self) -> None:
+        evaluator = LegacyExactMatchEvaluator(**_make_exact_match_params("tags[1]"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_nested_path_mismatch_fails(self) -> None:
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_exact_match_params("summary.status")
+        )
+        original_summary = NESTED_OUTPUT["summary"]
+        assert isinstance(original_summary, dict)
+        modified_summary = {**original_summary, "status": "pending"}
+        different_output = {**NESTED_OUTPUT, "summary": modified_summary}
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={}, agent_trace=[], agent_output=different_output
+            ),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is False
+
+    @pytest.mark.asyncio
+    async def test_missing_path_in_both_passes(self) -> None:
+        """When path doesn't exist in either output, both resolve to {} -> pass."""
+        evaluator = LegacyExactMatchEvaluator(
+            **_make_exact_match_params("nonexistent.path")
+        )
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+    @pytest.mark.asyncio
+    async def test_flat_key_backward_compatible(self) -> None:
+        """Flat key like 'order_id' still works as before."""
+        evaluator = LegacyExactMatchEvaluator(**_make_exact_match_params("order_id"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score is True
+
+
+class TestJsonSimilarityWithNestedPaths:
+    """Test LegacyJsonSimilarityEvaluator with nested targetOutputKey paths."""
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_with_target_key_summary(self) -> None:
+        """JSON similarity on nested 'summary' object should score 100."""
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_json_sim_params("summary"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score == 100.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_with_target_key_customer(self) -> None:
+        """JSON similarity on nested 'customer' object should score 100."""
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_json_sim_params("customer"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score == 100.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_with_target_key_items_0(self) -> None:
+        """JSON similarity on items[0] should score 100 when matching."""
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_json_sim_params("items[0]"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score == 100.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_wildcard_unchanged(self) -> None:
+        """Wildcard '*' should compare the full output (backward compatible)."""
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_json_sim_params("*"))
+        result = await evaluator.evaluate(
+            AgentExecution(agent_input={}, agent_trace=[], agent_output=NESTED_OUTPUT),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        assert result.score == 100.0
+
+    @pytest.mark.asyncio
+    async def test_json_similarity_partial_match_with_target(self) -> None:
+        """When target narrows to a sub-object, partial matches still work."""
+        evaluator = LegacyJsonSimilarityEvaluator(**_make_json_sim_params("summary"))
+        different_summary = {
+            **NESTED_OUTPUT,
+            "summary": {"total": 45.0, "item_count": 3, "status": "completed"},
+        }
+        result = await evaluator.evaluate(
+            AgentExecution(
+                agent_input={}, agent_trace=[], agent_output=different_summary
+            ),
+            LegacyEvaluationCriteria(
+                expected_output=NESTED_OUTPUT, expected_agent_behavior=""
+            ),
+        )
+        # total: 45.0 vs 44.97 -> very close but not exact
+        assert result.score > 99.0
+        assert result.score < 100.0
diff --git a/packages/uipath/tests/evaluators/test_legacy_trajectory_evaluator.py b/packages/uipath/tests/evaluators/test_legacy_trajectory_evaluator.py
new file mode 100644
index 000000000..687fce08d
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_legacy_trajectory_evaluator.py
@@ -0,0 +1,64 @@
+import uuid
+
+from opentelemetry.sdk.trace import ReadableSpan
+
+from uipath.eval.evaluators import LegacyTrajectoryEvaluator
+from uipath.eval.evaluators.base_legacy_evaluator import LegacyEvaluationCriteria
+from uipath.eval.evaluators.legacy_trajectory_evaluator import (
+    LegacyTrajectoryEvaluatorConfig,
+)
+from uipath.eval.models.models import LegacyEvaluatorCategory, LegacyEvaluatorType
+
+
+def _legacy_trajectory_evaluator() -> LegacyTrajectoryEvaluator:
+    return LegacyTrajectoryEvaluator(
+        id=str(uuid.uuid4()),
+        name="Legacy trajectory",
+        config_type=LegacyTrajectoryEvaluatorConfig,
+        evaluation_criteria_type=LegacyEvaluationCriteria,
+        justification_type=str,
+        category=LegacyEvaluatorCategory.Trajectory,
+        type=LegacyEvaluatorType.Trajectory,
+        prompt="History:\n{{AgentRunHistory}}\nExpected:\n{{ExpectedAgentBehavior}}",
+        createdAt="2026-05-14T00:00:00Z",
+        updatedAt="2026-05-14T00:00:00Z",
+    )
+
+
+def test_legacy_trajectory_prompt_uses_compact_tool_history() -> None:
+    long_prompt = "SYSTEM_PROMPT_" + ("x" * 10_000)
+    spans = [
+        ReadableSpan(
+            name="agent_llm_call",
+            start_time=0,
+            end_time=1,
+            attributes={
+                "openinference.span.kind": "LLM",
+                "input.value": f'{{"messages": [{{"role": "system", "content": "{long_prompt}"}}]}}',
+                "output.value": '{"generations": []}',
+            },
+        ),
+        ReadableSpan(
+            name="search_profiles",
+            start_time=1,
+            end_time=2,
+            attributes={
+                "openinference.span.kind": "TOOL",
+                "tool.name": "search_profiles",
+                "input.value": '{"query": "mentor"}',
+                "output.value": '{"content": "found mentor profile"}',
+                "metadata": f'{{"agent_prompt": "{long_prompt}"}}',
+            },
+        ),
+    ]
+
+    prompt = _legacy_trajectory_evaluator()._create_evaluation_prompt(
+        expected_agent_behavior="The agent should search matching profiles.",
+        agent_run_history=spans,
+    )
+
+    assert "SYSTEM_PROMPT_" not in prompt
+    assert "Tool: search_profiles" in prompt
+    assert '{"query": "mentor"}' in prompt
+    assert "found mentor profile" in prompt
+    assert "agent_llm_call" not in prompt
diff --git a/packages/uipath/tests/evaluators/test_line_by_line_utils.py b/packages/uipath/tests/evaluators/test_line_by_line_utils.py
new file mode 100644
index 000000000..89449600c
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_line_by_line_utils.py
@@ -0,0 +1,356 @@
+"""Tests for line-by-line evaluation utility functions."""
+
+import pytest
+
+from uipath.eval.evaluators.line_by_line_utils import (
+    aggregate_line_scores,
+    build_line_by_line_result,
+    evaluate_lines,
+    split_into_lines,
+    wrap_line_in_structure,
+)
+from uipath.eval.evaluators.output_evaluator import (
+    LineByLineEvaluationDetails,
+    LineEvaluationDetail,
+)
+from uipath.eval.models.models import AgentExecution, NumericEvaluationResult
+
+
+class TestSplitIntoLines:
+    """Tests for split_into_lines utility function."""
+
+    def test_split_with_newline_delimiter(self):
+        """Test splitting with default newline delimiter."""
+        text = "line1\nline2\nline3"
+        result = split_into_lines(text, "\n")
+        assert result == ["line1", "line2", "line3"]
+
+    def test_split_with_custom_delimiter(self):
+        """Test splitting with custom delimiter."""
+        text = "line1|line2|line3"
+        result = split_into_lines(text, "|")
+        assert result == ["line1", "line2", "line3"]
+
+    def test_split_with_comma_delimiter(self):
+        """Test splitting with comma delimiter."""
+        text = "apple,banana,cherry"
+        result = split_into_lines(text, ",")
+        assert result == ["apple", "banana", "cherry"]
+
+    def test_split_filters_empty_lines(self):
+        """Test that empty lines are filtered out."""
+        text = "line1\n\nline2\n  \nline3"
+        result = split_into_lines(text, "\n")
+        assert result == ["line1", "line2", "line3"]
+
+    def test_split_with_dict_and_target_key(self):
+        """Test splitting when text is a dict and target_output_key is provided."""
+        text = {"result": "line1\nline2"}
+        result = split_into_lines(text, "\n", target_output_key="result")
+        assert result == ["line1", "line2"]
+
+    def test_split_with_dict_and_wildcard_target_key(self):
+        """Test splitting when target_output_key is wildcard."""
+        text = {"result": "line1\nline2"}
+        result = split_into_lines(text, "\n", target_output_key="*")
+        # Should convert dict to string
+        assert len(result) > 0
+
+    def test_split_converts_non_string_to_string(self):
+        """Test that non-string values are converted to string."""
+        text = 12345
+        result = split_into_lines(text, "\n")
+        assert result == ["12345"]
+
+    def test_split_with_multichar_delimiter(self):
+        """Test splitting with multi-character delimiter."""
+        text = "line1::line2::line3"
+        result = split_into_lines(text, "::")
+        assert result == ["line1", "line2", "line3"]
+
+
+class TestWrapLineInStructure:
+    """Tests for wrap_line_in_structure utility function."""
+
+    def test_wrap_with_wildcard_target_key(self):
+        """Test wrapping with wildcard target key returns line directly."""
+        line = "test line"
+        result = wrap_line_in_structure(line, "*")
+        assert result == "test line"
+
+    def test_wrap_with_none_target_key(self):
+        """Test wrapping with None target key returns line directly."""
+        line = "test line"
+        result = wrap_line_in_structure(line, None)
+        assert result == "test line"
+
+    def test_wrap_with_specific_target_key(self):
+        """Test wrapping with specific target key returns dict."""
+        line = "test line"
+        result = wrap_line_in_structure(line, "result")
+        assert result == {"result": "test line"}
+
+    def test_wrap_with_empty_string_target_key(self):
+        """Test wrapping with empty string target key returns line directly."""
+        line = "test line"
+        result = wrap_line_in_structure(line, "")
+        assert result == "test line"
+
+
+class TestAggregateLineScores:
+    """Tests for aggregate_line_scores utility function."""
+
+    def test_aggregate_numeric_scores(self):
+        """Test aggregating numeric scores."""
+        mock_results = [
+            (1, type("Result", (), {"score": 1.0})()),
+            (2, type("Result", (), {"score": 0.5})()),
+            (3, type("Result", (), {"score": 0.75})()),
+        ]
+        result = aggregate_line_scores(mock_results)
+        assert result == pytest.approx(0.75)  # (1.0 + 0.5 + 0.75) / 3
+
+    def test_aggregate_boolean_scores(self):
+        """Test aggregating boolean scores (converted to float)."""
+        mock_results = [
+            (1, type("Result", (), {"score": True})()),
+            (2, type("Result", (), {"score": False})()),
+            (3, type("Result", (), {"score": True})()),
+        ]
+        result = aggregate_line_scores(mock_results)
+        assert result == pytest.approx(0.6667, rel=1e-3)  # (1.0 + 0.0 + 1.0) / 3
+
+    def test_aggregate_mixed_scores(self):
+        """Test aggregating mixed numeric and boolean scores."""
+        mock_results = [
+            (1, type("Result", (), {"score": 1.0})()),
+            (2, type("Result", (), {"score": False})()),
+            (3, type("Result", (), {"score": 0.5})()),
+        ]
+        result = aggregate_line_scores(mock_results)
+        assert result == 0.5  # (1.0 + 0.0 + 0.5) / 3
+
+    def test_aggregate_empty_results(self):
+        """Test aggregating empty results returns 0.0."""
+        result = aggregate_line_scores([])
+        assert result == 0.0
+
+    def test_aggregate_results_without_score_attribute(self):
+        """Test aggregating results without score attribute."""
+        mock_results = [
+            (1, type("Result", (), {})()),
+            (2, type("Result", (), {})()),
+        ]
+        result = aggregate_line_scores(mock_results)
+        assert result == 0.0
+
+
+class TestEvaluateLines:
+    """Tests for evaluate_lines utility function."""
+
+    @pytest.mark.asyncio
+    async def test_evaluate_lines_all_match(self):
+        """Test evaluating lines when all lines match."""
+        actual_lines = ["line1", "line2", "line3"]
+        expected_lines = ["line1", "line2", "line3"]
+
+        agent_execution = AgentExecution(
+            agent_input={"test": "input"},
+            agent_output="line1\nline2\nline3",
+            agent_trace=[],
+        )
+
+        async def mock_evaluate(execution, criteria):
+            return NumericEvaluationResult(score=1.0, details="match")
+
+        def mock_create_criteria(expected_line):
+            return {"expected": expected_line}
+
+        line_details, line_results = await evaluate_lines(
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+            target_output_key="*",
+            agent_execution=agent_execution,
+            evaluate_fn=mock_evaluate,
+            create_line_criteria_fn=mock_create_criteria,
+        )
+
+        assert len(line_details) == 3
+        assert len(line_results) == 3
+        assert all(isinstance(detail, LineEvaluationDetail) for detail in line_details)
+        assert all(detail.score == 1.0 for detail in line_details)
+
+    @pytest.mark.asyncio
+    async def test_evaluate_lines_unequal_counts(self):
+        """Test evaluating lines when line counts don't match."""
+        actual_lines = ["line1", "line2"]
+        expected_lines = ["line1", "line2", "line3", "line4"]
+
+        agent_execution = AgentExecution(
+            agent_input={"test": "input"},
+            agent_output="line1\nline2",
+            agent_trace=[],
+        )
+
+        async def mock_evaluate(execution, criteria):
+            return NumericEvaluationResult(score=1.0, details="match")
+
+        def mock_create_criteria(expected_line):
+            return {"expected": expected_line}
+
+        line_details, line_results = await evaluate_lines(
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+            target_output_key="*",
+            agent_execution=agent_execution,
+            evaluate_fn=mock_evaluate,
+            create_line_criteria_fn=mock_create_criteria,
+        )
+
+        # Should evaluate max(len(actual), len(expected)) = 4 lines
+        assert len(line_details) == 4
+        assert len(line_results) == 4
+
+        # First 2 lines have content
+        assert line_details[0].actual == "line1"
+        assert line_details[1].actual == "line2"
+
+        # Last 2 lines are empty for actual
+        assert line_details[2].actual == ""
+        assert line_details[3].actual == ""
+
+        # All expected lines should be present
+        assert line_details[2].expected == "line3"
+        assert line_details[3].expected == "line4"
+
+    @pytest.mark.asyncio
+    async def test_evaluate_lines_with_target_output_key(self):
+        """Test evaluating lines with specific target_output_key."""
+        actual_lines = ["line1", "line2"]
+        expected_lines = ["line1", "line2"]
+
+        agent_execution = AgentExecution(
+            agent_input={"test": "input"},
+            agent_output={"result": "line1\nline2"},
+            agent_trace=[],
+        )
+
+        async def mock_evaluate(execution, criteria):
+            # Verify the execution has the wrapped structure
+            assert "result" in execution.agent_output
+            return NumericEvaluationResult(score=1.0, details="match")
+
+        def mock_create_criteria(expected_line):
+            return {"expected": expected_line}
+
+        line_details, line_results = await evaluate_lines(
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+            target_output_key="result",
+            agent_execution=agent_execution,
+            evaluate_fn=mock_evaluate,
+            create_line_criteria_fn=mock_create_criteria,
+        )
+
+        assert len(line_details) == 2
+        assert len(line_results) == 2
+
+
+class TestBuildLineByLineResult:
+    """Tests for build_line_by_line_result utility function."""
+
+    def test_build_result_with_all_matches(self):
+        """Test building result when all lines match."""
+        line_details = [
+            LineEvaluationDetail(
+                line_number=1, actual="line1", expected="line1", score=1.0
+            ),
+            LineEvaluationDetail(
+                line_number=2, actual="line2", expected="line2", score=1.0
+            ),
+        ]
+
+        line_results = [
+            (1, NumericEvaluationResult(score=1.0, details="match")),
+            (2, NumericEvaluationResult(score=1.0, details="match")),
+        ]
+
+        actual_lines = ["line1", "line2"]
+        expected_lines = ["line1", "line2"]
+
+        result = build_line_by_line_result(
+            line_details=line_details,
+            line_results=line_results,
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == 1.0
+        assert hasattr(result, "_line_by_line_results")
+        assert isinstance(result.details, LineByLineEvaluationDetails)
+        assert result.details.total_lines_actual == 2
+        assert result.details.total_lines_expected == 2
+
+    def test_build_result_with_partial_matches(self):
+        """Test building result with partial matches."""
+        line_details = [
+            LineEvaluationDetail(
+                line_number=1, actual="line1", expected="line1", score=1.0
+            ),
+            LineEvaluationDetail(
+                line_number=2, actual="wrong", expected="line2", score=0.0
+            ),
+            LineEvaluationDetail(
+                line_number=3, actual="line3", expected="line3", score=1.0
+            ),
+        ]
+
+        line_results = [
+            (1, NumericEvaluationResult(score=1.0, details="match")),
+            (2, NumericEvaluationResult(score=0.0, details="no match")),
+            (3, NumericEvaluationResult(score=1.0, details="match")),
+        ]
+
+        actual_lines = ["line1", "wrong", "line3"]
+        expected_lines = ["line1", "line2", "line3"]
+
+        result = build_line_by_line_result(
+            line_details=line_details,
+            line_results=line_results,
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert result.score == pytest.approx(0.6667, rel=1e-3)  # 2/3
+
+    def test_build_result_with_unequal_line_counts(self):
+        """Test building result when actual and expected have different line counts."""
+        line_details = [
+            LineEvaluationDetail(
+                line_number=1, actual="line1", expected="line1", score=1.0
+            ),
+            LineEvaluationDetail(line_number=2, actual="", expected="line2", score=0.0),
+        ]
+
+        line_results = [
+            (1, NumericEvaluationResult(score=1.0, details="match")),
+            (2, NumericEvaluationResult(score=0.0, details="no match")),
+        ]
+
+        actual_lines = ["line1"]
+        expected_lines = ["line1", "line2"]
+
+        result = build_line_by_line_result(
+            line_details=line_details,
+            line_results=line_results,
+            actual_lines=actual_lines,
+            expected_lines=expected_lines,
+        )
+
+        assert isinstance(result, NumericEvaluationResult)
+        assert isinstance(result.details, LineByLineEvaluationDetails)
+        assert result.details.total_lines_actual == 1
+        assert result.details.total_lines_expected == 2
+        assert result.score == 0.5  # 1/2
diff --git a/packages/uipath/tests/evaluators/test_llm_judge_placeholder_validation.py b/packages/uipath/tests/evaluators/test_llm_judge_placeholder_validation.py
new file mode 100644
index 000000000..71108fdbe
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_llm_judge_placeholder_validation.py
@@ -0,0 +1,293 @@
+"""Tests for LLMJudgeMixin placeholder auto-addition.
+
+Tests that missing {{ActualOutput}} and {{ExpectedOutput}} placeholders are
+automatically added to prompts with XML tags for clear delimitation.
+"""
+
+import uuid
+from unittest.mock import patch
+
+from uipath.eval.evaluators.llm_judge_output_evaluator import (
+    LLMJudgeOutputEvaluator,
+)
+
+
+class TestLLMJudgePlaceholderValidation:
+    """Test suite for automatic placeholder addition in LLM judge evaluators."""
+
+    def test_both_placeholders_present_no_modification(self):
+        """Test that prompts with both placeholders are not modified."""
+        original_prompt = (
+            "Evaluate the quality.\n"
+            "Actual: {{ActualOutput}}\n"
+            "Expected: {{ExpectedOutput}}"
+        )
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Prompt should remain unchanged
+        assert evaluator.evaluator_config.prompt == original_prompt
+        assert "## Actual Output" not in evaluator.evaluator_config.prompt
+        assert "## Expected Output" not in evaluator.evaluator_config.prompt
+        assert "<ActualOutput>" not in evaluator.evaluator_config.prompt
+        assert "<ExpectedOutput>" not in evaluator.evaluator_config.prompt
+
+    def test_missing_expected_output_placeholder_added_with_tags(self):
+        """Test that missing {{ExpectedOutput}} is auto-added with XML tags."""
+        original_prompt = "Evaluate this output: {{ActualOutput}}"
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Check that ExpectedOutput section was added
+        assert "## Expected Output" in evaluator.evaluator_config.prompt
+        assert "<ExpectedOutput>" in evaluator.evaluator_config.prompt
+        assert "{{ExpectedOutput}}" in evaluator.evaluator_config.prompt
+        assert "</ExpectedOutput>" in evaluator.evaluator_config.prompt
+
+        # Original prompt should still be there
+        assert (
+            "Evaluate this output: {{ActualOutput}}"
+            in evaluator.evaluator_config.prompt
+        )
+
+        # Verify structure: tags should wrap the placeholder
+        expected_section = (
+            "\n\n## Expected Output\n"
+            "<ExpectedOutput>\n"
+            "{{ExpectedOutput}}\n"
+            "</ExpectedOutput>"
+        )
+        assert expected_section in evaluator.evaluator_config.prompt
+
+    def test_missing_actual_output_placeholder_added_with_tags(self):
+        """Test that missing {{ActualOutput}} is auto-added with XML tags."""
+        original_prompt = "Compare against expected: {{ExpectedOutput}}"
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Check that ActualOutput section was added
+        assert "## Actual Output" in evaluator.evaluator_config.prompt
+        assert "<ActualOutput>" in evaluator.evaluator_config.prompt
+        assert "{{ActualOutput}}" in evaluator.evaluator_config.prompt
+        assert "</ActualOutput>" in evaluator.evaluator_config.prompt
+
+        # Original prompt should still be there
+        assert (
+            "Compare against expected: {{ExpectedOutput}}"
+            in evaluator.evaluator_config.prompt
+        )
+
+        # Verify structure: tags should wrap the placeholder
+        expected_section = (
+            "\n\n## Actual Output\n<ActualOutput>\n{{ActualOutput}}\n</ActualOutput>"
+        )
+        assert expected_section in evaluator.evaluator_config.prompt
+
+    def test_both_placeholders_missing_both_added_with_tags(self):
+        """Test that both placeholders are auto-added when both are missing."""
+        original_prompt = "Evaluate the quality of the agent output."
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Check that both sections were added
+        assert "## Actual Output" in evaluator.evaluator_config.prompt
+        assert "<ActualOutput>" in evaluator.evaluator_config.prompt
+        assert "{{ActualOutput}}" in evaluator.evaluator_config.prompt
+        assert "</ActualOutput>" in evaluator.evaluator_config.prompt
+
+        assert "## Expected Output" in evaluator.evaluator_config.prompt
+        assert "<ExpectedOutput>" in evaluator.evaluator_config.prompt
+        assert "{{ExpectedOutput}}" in evaluator.evaluator_config.prompt
+        assert "</ExpectedOutput>" in evaluator.evaluator_config.prompt
+
+        # Original prompt should still be there
+        assert (
+            "Evaluate the quality of the agent output."
+            in evaluator.evaluator_config.prompt
+        )
+
+        # Verify both sections are present
+        actual_section = (
+            "\n\n## Actual Output\n<ActualOutput>\n{{ActualOutput}}\n</ActualOutput>"
+        )
+        expected_section = (
+            "\n\n## Expected Output\n"
+            "<ExpectedOutput>\n"
+            "{{ExpectedOutput}}\n"
+            "</ExpectedOutput>"
+        )
+        assert actual_section in evaluator.evaluator_config.prompt
+        assert expected_section in evaluator.evaluator_config.prompt
+
+    def test_placeholder_order_actual_then_expected(self):
+        """Test that when both placeholders are added, ActualOutput comes before ExpectedOutput."""
+        original_prompt = "Rate the output quality."
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Find positions of the sections
+        actual_pos = evaluator.evaluator_config.prompt.find("## Actual Output")
+        expected_pos = evaluator.evaluator_config.prompt.find("## Expected Output")
+
+        # ActualOutput should come before ExpectedOutput
+        assert actual_pos < expected_pos
+
+    def test_xml_tags_properly_nested(self):
+        """Test that XML tags are properly nested around placeholders."""
+        original_prompt = "Evaluate."
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Check proper nesting for ActualOutput
+        actual_section = evaluator.evaluator_config.prompt[
+            evaluator.evaluator_config.prompt.find("## Actual Output") :
+        ]
+        assert "<ActualOutput>" in actual_section
+        assert "{{ActualOutput}}" in actual_section
+        assert "</ActualOutput>" in actual_section
+
+        # Verify order: opening tag, placeholder, closing tag
+        opening_tag_pos = actual_section.find("<ActualOutput>")
+        placeholder_pos = actual_section.find("{{ActualOutput}}")
+        closing_tag_pos = actual_section.find("</ActualOutput>")
+
+        assert opening_tag_pos < placeholder_pos < closing_tag_pos
+
+    def test_custom_placeholder_delimiters_not_affected(self):
+        """Test that custom placeholder delimiters (curly braces) are preserved."""
+        original_prompt = "Evaluate: {{ActualOutput}} vs {{ExpectedOutput}}"
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Double braces should be preserved
+        assert "{{ActualOutput}}" in evaluator.evaluator_config.prompt
+        assert "{{ExpectedOutput}}" in evaluator.evaluator_config.prompt
+        # Single braces in tags should not interfere
+        assert (
+            "<ActualOutput>" not in evaluator.evaluator_config.prompt
+        )  # Shouldn't be added
+        assert (
+            "<ExpectedOutput>" not in evaluator.evaluator_config.prompt
+        )  # Shouldn't be added
+
+    def test_sections_appended_not_prepended(self):
+        """Test that missing sections are appended to the end, not prepended."""
+        original_prompt = "Original prompt content at the start."
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Original prompt should be at the start
+        assert evaluator.evaluator_config.prompt.startswith("Original prompt content")
+        # Added sections should be at the end
+        assert evaluator.evaluator_config.prompt.index("## Actual Output") > len(
+            original_prompt
+        )
+
+    def test_multiline_prompt_with_missing_placeholders(self):
+        """Test placeholder addition works with multiline prompts."""
+        original_prompt = """
+You are an expert evaluator.
+
+Task: Evaluate the quality of the agent output.
+
+Consider the following criteria:
+1. Accuracy
+2. Completeness
+3. Clarity
+
+Provide a score from 0-100.
+"""
+
+        config = {
+            "name": "TestEvaluator",
+            "prompt": original_prompt,
+            "model": "gpt-4",
+        }
+
+        with patch("uipath.platform.UiPath"):
+            evaluator = LLMJudgeOutputEvaluator.model_validate(
+                {"evaluatorConfig": config, "id": str(uuid.uuid4())}
+            )
+
+        # Original multiline content should be preserved
+        assert "You are an expert evaluator." in evaluator.evaluator_config.prompt
+        assert "1. Accuracy" in evaluator.evaluator_config.prompt
+
+        # Both placeholders should be added at the end
+        assert "## Actual Output" in evaluator.evaluator_config.prompt
+        assert "## Expected Output" in evaluator.evaluator_config.prompt
+        assert evaluator.evaluator_config.prompt.index("## Actual Output") > len(
+            original_prompt
+        )
diff --git a/packages/uipath/tests/evaluators/test_output_path.py b/packages/uipath/tests/evaluators/test_output_path.py
new file mode 100644
index 000000000..9e2947556
--- /dev/null
+++ b/packages/uipath/tests/evaluators/test_output_path.py
@@ -0,0 +1,152 @@
+"""Tests for resolve_output_path utility function.
+
+Covers: wildcard, flat key, nested dot notation, array indexing,
+mixed paths, error handling, and edge cases.
+"""
+
+from typing import Any
+
+import pytest
+
+from uipath.eval._helpers.output_path import resolve_output_path
+
+
+class TestResolveOutputPath:
+    """Test suite for resolve_output_path."""
+
+    # --- Wildcard ("*") ---
+
+    def test_wildcard_returns_full_output_dict(self) -> None:
+        output = {"a": 1, "b": 2}
+        assert resolve_output_path(output, "*") == {"a": 1, "b": 2}
+
+    def test_wildcard_returns_full_output_string(self) -> None:
+        assert resolve_output_path("hello", "*") == "hello"
+
+    def test_wildcard_returns_full_output_list(self) -> None:
+        assert resolve_output_path([1, 2, 3], "*") == [1, 2, 3]
+
+    # --- Flat key ---
+
+    def test_flat_key_lookup(self) -> None:
+        output = {"result": 42, "extra": "ignore"}
+        assert resolve_output_path(output, "result") == 42
+
+    def test_flat_key_returns_nested_dict(self) -> None:
+        output = {"summary": {"total": 100, "count": 5}}
+        assert resolve_output_path(output, "summary") == {"total": 100, "count": 5}
+
+    # --- Nested dot notation ---
+
+    def test_nested_dot_two_levels(self) -> None:
+        output = {"summary": {"status": "completed"}}
+        assert resolve_output_path(output, "summary.status") == "completed"
+
+    def test_nested_dot_three_levels(self) -> None:
+        output = {
+            "customer": {
+                "address": {
+                    "city": "Springfield",
+                }
+            }
+        }
+        assert resolve_output_path(output, "customer.address.city") == "Springfield"
+
+    def test_nested_dot_numeric_value(self) -> None:
+        output = {"order": {"summary": {"total": 44.97}}}
+        assert resolve_output_path(output, "order.summary.total") == 44.97
+
+    # --- Array indexing ---
+
+    def test_array_index_first(self) -> None:
+        output = {"items": ["a", "b", "c"]}
+        assert resolve_output_path(output, "items[0]") == "a"
+
+    def test_array_index_last(self) -> None:
+        output = {"items": ["a", "b", "c"]}
+        assert resolve_output_path(output, "items[2]") == "c"
+
+    def test_array_index_with_nested_property(self) -> None:
+        output = {
+            "items": [
+                {"name": "Widget", "price": 9.99},
+                {"name": "Gadget", "price": 24.99},
+            ]
+        }
+        assert resolve_output_path(output, "items[0].name") == "Widget"
+        assert resolve_output_path(output, "items[1].price") == 24.99
+
+    def test_array_index_on_flat_array(self) -> None:
+        output = {"tags": ["priority", "express", "verified"]}
+        assert resolve_output_path(output, "tags[1]") == "express"
+
+    # --- Mixed deep paths ---
+
+    def test_mixed_nested_and_array(self) -> None:
+        output = {
+            "data": {
+                "results": [
+                    {"details": {"score": 95}},
+                    {"details": {"score": 87}},
+                ]
+            }
+        }
+        assert resolve_output_path(output, "data.results[0].details.score") == 95
+        assert resolve_output_path(output, "data.results[1].details.score") == 87
+
+    def test_deeply_nested_array_of_arrays(self) -> None:
+        output = {"matrix": [[1, 2], [3, 4]]}
+        assert resolve_output_path(output, "matrix[0][1]") == 2
+        assert resolve_output_path(output, "matrix[1][0]") == 3
+
+    # --- Error handling ---
+
+    def test_missing_key_raises_key_error(self) -> None:
+        output = {"a": 1}
+        with pytest.raises(KeyError):
+            resolve_output_path(output, "missing_key")
+
+    def test_missing_nested_key_raises_key_error(self) -> None:
+        output = {"a": {"b": 1}}
+        with pytest.raises(KeyError):
+            resolve_output_path(output, "a.missing")
+
+    def test_array_index_out_of_range(self) -> None:
+        output = {"items": [1, 2]}
+        with pytest.raises(IndexError):
+            resolve_output_path(output, "items[5]")
+
+    def test_index_on_non_list_raises_type_error(self) -> None:
+        output = {"value": "string"}
+        with pytest.raises(TypeError):
+            resolve_output_path(output, "value[0]")
+
+    def test_key_on_non_dict_raises_type_error(self) -> None:
+        output = {"value": 42}
+        with pytest.raises(TypeError):
+            resolve_output_path(output, "value.nested")
+
+    def test_invalid_empty_path_raises_value_error(self) -> None:
+        with pytest.raises(ValueError):
+            resolve_output_path({"a": 1}, "")
+
+    # --- Edge cases ---
+
+    def test_output_is_none(self) -> None:
+        assert resolve_output_path(None, "*") is None
+
+    def test_path_with_numeric_string_key(self) -> None:
+        output = {"123": "numeric-key"}
+        assert resolve_output_path(output, "123") == "numeric-key"
+
+    def test_nested_none_value(self) -> None:
+        output = {"a": {"b": None}}
+        assert resolve_output_path(output, "a.b") is None
+
+    def test_empty_dict_value(self) -> None:
+        output: dict[str, Any] = {"a": {}}
+        assert resolve_output_path(output, "a") == {}
+
+    def test_bool_value(self) -> None:
+        output = {"active": True}
+        assert resolve_output_path(output, "active") is True
diff --git a/packages/uipath/tests/functions/__init__.py b/packages/uipath/tests/functions/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/uipath/tests/functions/test_debug_breakpoints.py b/packages/uipath/tests/functions/test_debug_breakpoints.py
new file mode 100644
index 000000000..4735f9e2a
--- /dev/null
+++ b/packages/uipath/tests/functions/test_debug_breakpoints.py
@@ -0,0 +1,837 @@
+"""E2E tests for the debug breakpoint stack.
+
+Composition under test (same as production):
+
+    UiPathDebugRuntime              ← bridge I/O, resume loop
+      └─ UiPathDebugFunctionsRuntime ← sys.settrace line breakpoints
+           └─ UiPathFunctionsRuntime  ← loads & executes user code
+
+MockDebugBridge implements UiPathDebugProtocol (same interface as
+ConsoleDebugBridge / SignalRDebugBridge) and auto-resumes on every
+breakpoint so the full loop completes without human interaction.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+import pytest
+
+from uipath.functions.debug import BreakpointController, UiPathDebugFunctionsRuntime
+from uipath.functions.runtime import UiPathFunctionsRuntime
+from uipath.runtime import (
+    UiPathBreakpointResult,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+from uipath.runtime.debug import UiPathDebugRuntime
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+
+
+class MockDebugBridge:
+    """Test double that implements UiPathDebugProtocol.
+
+    * Auto-resumes immediately on every ``wait_for_resume`` call.
+    * Records every breakpoint hit so tests can assert on them.
+    * ``wait_for_terminate`` blocks forever (never quits on its own).
+    """
+
+    def __init__(self, breakpoints: list[str] | Literal["*"]) -> None:
+        self._breakpoints = breakpoints
+        self.breakpoint_hits: list[UiPathBreakpointResult] = []
+        self.completed_result: UiPathRuntimeResult | None = None
+        self.state_updates: list[UiPathRuntimeStateEvent] = []
+        self.errors: list[str] = []
+        self.connected = False
+        self.execution_started = False
+
+    async def connect(self) -> None:
+        self.connected = True
+
+    async def disconnect(self) -> None:
+        self.connected = False
+
+    async def emit_execution_started(self, **kwargs: Any) -> None:
+        self.execution_started = True
+
+    async def emit_state_update(self, state_event: UiPathRuntimeStateEvent) -> None:
+        self.state_updates.append(state_event)
+
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        self.breakpoint_hits.append(breakpoint_result)
+
+    async def emit_execution_suspended(
+        self, runtime_result: UiPathRuntimeResult
+    ) -> None:
+        pass
+
+    async def emit_execution_resumed(self, resume_data: Any) -> None:
+        pass
+
+    async def emit_execution_completed(
+        self, runtime_result: UiPathRuntimeResult
+    ) -> None:
+        self.completed_result = runtime_result
+
+    async def emit_execution_error(self, error: str) -> None:
+        self.errors.append(error)
+
+    async def wait_for_resume(self) -> Any:
+        return None  # auto-resume
+
+    async def wait_for_terminate(self) -> None:
+        await asyncio.Event().wait()  # block forever
+
+    def get_breakpoints(self) -> list[str] | Literal["*"]:
+        return self._breakpoints
+
+
+def _write_script(directory: Path, name: str, content: str) -> Path:
+    path = directory / name
+    path.write_text(content)
+    return path
+
+
+def _build_stack(
+    script: Path,
+    breakpoints: list[str] | Literal["*"],
+    func_name: str = "main",
+) -> tuple[UiPathDebugRuntime, MockDebugBridge]:
+    """Build the full debug stack and return (runtime, bridge)."""
+    inner = UiPathFunctionsRuntime(str(script), func_name, script.name)
+    debug_fn = UiPathDebugFunctionsRuntime(
+        inner, entrypoint_path=str(script), function_name=func_name
+    )
+    bridge = MockDebugBridge(breakpoints=breakpoints)
+    runtime = UiPathDebugRuntime(delegate=debug_fn, debug_bridge=bridge)
+    return runtime, bridge
+
+
+@pytest.fixture()
+def script_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Temp directory used as cwd so BreakpointController treats scripts as project files."""
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.syspath_prepend(tmp_path)
+    return tmp_path
+
+
+class TestBreakpointE2E:
+    async def test_single_breakpoint_pauses_and_resumes(self, script_dir: Path):
+        # Line 1: def main(input):
+        # Line 2:     x = input.get("value", 10)
+        # Line 3:     y = x * 2                     ← breakpoint
+        # Line 4:     z = y + 5
+        # Line 5:     return {"result": z}
+        script = _write_script(
+            script_dir,
+            "calc.py",
+            "def main(input):\n"
+            '    x = input.get("value", 10)\n'
+            "    y = x * 2\n"
+            "    z = y + 5\n"
+            '    return {"result": z}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["3"])
+
+        try:
+            result = await runtime.execute({"value": 7})
+
+            assert len(bridge.breakpoint_hits) == 1
+            hit = bridge.breakpoint_hits[0]
+            assert hit.status == UiPathRuntimeStatus.SUSPENDED
+            assert hit.breakpoint_type == "before"
+            assert hit.current_state["x"] == 7
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"result": 19}  # (7*2)+5
+
+            assert bridge.execution_started
+            assert bridge.completed_result is not None
+        finally:
+            await runtime.dispose()
+
+    async def test_multiple_breakpoints_fire_in_order(self, script_dir: Path):
+        # Line 1: def main(input):
+        # Line 2:     a = 1
+        # Line 3:     b = 2                   ← bp 1
+        # Line 4:     c = a + b
+        # Line 5:     d = c * 10              ← bp 2
+        # Line 6:     return {"result": d}
+        script = _write_script(
+            script_dir,
+            "multi.py",
+            "def main(input):\n"
+            "    a = 1\n"
+            "    b = 2\n"
+            "    c = a + b\n"
+            "    d = c * 10\n"
+            '    return {"result": d}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["3", "5"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 2
+            # bp1 @ line 3: a is set, b not yet
+            assert bridge.breakpoint_hits[0].current_state["a"] == 1
+            assert "b" not in bridge.breakpoint_hits[0].current_state
+            # bp2 @ line 5: a, b, c set; d not yet
+            assert bridge.breakpoint_hits[1].current_state["c"] == 3
+            assert "d" not in bridge.breakpoint_hits[1].current_state
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"result": 30}
+        finally:
+            await runtime.dispose()
+
+    async def test_step_mode_breaks_every_line(self, script_dir: Path):
+        script = _write_script(
+            script_dir,
+            "steps.py",
+            'def main(input):\n    x = 1\n    y = 2\n    return {"sum": x + y}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints="*")
+
+        try:
+            result = await runtime.execute({})
+
+            # Lines 2, 3, 4 — each executable statement
+            assert len(bridge.breakpoint_hits) >= 3
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"sum": 3}
+        finally:
+            await runtime.dispose()
+
+    async def test_file_colon_line_breakpoint_format(self, script_dir: Path):
+        # Line 1: def main(input):
+        # Line 2:     msg = "hello"
+        # Line 3:     return {"message": msg}     ← bp via "qualified.py:3"
+        script = _write_script(
+            script_dir,
+            "qualified.py",
+            'def main(input):\n    msg = "hello"\n    return {"message": msg}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["qualified.py:3"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 1
+            assert bridge.breakpoint_hits[0].current_state["msg"] == "hello"
+            assert result.output == {"message": "hello"}
+        finally:
+            await runtime.dispose()
+
+    async def test_no_breakpoints_completes_immediately(self, script_dir: Path):
+        script = _write_script(
+            script_dir,
+            "passthrough.py",
+            'def main(input):\n    return {"ok": True}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=[])
+
+        try:
+            result = await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 0
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"ok": True}
+            assert bridge.completed_result is not None
+        finally:
+            await runtime.dispose()
+
+    async def test_breakpoint_captures_complex_locals(self, script_dir: Path):
+        # Line 5 breakpoint — items, mapping, obj all set; total not yet
+        script = _write_script(
+            script_dir,
+            "locals_test.py",
+            "def main(input):\n"
+            "    items = [1, 2, 3]\n"
+            '    mapping = {"key": "value"}\n'
+            "    obj = object()\n"
+            "    total = sum(items)\n"
+            '    return {"total": total}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["5"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 1
+            state = bridge.breakpoint_hits[0].current_state
+            assert state["items"] == [1, 2, 3]
+            assert state["mapping"] == {"key": "value"}
+            assert isinstance(state["obj"], str)
+            assert "object" in state["obj"]
+            assert result.output == {"total": 6}
+        finally:
+            await runtime.dispose()
+
+    async def test_breakpoint_in_nested_function(self, script_dir: Path):
+        # bp on nested.py:3 → inside helper(), doubled should be set
+        script = _write_script(
+            script_dir,
+            "nested.py",
+            "def helper(n):\n"
+            "    doubled = n * 2\n"
+            "    return doubled\n"
+            "\n"
+            "def main(input):\n"
+            '    val = input.get("n", 5)\n'
+            "    result = helper(val)\n"
+            '    return {"result": result}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["nested.py:3"])
+
+        try:
+            result = await runtime.execute({"n": 4})
+
+            assert len(bridge.breakpoint_hits) == 1
+            assert bridge.breakpoint_hits[0].current_state["doubled"] == 8
+            assert result.output == {"result": 8}
+        finally:
+            await runtime.dispose()
+
+    async def test_breakpoint_node_format(self, script_dir: Path):
+        script = _write_script(
+            script_dir,
+            "node_fmt.py",
+            'def main(input):\n    x = 42\n    return {"x": x}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["2"])
+
+        try:
+            await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 1
+            node = bridge.breakpoint_hits[0].breakpoint_node
+            assert "node_fmt.py" in node
+            assert ":2" in node
+        finally:
+            await runtime.dispose()
+
+    async def test_bridge_lifecycle_events(self, script_dir: Path):
+        """connect / emit_execution_started / emit_execution_completed / disconnect all fire."""
+        script = _write_script(
+            script_dir,
+            "lifecycle.py",
+            'def main(input):\n    return {"done": True}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=[])
+
+        try:
+            await runtime.execute({})
+
+            assert bridge.execution_started
+            assert bridge.completed_result is not None
+            assert bridge.completed_result.status == UiPathRuntimeStatus.SUCCESSFUL
+        finally:
+            await runtime.dispose()
+            assert not bridge.connected  # disconnect called by dispose
+
+    async def test_bridge_receives_breakpoint_then_completion(self, script_dir: Path):
+        """Bridge sees emit_breakpoint_hit followed by emit_execution_completed."""
+        script = _write_script(
+            script_dir,
+            "bpcomp.py",
+            'def main(input):\n    x = 1\n    return {"x": x}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["2"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert len(bridge.breakpoint_hits) == 1
+            assert bridge.completed_result is not None
+            assert bridge.completed_result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"x": 1}
+        finally:
+            await runtime.dispose()
+
+    async def test_stream_yields_breakpoint_and_result_events(self, script_dir: Path):
+        """Streaming the debug runtime yields breakpoint events then the final result."""
+        script = _write_script(
+            script_dir,
+            "stream_test.py",
+            'def main(input):\n    a = 10\n    b = 20\n    return {"sum": a + b}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["3"])
+
+        try:
+            events = []
+            async for event in runtime.stream({}):
+                events.append(event)
+
+            bp_events = [e for e in events if isinstance(e, UiPathBreakpointResult)]
+            result_events = [
+                e
+                for e in events
+                if isinstance(e, UiPathRuntimeResult)
+                and not isinstance(e, UiPathBreakpointResult)
+            ]
+
+            assert len(bp_events) == 1
+            assert bp_events[0].current_state["a"] == 10
+            assert len(result_events) == 1
+            assert result_events[0].output == {"sum": 30}
+        finally:
+            await runtime.dispose()
+
+
+class TestBreakpointController:
+    def test_parse_bare_line_numbers(self, script_dir: Path):
+        script = script_dir / "entry.py"
+        script.write_text("x = 1\n")
+
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=["5", "10"],
+            entrypoint_path=str(script),
+        )
+        abspath = str(script.resolve())
+        assert abspath in ctrl._file_breakpoints
+        assert ctrl._file_breakpoints[abspath] == {5, 10}
+
+    def test_parse_file_colon_line(self, script_dir: Path):
+        script = script_dir / "foo.py"
+        script.write_text("x = 1\n")
+
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=["foo.py:7"],
+        )
+        abspath = str(script.resolve())
+        assert abspath in ctrl._file_breakpoints
+        assert 7 in ctrl._file_breakpoints[abspath]
+
+    def test_step_mode(self, script_dir: Path):
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints="*",
+        )
+        assert ctrl._step_mode is True
+        assert ctrl._file_breakpoints == {}
+
+    def test_update_breakpoints_replaces_set(self, script_dir: Path):
+        script = script_dir / "up.py"
+        script.write_text("x = 1\n")
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=["3"],
+            entrypoint_path=str(script),
+        )
+        abspath = str(script.resolve())
+        assert ctrl._file_breakpoints[abspath] == {3}
+
+        ctrl.update_breakpoints(["7", "9"])
+        assert ctrl._file_breakpoints[abspath] == {7, 9}
+
+    def test_update_to_step_mode(self, script_dir: Path):
+        script = script_dir / "s.py"
+        script.write_text("x = 1\n")
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=["3"],
+            entrypoint_path=str(script),
+        )
+        assert ctrl._step_mode is False
+
+        ctrl.update_breakpoints("*")
+        assert ctrl._step_mode is True
+        assert ctrl._file_breakpoints == {}
+
+    def test_invalid_breakpoint_strings_ignored(self, script_dir: Path):
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=["not_a_number", "agent_node_name"],
+        )
+        assert ctrl._file_breakpoints == {}
+
+    def test_is_project_file(self, script_dir: Path):
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=[],
+        )
+        assert ctrl._is_project_file(str(script_dir / "main.py"))
+        assert not ctrl._is_project_file(str(script_dir / "site-packages" / "lib.py"))
+        assert not ctrl._is_project_file("/some/other/path/foo.py")
+
+    def test_is_project_file_rejects_frozen_modules(self, script_dir: Path):
+        """Frozen/built-in module paths must not pass the project-file check."""
+        ctrl = BreakpointController(
+            project_dir=str(script_dir),
+            breakpoints=[],
+        )
+        # os.path.abspath("<frozen importlib._bootstrap>") resolves under cwd
+        frozen_resolved = os.path.abspath("<frozen importlib._bootstrap_external>")
+        assert not ctrl._is_project_file(frozen_resolved)
+
+
+class TestStateEvents:
+    """State events should fire only for call-graph functions."""
+
+    async def test_state_events_emitted_for_graph_functions(self, script_dir: Path):
+        """State events fire for the entrypoint and functions it calls."""
+        _write_script(
+            script_dir,
+            "helpers.py",
+            "def helper(n):\n    return n * 2\n",
+        )
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "from helpers import helper\n"
+            "\n"
+            "def main(input):\n"
+            '    val = input.get("n", 5)\n'
+            "    result = helper(val)\n"  # line 5
+            '    return {"result": result}\n',
+        )
+        # Use step mode so the controller path is active and state events fire
+        runtime, bridge = _build_stack(script, breakpoints="*")
+
+        try:
+            result = await runtime.execute({"n": 3})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"result": 6}
+
+            # State events should include main and helper
+            state_names = [s.node_name for s in bridge.state_updates]
+            assert "main" in state_names
+            assert "helper" in state_names
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_not_emitted_for_external_functions(
+        self, script_dir: Path
+    ):
+        """Functions from external modules (json, os, etc.) should NOT produce state events."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "import json\n"
+            "\n"
+            "def main(input):\n"
+            '    data = json.dumps({"hello": "world"})\n'  # line 4
+            '    return {"data": data}\n',
+        )
+        # Step mode to activate the controller (and state events)
+        runtime, bridge = _build_stack(script, breakpoints="*")
+
+        try:
+            result = await runtime.execute({})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+
+            state_names = [s.node_name for s in bridge.state_updates]
+            # Only main — json.dumps is external; 2 events: started + completed
+            assert all(name == "main" for name in state_names)
+            assert len(state_names) == 2
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_carry_locals(self, script_dir: Path):
+        """State event payload should contain the function's arguments."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "def helper(x, y):\n"
+            "    return x + y\n"
+            "\n"
+            "def main(input):\n"
+            "    return helper(1, 2)\n",  # line 5
+        )
+        # Use a breakpoint to activate the controller path
+        runtime, bridge = _build_stack(script, breakpoints=["5"])
+
+        try:
+            await runtime.execute({})
+
+            helper_started = [
+                s
+                for s in bridge.state_updates
+                if s.node_name == "helper"
+                and s.phase == UiPathRuntimeStatePhase.STARTED
+            ]
+            helper_completed = [
+                s
+                for s in bridge.state_updates
+                if s.node_name == "helper"
+                and s.phase == UiPathRuntimeStatePhase.COMPLETED
+            ]
+            assert len(helper_started) == 1
+            assert len(helper_completed) == 1
+            # At call time, x and y should be in the payload
+            assert helper_started[0].payload["x"] == 1
+            assert helper_started[0].payload["y"] == 2
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_with_breakpoints(self, script_dir: Path):
+        """State events and breakpoints work together."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "def helper():\n"
+            "    return 42\n"
+            "\n"
+            "def main(input):\n"
+            "    x = helper()\n"  # line 5
+            '    return {"x": x}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=["5"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"x": 42}
+
+            # Should have both state updates and breakpoint hits
+            assert len(bridge.breakpoint_hits) == 1
+            state_names = [s.node_name for s in bridge.state_updates]
+            assert "main" in state_names
+        finally:
+            await runtime.dispose()
+
+    async def test_no_state_events_without_function_name(self, script_dir: Path):
+        """When function_name is not provided, no state events fire (even with breakpoints)."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            'def main(input):\n    x = 1\n    return {"ok": True}\n',
+        )
+        inner = UiPathFunctionsRuntime(str(script), "main", script.name)
+        # No function_name → no graph → no state events
+        debug_fn = UiPathDebugFunctionsRuntime(inner, entrypoint_path=str(script))
+        bridge = MockDebugBridge(breakpoints=["2"])
+        runtime = UiPathDebugRuntime(delegate=debug_fn, debug_bridge=bridge)
+
+        try:
+            result = await runtime.execute({})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert len(bridge.breakpoint_hits) == 1
+            assert len(bridge.state_updates) == 0
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_emitted_without_breakpoints(self, script_dir: Path):
+        """State events fire even without breakpoints when the call graph exists."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "def helper():\n"
+            "    return 42\n"
+            "\n"
+            "def main(input):\n"
+            "    x = helper()\n"
+            '    return {"x": x}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints=[])
+
+        try:
+            result = await runtime.execute({})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"x": 42}
+
+            # State events fire even with no breakpoints
+            state_names = [s.node_name for s in bridge.state_updates]
+            assert "main" in state_names
+            assert "helper" in state_names
+            # No breakpoints should have been hit
+            assert len(bridge.breakpoint_hits) == 0
+        finally:
+            await runtime.dispose()
+
+    async def test_multiline_expression_breakpoint_hits_once(self, script_dir: Path):
+        """Breakpoint on a multiline call expression should fire exactly once.
+
+        Python's bytecode bounces back to the call-site line after
+        evaluating nested arguments on deeper lines, e.g.::
+
+            return Wrapper(          # line 5 — LOAD_GLOBAL + CALL
+                result=choice(       # line 6
+                    [1, 2, 3]        # line 7
+                )                    # ← CALL choice → back to line 6
+            )                        # ← CALL Wrapper → back to line 5
+
+        Without deduplication the breakpoint on line 5 fires twice.
+        """
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "import random\n"  # 1
+            "\n"  # 2
+            "async def get_random():\n"  # 3
+            '    """Get a random value."""\n'  # 4
+            "    return dict(\n"  # 5
+            "        value=random.choice(\n"  # 6
+            "            [1, 2, 3]\n"  # 7
+            "        )\n"  # 8
+            "    )\n"  # 9
+            "\n"  # 10
+            "async def main(input):\n"  # 11
+            "    result = await get_random()\n"  # 12
+            '    return {"result": result}\n',  # 13
+        )
+        # Breakpoint on line 5 — the first body line (multiline return)
+        runtime, bridge = _build_stack(script, breakpoints=["main.py:5"])
+
+        try:
+            result = await runtime.execute({})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+
+            # The breakpoint should fire exactly ONCE despite bytecode bouncing
+            bp_nodes = [h.breakpoint_node for h in bridge.breakpoint_hits]
+            assert len(bridge.breakpoint_hits) == 1, (
+                f"Expected 1 breakpoint hit but got {len(bridge.breakpoint_hits)}: {bp_nodes}"
+            )
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_through_decorator_wrappers(self, script_dir: Path):
+        """State events fire for functions wrapped with functools.wraps decorators.
+
+        Simulates @traced-style decorators where the wrapper (sync_wrapper/
+        async_wrapper) lives in an external module. The trace callback should
+        still fire for the ORIGINAL function called from within the wrapper.
+        """
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "from functools import wraps\n"
+            "\n"
+            "def my_decorator(func):\n"
+            "    @wraps(func)\n"
+            "    def wrapper(*args, **kwargs):\n"
+            "        return func(*args, **kwargs)\n"
+            "    return wrapper\n"
+            "\n"
+            "@my_decorator\n"
+            "def track_operator(op):\n"
+            "    pass\n"
+            "\n"
+            "@my_decorator\n"
+            "def apply_operator(op, a, b):\n"
+            "    return a + b\n"
+            "\n"
+            "def main(input):\n"
+            '    op = input.get("op", "+")\n'
+            "    track_operator(op)\n"
+            '    result = apply_operator(op, input.get("a", 1), input.get("b", 2))\n'
+            '    return {"result": result}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints="*")
+
+        try:
+            result = await runtime.execute({"a": 3, "b": 4})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"result": 7}
+
+            state_names = [s.node_name for s in bridge.state_updates]
+            assert "main" in state_names
+            assert "track_operator" in state_names
+            assert "apply_operator" in state_names
+        finally:
+            await runtime.dispose()
+
+    async def test_state_events_have_started_and_completed_phases(
+        self, script_dir: Path
+    ):
+        """Each tracked function should emit both STARTED and COMPLETED phase events."""
+        _write_script(
+            script_dir,
+            "phase_helpers.py",
+            "def helper(n):\n    return n * 2\n",
+        )
+        script = _write_script(
+            script_dir,
+            "main.py",
+            "from phase_helpers import helper\n"
+            "\n"
+            "def main(input):\n"
+            '    val = input.get("n", 5)\n'
+            "    result = helper(val)\n"
+            '    return {"result": result}\n',
+        )
+        runtime, bridge = _build_stack(script, breakpoints="*")
+
+        try:
+            result = await runtime.execute({"n": 3})
+
+            assert result.status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result.output == {"result": 6}
+
+            # Each tracked function (main, helper) should have started + completed
+            for func_name in ("main", "helper"):
+                started = [
+                    s
+                    for s in bridge.state_updates
+                    if s.node_name == func_name
+                    and s.phase == UiPathRuntimeStatePhase.STARTED
+                ]
+                completed = [
+                    s
+                    for s in bridge.state_updates
+                    if s.node_name == func_name
+                    and s.phase == UiPathRuntimeStatePhase.COMPLETED
+                ]
+                assert len(started) == 1, f"{func_name} should have 1 STARTED event"
+                assert len(completed) == 1, f"{func_name} should have 1 COMPLETED event"
+
+            # Completed events should carry __return__ key
+            helper_completed = [
+                s
+                for s in bridge.state_updates
+                if s.node_name == "helper"
+                and s.phase == UiPathRuntimeStatePhase.COMPLETED
+            ]
+            assert "__return__" in helper_completed[0].payload
+        finally:
+            await runtime.dispose()
+
+    async def test_stream_phase_events_from_functions_runtime(self, script_dir: Path):
+        """UiPathFunctionsRuntime.stream() emits STARTED → COMPLETED → result."""
+        script = _write_script(
+            script_dir,
+            "main.py",
+            'def main(input):\n    return {"value": input.get("x", 0) + 1}\n',
+        )
+        inner = UiPathFunctionsRuntime(str(script), "main", script.name)
+
+        try:
+            events = []
+            async for event in inner.stream({"x": 5}):
+                events.append(event)
+
+            # Should be: STARTED state event, COMPLETED state event, result
+            state_events = [e for e in events if isinstance(e, UiPathRuntimeStateEvent)]
+            result_events = [
+                e
+                for e in events
+                if isinstance(e, UiPathRuntimeResult)
+                and not isinstance(e, UiPathBreakpointResult)
+            ]
+
+            assert len(state_events) == 2
+            assert state_events[0].phase == UiPathRuntimeStatePhase.STARTED
+            assert state_events[0].payload == {"x": 5}
+            assert state_events[1].phase == UiPathRuntimeStatePhase.COMPLETED
+            assert state_events[1].payload == {"value": 6}
+
+            assert len(result_events) == 1
+            assert result_events[0].status == UiPathRuntimeStatus.SUCCESSFUL
+            assert result_events[0].output == {"value": 6}
+        finally:
+            await inner.dispose()
diff --git a/packages/uipath/tests/functions/test_graph_builder.py b/packages/uipath/tests/functions/test_graph_builder.py
new file mode 100644
index 000000000..56bf97cd3
--- /dev/null
+++ b/packages/uipath/tests/functions/test_graph_builder.py
@@ -0,0 +1,337 @@
+"""Tests for the AST-based call graph builder."""
+
+import textwrap
+
+import pytest
+
+from uipath.functions.graph_builder import build_call_graph
+
+
+@pytest.fixture
+def project_dir(tmp_path):
+    """Create a small multi-file project for testing."""
+    # main.py — the entrypoint
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        from helpers import process_data
+        from utils import format_output
+
+        def main(input):
+            result = process_data(input)
+            return format_output(result)
+        """)
+    )
+
+    # helpers.py — calls into a deeper utility
+    (tmp_path / "helpers.py").write_text(
+        textwrap.dedent("""\
+        from deep import transform
+
+        def process_data(data):
+            return transform(data)
+
+        def unused_function():
+            pass
+        """)
+    )
+
+    # utils.py — leaf function
+    (tmp_path / "utils.py").write_text(
+        textwrap.dedent("""\
+        def format_output(data):
+            return str(data)
+        """)
+    )
+
+    # deep.py — deeper than default depth
+    (tmp_path / "deep.py").write_text(
+        textwrap.dedent("""\
+        def transform(data):
+            return data
+        """)
+    )
+
+    return tmp_path
+
+
+def test_basic_graph_structure(project_dir):
+    """Entrypoint node and its direct callees are discovered."""
+    graph = build_call_graph(
+        str(project_dir / "main.py"),
+        "main",
+        project_dir=str(project_dir),
+        max_depth=3,
+    )
+
+    node_names = {n.name for n in graph.nodes}
+
+    # Should contain main, process_data, format_output, transform
+    assert "main" in node_names
+    assert "process_data" in node_names
+    assert "format_output" in node_names
+    assert "transform" in node_names
+
+    # unused_function should NOT appear
+    assert "unused_function" not in node_names
+
+
+def test_node_ids_are_file_line(project_dir):
+    """Node IDs must follow the file:line format for breakpoints."""
+    graph = build_call_graph(
+        str(project_dir / "main.py"),
+        "main",
+        project_dir=str(project_dir),
+    )
+
+    for node in graph.nodes:
+        parts = node.id.rsplit(":", 1)
+        assert len(parts) == 2, f"Node ID '{node.id}' is not in file:line format"
+        assert parts[1].isdigit(), f"Line part of '{node.id}' is not a number"
+
+
+def test_edges_connect_caller_to_callee(project_dir):
+    """Edges should go from caller to callee."""
+    graph = build_call_graph(
+        str(project_dir / "main.py"),
+        "main",
+        project_dir=str(project_dir),
+    )
+
+    id_to_name = {n.id: n.name for n in graph.nodes}
+    edge_pairs = {(id_to_name[e.source], id_to_name[e.target]) for e in graph.edges}
+
+    assert ("main", "process_data") in edge_pairs
+    assert ("main", "format_output") in edge_pairs
+    assert ("process_data", "transform") in edge_pairs
+
+
+def test_max_depth_limits_recursion(project_dir):
+    """Setting max_depth=1 should only include the entrypoint and its direct calls."""
+    graph = build_call_graph(
+        str(project_dir / "main.py"),
+        "main",
+        project_dir=str(project_dir),
+        max_depth=1,
+    )
+
+    node_names = {n.name for n in graph.nodes}
+
+    assert "main" in node_names
+    assert "process_data" in node_names
+    assert "format_output" in node_names
+    # transform is 2 levels deep, should be excluded
+    assert "transform" not in node_names
+
+
+def test_no_duplicates_on_repeated_calls(tmp_path):
+    """A function called multiple times should appear as one node."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        def helper():
+            pass
+
+        def main():
+            helper()
+            helper()
+            helper()
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    names = [n.name for n in graph.nodes]
+    assert names.count("helper") == 1
+    # But there can be multiple edges (one per call site)
+
+
+def test_local_function_calls(tmp_path):
+    """Functions defined in the same file are resolved."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        def step_a():
+            pass
+
+        def step_b():
+            step_a()
+
+        def main():
+            step_b()
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    node_names = {n.name for n in graph.nodes}
+    assert node_names == {"main", "step_b", "step_a"}
+
+
+def test_async_functions(tmp_path):
+    """Async function definitions and await calls are handled."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        async def helper():
+            pass
+
+        async def main():
+            await helper()
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    node_names = {n.name for n in graph.nodes}
+    assert node_names == {"main", "helper"}
+
+
+def test_external_calls_ignored(tmp_path):
+    """Calls to external/unknown functions produce no nodes."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        import json
+
+        def main(data):
+            return json.dumps(data)
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    assert len(graph.nodes) == 1
+    assert graph.nodes[0].name == "main"
+    assert len(graph.edges) == 0
+
+
+def test_missing_function_returns_empty_graph(tmp_path):
+    """If the entrypoint function doesn't exist, return an empty graph."""
+    (tmp_path / "main.py").write_text("def other(): pass\n")
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    assert len(graph.nodes) == 0
+    assert len(graph.edges) == 0
+
+
+def test_relative_import(tmp_path):
+    """Relative imports (from .module import func) are resolved."""
+    pkg = tmp_path / "pkg"
+    pkg.mkdir()
+    (pkg / "__init__.py").write_text("")
+
+    (pkg / "main.py").write_text(
+        textwrap.dedent("""\
+        from .helpers import do_work
+
+        def main():
+            do_work()
+        """)
+    )
+    (pkg / "helpers.py").write_text(
+        textwrap.dedent("""\
+        def do_work():
+            pass
+        """)
+    )
+
+    graph = build_call_graph(
+        str(pkg / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    node_names = {n.name for n in graph.nodes}
+    assert "main" in node_names
+    assert "do_work" in node_names
+
+
+def test_node_id_uses_last_body_line(tmp_path):
+    """Node ID should point to the last statement in the function body."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        def main(input):
+            x = input.get("value", 10)
+            y = x * 2
+            return {"result": y}
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    assert len(graph.nodes) == 1
+    node = graph.nodes[0]
+    # Last body line is "return {"result": y}" at line 4
+    assert node.id == "main.py:4"
+
+
+def test_node_id_last_line_with_docstring(tmp_path):
+    """Docstring should not affect the last body line calculation."""
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        def main(input):
+            \"\"\"This is a docstring.\"\"\"
+            x = 1
+            y = 2
+            return x + y
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    assert len(graph.nodes) == 1
+    node = graph.nodes[0]
+    # Last body line is "return x + y" at line 5
+    assert node.id == "main.py:5"
+
+
+def test_module_attribute_call(tmp_path):
+    """import module; module.func() pattern is resolved."""
+    (tmp_path / "mymod.py").write_text(
+        textwrap.dedent("""\
+        def compute():
+            pass
+        """)
+    )
+    (tmp_path / "main.py").write_text(
+        textwrap.dedent("""\
+        import mymod
+
+        def main():
+            mymod.compute()
+        """)
+    )
+
+    graph = build_call_graph(
+        str(tmp_path / "main.py"),
+        "main",
+        project_dir=str(tmp_path),
+    )
+
+    node_names = {n.name for n in graph.nodes}
+    assert "compute" in node_names
diff --git a/packages/uipath/tests/functions/test_unwrap_decorated.py b/packages/uipath/tests/functions/test_unwrap_decorated.py
new file mode 100644
index 000000000..37b9d40eb
--- /dev/null
+++ b/packages/uipath/tests/functions/test_unwrap_decorated.py
@@ -0,0 +1,176 @@
+"""Tests that the functions runtime correctly unwraps decorated functions."""
+
+import textwrap
+
+import pytest
+
+from uipath.functions.runtime import UiPathFunctionsRuntime
+from uipath.runtime.errors import UiPathRuntimeError
+from uipath.runtime.events import UiPathRuntimeStateEvent, UiPathRuntimeStatePhase
+
+
+@pytest.fixture
+def decorated_module(tmp_path):
+    """Create a module with a decorated function using functools.wraps."""
+    (tmp_path / "decorated.py").write_text(
+        textwrap.dedent("""\
+        import functools
+        from dataclasses import dataclass
+
+
+        @dataclass
+        class TreeNode:
+            value: int
+            left: "TreeNode | None" = None
+            right: "TreeNode | None" = None
+
+
+        @dataclass
+        class TreeStats:
+            total_nodes: int
+            max_value: int
+
+
+        def mock_traced(func):
+            @functools.wraps(func)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
+            return wrapper
+
+
+        @mock_traced
+        async def main(input: TreeNode) -> TreeStats:
+            return TreeStats(total_nodes=1, max_value=input.value)
+        """)
+    )
+    return tmp_path / "decorated.py"
+
+
+@pytest.mark.asyncio
+async def test_get_schema_unwraps_decorated_function(decorated_module):
+    """get_schema should see through decorators to find the original type hints."""
+    runtime = UiPathFunctionsRuntime(str(decorated_module), "main", "decorated")
+    schema = await runtime.get_schema()
+
+    # The input schema should reflect TreeNode, not be empty
+    assert schema.input is not None
+    props = schema.input.get("properties", {})
+    assert "value" in props
+
+    # The output schema should reflect TreeStats
+    assert schema.output is not None
+    out_props = schema.output.get("properties", {})
+    assert "total_nodes" in out_props
+    assert "max_value" in out_props
+
+
+@pytest.mark.asyncio
+async def test_execute_unwraps_decorated_function(decorated_module):
+    """execute should unwrap the decorator to read the signature, but still call the wrapper."""
+    runtime = UiPathFunctionsRuntime(str(decorated_module), "main", "decorated")
+    result = await runtime.execute({"value": 42})
+
+    assert isinstance(result.output, dict)
+    assert result.output["total_nodes"] == 1
+    assert result.output["max_value"] == 42
+
+
+@pytest.mark.asyncio
+async def test_schema_type_defaults_to_function(decorated_module):
+    """Schema type should be 'function' by default."""
+    runtime = UiPathFunctionsRuntime(str(decorated_module), "main", "decorated")
+    schema = await runtime.get_schema()
+
+    assert schema.type == "function"
+
+
+@pytest.mark.asyncio
+async def test_schema_type_reflects_entrypoint_type(decorated_module):
+    """Schema type should reflect the entrypoint_type passed to the runtime."""
+    runtime_fn = UiPathFunctionsRuntime(
+        str(decorated_module), "main", "decorated", entrypoint_type="function"
+    )
+    schema_fn = await runtime_fn.get_schema()
+    assert schema_fn.type == "function"
+
+    runtime_agent = UiPathFunctionsRuntime(
+        str(decorated_module), "main", "decorated", entrypoint_type="agent"
+    )
+    schema_agent = await runtime_agent.get_schema()
+    assert schema_agent.type == "agent"
+
+
+@pytest.fixture
+def future_annotations_module(tmp_path):
+    """Create a module using `from __future__ import annotations` (PEP 563)."""
+    (tmp_path / "future_ann.py").write_text(
+        textwrap.dedent("""\
+        from __future__ import annotations
+
+        from pydantic import BaseModel
+
+
+        class OrderInput(BaseModel):
+            customer_name: str
+            quantity: int = 1
+
+
+        class OrderOutput(BaseModel):
+            accepted: bool
+            total: float
+
+
+        def main(order: OrderInput) -> OrderOutput:
+            return OrderOutput(accepted=True, total=order.quantity * 9.99)
+        """)
+    )
+    return tmp_path / "future_ann.py"
+
+
+@pytest.mark.asyncio
+async def test_execute_resolves_future_annotations(future_annotations_module):
+    """PEP 563 stringified annotations should be resolved via get_type_hints."""
+    runtime = UiPathFunctionsRuntime(
+        str(future_annotations_module), "main", "future_ann"
+    )
+    result = await runtime.execute({"customer_name": "Alice", "quantity": 2})
+
+    assert result.output == {"accepted": True, "total": 19.98}
+
+
+@pytest.fixture
+def failing_module(tmp_path):
+    """Create a module whose function always raises."""
+    (tmp_path / "failing.py").write_text(
+        textwrap.dedent("""\
+        def main(data: dict) -> dict:
+            raise ValueError("something went wrong")
+        """)
+    )
+    return tmp_path / "failing.py"
+
+
+@pytest.mark.asyncio
+async def test_execute_raises_on_function_error(failing_module):
+    """Function errors should propagate as UiPathRuntimeError, not return FAULTED."""
+    runtime = UiPathFunctionsRuntime(str(failing_module), "main", "failing")
+
+    with pytest.raises(UiPathRuntimeError, match="something went wrong"):
+        await runtime.execute({"key": "value"})
+
+
+@pytest.mark.asyncio
+async def test_stream_yields_faulted_then_raises(failing_module):
+    """stream() should yield STARTED, then FAULTED, then raise UiPathRuntimeError."""
+    runtime = UiPathFunctionsRuntime(str(failing_module), "main", "failing")
+
+    events = []
+    with pytest.raises(UiPathRuntimeError, match="something went wrong"):
+        async for event in runtime.stream({"key": "value"}):
+            events.append(event)
+
+    assert len(events) == 2
+    assert isinstance(events[0], UiPathRuntimeStateEvent)
+    assert events[0].phase == UiPathRuntimeStatePhase.STARTED
+    assert isinstance(events[1], UiPathRuntimeStateEvent)
+    assert events[1].phase == UiPathRuntimeStatePhase.FAULTED
diff --git a/packages/uipath/tests/resource_overrides/__init__.py b/packages/uipath/tests/resource_overrides/__init__.py
new file mode 100644
index 000000000..b13992513
--- /dev/null
+++ b/packages/uipath/tests/resource_overrides/__init__.py
@@ -0,0 +1 @@
+# Resource overrides tests
diff --git a/packages/uipath/tests/resource_overrides/overwrites.json b/packages/uipath/tests/resource_overrides/overwrites.json
new file mode 100644
index 000000000..e0bca84ba
--- /dev/null
+++ b/packages/uipath/tests/resource_overrides/overwrites.json
@@ -0,0 +1,36 @@
+{
+  "asset.asset_name": {
+    "name": "Overwritten Asset Name",
+    "folderPath": "Overwritten/Asset/Folder"
+  },
+  "connection.connection_key": {
+    "connectionId": "overwritten-connection-id-12345",
+    "elementInstanceId": "999999",
+    "folderKey": "overwritten-folder-key-abc",
+    "ConnectionId": "overwritten-connection-id-12345"
+  },
+  "app.app_name": {
+    "name": "Overwritten App Name",
+    "folderPath": "Overwritten/App/Folder"
+  },
+  "index.index_name": {
+    "name": "Overwritten Index Name",
+    "folderPath": "Overwritten/Index/Folder"
+  },
+  "bucket.bucket_name": {
+    "name": "Overwritten Bucket Name",
+    "folderPath": "Overwritten/Bucket/Folder"
+  },
+  "process.process_name": {
+    "name": "Overwritten Process Name",
+    "folderPath": "Overwritten/Process/Folder"
+  },
+  "mcpServer.mcp_server_name": {
+    "name": "Overwritten MCP Server Name",
+    "folderPath": "Overwritten/MCPServer/Folder"
+  },
+  "entity.entity_name": {
+    "name": "Overwritten Entity Name",
+    "folderId": "overwritten-entity-folder-id-123"
+  }
+}
\ No newline at end of file
diff --git a/packages/uipath/tests/resource_overrides/test_overwrites_logging.py b/packages/uipath/tests/resource_overrides/test_overwrites_logging.py
new file mode 100644
index 000000000..e05a7daed
--- /dev/null
+++ b/packages/uipath/tests/resource_overrides/test_overwrites_logging.py
@@ -0,0 +1,308 @@
+# type: ignore
+"""Tests for INFO-level diagnostic logging on the resource-overwrites read paths.
+
+Covers the recent change that surfaces bindings.json content and raw resource
+overwrites (from both uipath.json and the Studio API) at INFO so binding/
+overwrite mismatches can be diagnosed from logs alone.
+"""
+
+import json
+import logging
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from uipath._cli._utils._common import read_resource_overwrites_from_file
+from uipath._cli._utils._studio_project import StudioClient
+from uipath.platform.common import GenericResourceOverwrite
+
+_VALID_OVERWRITES = {
+    "asset.asset_name": {
+        "name": "Overwritten Asset Name",
+        "folderPath": "Overwritten/Asset/Folder",
+    },
+    "bucket.bucket_name": {
+        "name": "Overwritten Bucket Name",
+        "folderPath": "Overwritten/Bucket/Folder",
+    },
+}
+
+
+_TARGET_LOGGERS = (
+    "uipath._cli._utils._common",
+    "uipath._cli._utils._studio_project",
+)
+
+
+@pytest.fixture(autouse=True)
+def _capture_uipath_loggers(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Attach caplog's handler directly to the target module loggers.
+
+    Earlier tests in the suite — chiefly anything that invokes the Click CLI
+    — call ``setup_logging`` and leave the ``uipath`` logger with
+    ``propagate = False``. That breaks the usual caplog flow (handler on
+    root, records reach it via propagation). Some intermediate loggers can
+    also end up with ``propagate = False`` from other test setups. Attaching
+    the handler directly to each module logger we assert against, and
+    forcing the level to DEBUG for the duration of the test, side-steps the
+    propagation question entirely.
+    """
+    snapshots: list[tuple[logging.Logger, int, bool]] = []
+    for name in _TARGET_LOGGERS:
+        logger = logging.getLogger(name)
+        snapshots.append((logger, logger.level, logger.propagate))
+        logger.setLevel(logging.DEBUG)
+        logger.propagate = True
+        logger.addHandler(caplog.handler)
+    try:
+        yield
+    finally:
+        for logger, level, propagate in snapshots:
+            logger.removeHandler(caplog.handler)
+            logger.setLevel(level)
+            logger.propagate = propagate
+
+
+def _write_uipath_json(directory: Path, overwrites: dict) -> Path:
+    config_path = directory / "uipath.json"
+    config_path.write_text(
+        json.dumps(
+            {
+                "runtime": {"internalArguments": {"resourceOverwrites": overwrites}},
+            }
+        )
+    )
+    return config_path
+
+
+class TestReadResourceOverwritesFromFileLogging:
+    """Behavior: read_resource_overwrites_from_file logs diagnostic info at INFO."""
+
+    async def test_logs_raw_overwrites_at_info_when_file_present(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        config_path = _write_uipath_json(tmp_path, _VALID_OVERWRITES)
+
+        with caplog.at_level(logging.INFO, logger="uipath._cli._utils._common"):
+            result = await read_resource_overwrites_from_file(str(tmp_path))
+
+        assert set(result.keys()) == set(_VALID_OVERWRITES.keys())
+
+        info_records = [r for r in caplog.records if r.levelno == logging.INFO]
+        assert any(
+            "Resource overwrites read from" in r.getMessage()
+            and str(config_path) in r.getMessage()
+            and f"({len(_VALID_OVERWRITES)} entries)" in r.getMessage()
+            for r in info_records
+        ), f"expected INFO log with file path and entry count, got: {caplog.text}"
+
+        # The raw JSON payload should be present in the log so a developer can
+        # diff it against what Studio later returns.
+        assert "Overwritten Asset Name" in caplog.text
+        assert "Overwritten Bucket Name" in caplog.text
+
+    async def test_logs_info_when_config_file_missing(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        # tmp_path is empty — no uipath.json present.
+        missing_dir = tmp_path / "does-not-exist"
+        missing_dir.mkdir()
+
+        with caplog.at_level(logging.INFO, logger="uipath._cli._utils._common"):
+            result = await read_resource_overwrites_from_file(str(missing_dir))
+
+        assert result == {}
+        info_messages = [
+            r.getMessage() for r in caplog.records if r.levelno == logging.INFO
+        ]
+        assert any(
+            "Resource overwrites config file not found" in msg for msg in info_messages
+        ), f"expected INFO log for missing config, got: {info_messages}"
+
+    async def test_logs_warning_when_json_is_malformed(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        (tmp_path / "uipath.json").write_text("{not valid json")
+
+        with caplog.at_level(logging.WARNING, logger="uipath._cli._utils._common"):
+            result = await read_resource_overwrites_from_file(str(tmp_path))
+
+        assert result == {}
+        warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
+        assert any(
+            "Failed to parse resource overwrites" in r.getMessage() for r in warnings
+        )
+
+    async def test_unrecognized_overwrite_key_is_skipped_with_warning(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        overwrites = {
+            **_VALID_OVERWRITES,
+            "totallyUnknownKind.foo": {"name": "x", "folderPath": "y"},
+        }
+        _write_uipath_json(tmp_path, overwrites)
+
+        with caplog.at_level(logging.WARNING, logger="uipath._cli._utils._common"):
+            result = await read_resource_overwrites_from_file(str(tmp_path))
+
+        # Valid entries still parsed; unknown key dropped.
+        assert set(result.keys()) == set(_VALID_OVERWRITES.keys())
+        assert any(
+            "Skipping unrecognized resource overwrite" in r.getMessage()
+            and "totallyUnknownKind.foo" in r.getMessage()
+            for r in caplog.records
+            if r.levelno == logging.WARNING
+        )
+
+
+class TestStudioClientGetResourceOverwritesLogging:
+    """Behavior: StudioClient.get_resource_overwrites logs bindings + raw payload."""
+
+    @pytest.fixture
+    def studio_client(self) -> StudioClient:
+        # Inject a mock UiPath so no real HTTP setup is required.
+        mock_uipath = MagicMock()
+        mock_uipath.api_client.request_async = AsyncMock()
+        client = StudioClient(project_id="test-project-id", uipath=mock_uipath)
+        # Avoid the network call that resolves the solution id.
+        client._get_solution_id = AsyncMock(return_value="test-solution-id")  # type: ignore[method-assign]
+        return client
+
+    async def test_warns_and_returns_empty_when_bindings_file_missing(
+        self,
+        studio_client: StudioClient,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        from uipath.platform.common._config import ConfigurationManager
+
+        missing_path = tmp_path / "bindings.json"
+        monkeypatch.setattr(
+            ConfigurationManager,
+            "bindings_file_path",
+            property(lambda self: missing_path),
+        )
+
+        with caplog.at_level(logging.WARNING):
+            result = await studio_client.get_resource_overwrites()
+
+        assert result == {}
+        assert any(
+            "Bindings file not found" in r.getMessage()
+            for r in caplog.records
+            if r.levelno == logging.WARNING
+        )
+        # No request should have been made when there is nothing to upload.
+        studio_client.uipath.api_client.request_async.assert_not_called()
+
+    async def test_logs_bindings_content_and_received_overwrites_at_info(
+        self,
+        studio_client: StudioClient,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        from uipath.platform.common._config import ConfigurationManager
+
+        bindings_path = tmp_path / "bindings.json"
+        bindings_content = json.dumps(
+            {"version": "2", "resources": [{"name": "my_bucket", "kind": "bucket"}]}
+        )
+        bindings_path.write_text(bindings_content)
+        monkeypatch.setattr(
+            ConfigurationManager,
+            "bindings_file_path",
+            property(lambda self: bindings_path),
+        )
+        monkeypatch.delenv("UIPATH_TENANT_ID", raising=False)
+
+        response = MagicMock()
+        response.json.return_value = {
+            "bucket.my_bucket": {
+                "name": "prod_bucket",
+                "folderPath": "Prod/Folder",
+            }
+        }
+        studio_client.uipath.api_client.request_async = AsyncMock(return_value=response)
+
+        with caplog.at_level(logging.INFO, logger="uipath._cli._utils._studio_project"):
+            result = await studio_client.get_resource_overwrites()
+
+        # Returned dict is parsed via ResourceOverwriteParser.
+        assert set(result.keys()) == {"bucket.my_bucket"}
+
+        info_text = "\n".join(
+            r.getMessage() for r in caplog.records if r.levelno == logging.INFO
+        )
+        # Bindings content is logged so we can compare what was sent to Studio.
+        assert "Resource bindings" in info_text
+        assert "my_bucket" in info_text
+        # Received overwrites payload is logged with the solution id and count.
+        assert "Resource overwrites received for solution test-solution-id" in info_text
+        assert "(1 entries)" in info_text
+        assert "prod_bucket" in info_text
+
+    async def test_parses_received_overwrites_into_resource_overwrite_objects(
+        self,
+        studio_client: StudioClient,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        from uipath.platform.common._config import ConfigurationManager
+
+        bindings_path = tmp_path / "bindings.json"
+        bindings_path.write_text("{}")
+        monkeypatch.setattr(
+            ConfigurationManager,
+            "bindings_file_path",
+            property(lambda self: bindings_path),
+        )
+
+        response = MagicMock()
+        response.json.return_value = {
+            "bucket.my_bucket": {
+                "name": "prod_bucket",
+                "folderPath": "Prod/Folder",
+            }
+        }
+        studio_client.uipath.api_client.request_async = AsyncMock(return_value=response)
+
+        result = await studio_client.get_resource_overwrites()
+
+        parsed = result["bucket.my_bucket"]
+        assert isinstance(parsed, GenericResourceOverwrite)
+        assert parsed.resource_identifier == "prod_bucket"
+        assert parsed.folder_identifier == "Prod/Folder"
+
+    async def test_passes_tenant_id_header_from_environment(
+        self,
+        studio_client: StudioClient,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        from uipath.platform.common._config import ConfigurationManager
+
+        bindings_path = tmp_path / "bindings.json"
+        bindings_path.write_text("{}")
+        monkeypatch.setattr(
+            ConfigurationManager,
+            "bindings_file_path",
+            property(lambda self: bindings_path),
+        )
+        monkeypatch.setenv("UIPATH_TENANT_ID", "tenant-from-env")
+
+        response = MagicMock()
+        response.json.return_value = {}
+        request_mock = AsyncMock(return_value=response)
+        studio_client.uipath.api_client.request_async = request_mock
+
+        await studio_client.get_resource_overwrites()
+
+        # The header carrying the tenant id should reflect the env var value.
+        call_kwargs = request_mock.await_args.kwargs
+        headers = call_kwargs["headers"]
+        assert any(value == "tenant-from-env" for value in headers.values()), headers
diff --git a/packages/uipath/tests/resource_overrides/test_resource_overrides.py b/packages/uipath/tests/resource_overrides/test_resource_overrides.py
new file mode 100644
index 000000000..8d39a762d
--- /dev/null
+++ b/packages/uipath/tests/resource_overrides/test_resource_overrides.py
@@ -0,0 +1,566 @@
+# type: ignore
+import json
+import os
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+from urllib.parse import parse_qs, urlparse
+
+import pytest
+from click.testing import CliRunner
+from opentelemetry.sdk.trace.export import SpanExporter
+from pytest_httpx import HTTPXMock
+
+from uipath._cli import cli
+from uipath.platform.common import ResourceOverwriteParser
+from uipath.runtime import UiPathRuntimeResult
+
+
+@pytest.fixture
+def sample_main_script():
+    """Load the sample main.py for resource overrides."""
+    sample_path = (
+        Path(__file__).parent.parent.parent
+        / "samples"
+        / "resource-overrides"
+        / "main.py"
+    )
+    with open(sample_path, "r") as f:
+        return f.read()
+
+
+@pytest.fixture
+def overwrites_data():
+    """Load the overwrites.json test data."""
+    overwrites_path = Path(__file__).parent / "overwrites.json"
+    with open(overwrites_path, "r") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def uipath_json_with_overwrites(overwrites_data):
+    """Create a uipath.json structure with resource overwrites."""
+
+    def _make_config(script_path: str = "main.py", function_name: str = "main"):
+        return {
+            "projectVersion": "1.0.0",
+            "description": "Test project for resource overwrites",
+            "runtime": {"internalArguments": {"resourceOverwrites": overwrites_data}},
+            "functions": {"main": f"{script_path}:{function_name}"},
+        }
+
+    return _make_config
+
+
+@pytest.fixture()
+def tracer_provider_with_memory_exporter():
+    """Create a TracerProvider with in-memory span exporter."""
+    from opentelemetry import trace
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import SimpleSpanProcessor, SpanExportResult
+
+    original_provider = trace.get_tracer_provider()
+    captured_spans = []
+
+    class InMemorySpanExporter(SpanExporter):
+        def export(self, spans):
+            captured_spans.extend(spans)
+            return SpanExportResult.SUCCESS
+
+        def force_flush(self, timeout_millis=30000):
+            return True
+
+        def shutdown(self):
+            pass
+
+    provider = TracerProvider()
+    span_processor = SimpleSpanProcessor(InMemorySpanExporter())
+    provider.add_span_processor(span_processor)
+
+    trace._TRACER_PROVIDER_SET_ONCE._done = False
+    trace._TRACER_PROVIDER = None
+    trace.set_tracer_provider(provider)
+
+    yield provider, captured_spans
+
+    span_processor.shutdown()
+    provider.shutdown()
+    trace._TRACER_PROVIDER_SET_ONCE._done = False
+    trace._TRACER_PROVIDER = None
+    trace.set_tracer_provider(original_provider)
+
+
+class TestResourceOverrides:
+    """Tests for resource override functionality."""
+
+    def _mock_calls(
+        self, httpx_mock: HTTPXMock, base_url: str, org_scoped_base_url: str
+    ):
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Overwritten Asset Name'&$top=1",
+            status_code=200,
+            json={
+                "value": [
+                    {
+                        "Name": "Overwritten Asset Name",
+                        "ValueType": "Text",
+                        "StringValue": "test_value",
+                    }
+                ]
+            },
+        )
+
+        # Mock Connections API - retrieve_async
+        # Connection uses /connections_/api/v1/Connections/{key}
+        httpx_mock.add_response(
+            url=f"{base_url}/connections_/api/v1/Connections/overwritten-connection-id-12345",
+            status_code=200,
+            json={
+                "Id": "overwritten-connection-id-12345",
+                "Name": "Connection Name",
+                "element_instance_id": 1234,
+            },
+        )
+
+        # Mock Actions API - need to mock app retrieval first
+        # First mock the app schema retrieval
+        httpx_mock.add_response(
+            url=f"{org_scoped_base_url}/apps_/default/api/v1/default/deployed-action-apps-schemas?search=Overwritten App Name&filterByDeploymentTitle=true",
+            method="GET",
+            json={
+                "deployed": [
+                    {
+                        "systemName": "app-key-123",
+                        "deploymentTitle": "Overwritten App Name",
+                        "deploymentFolder": {
+                            "fullyQualifiedName": "Overwritten/App/Folder"
+                        },
+                        "actionSchema": {
+                            "key": "schema-key",
+                            "inputs": [],
+                            "outputs": [],
+                            "outcomes": [],
+                            "inOuts": [],
+                        },
+                    }
+                ]
+            },
+        )
+        # Then mock the action creation
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/tasks/AppTasks/CreateAppTask",
+            method="POST",
+            json={"Id": "action-id-123", "Status": "Created"},
+        )
+
+        # Mock Context Grounding API - retrieve index
+        httpx_mock.add_response(
+            url=f"{base_url}/ecs_/v2/indexes?$filter=Name eq 'Overwritten Index Name'&$expand=dataSource",
+            method="GET",
+            json={
+                "value": [
+                    {
+                        "id": "test-index-id",
+                        "name": "Overwritten Index Name",
+                        "lastIngestionStatus": "Completed",
+                    }
+                ]
+            },
+        )
+
+        # exchange folder path for folder key
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=Folder&skip=0&take=20",
+            status_code=200,
+            json={
+                "PageItems": [
+                    {
+                        "Key": "test-folder-key",
+                        "FullyQualifiedName": "Overwritten/Index/Folder",
+                    }
+                ]
+            },
+        )
+
+        # Mock Buckets API - retrieve_async
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/odata/Buckets?$filter=Name eq 'Overwritten Bucket Name'&$top=1",
+            method="GET",
+            json={
+                "value": [
+                    {
+                        "Id": 123,
+                        "Name": "Overwritten Bucket Name",
+                        "Identifier": "bucket-key",
+                    }
+                ]
+            },
+        )
+
+        # Mock Processes API - invoke_async
+        # First mock the release retrieval
+        httpx_mock.add_response(
+            url=f"{base_url}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
+            method="POST",
+            json={
+                "value": [
+                    {
+                        "Key": "test-job-key",
+                        "State": "Running",
+                        "StartTime": "2024-01-01T00:00:00Z",
+                        "Id": 123,
+                        "FolderKey": "test-folder-key",
+                    }
+                ]
+            },
+        )
+
+    def _assert(self, result, httpx_mock):
+        # Verify execution was successful
+        assert result.exit_code == 0
+
+        # Now verify that overridden values were used in API calls
+        # Get all requests made
+        requests = httpx_mock.get_requests()
+
+        # Check Assets call - should have overwritten name in filter
+        asset_requests = [r for r in requests if "Assets" in str(r.url)]
+        assert len(asset_requests) > 0
+        asset_url = str(asset_requests[0].url)
+        parsed_url = urlparse(asset_url)
+        query_params = parse_qs(parsed_url.query)
+        assert "$filter" in query_params
+        # The filter should contain the overwritten name
+        assert "Overwritten Asset Name" in query_params["$filter"][0]
+
+        # Check Connections call - should have overwritten connection ID in URL
+        conn_requests = [
+            r for r in requests if "Connections" in str(r.url) and r.method == "GET"
+        ]
+        assert len(conn_requests) > 0
+        assert "overwritten-connection-id-12345" in str(conn_requests[0].url)
+
+        # Check Actions call - should have overwritten app name
+        app_requests = [
+            r for r in requests if "deployed-action-apps-schemas" in str(r.url)
+        ]
+        assert len(app_requests) > 0
+        app_query = parse_qs(urlparse(str(app_requests[0].url)).query)
+        assert "search" in app_query
+        assert app_query["search"][0] == "Overwritten App Name"
+
+        # Check Context Grounding call - should have overwritten index name in URL
+        index_requests = [r for r in requests if "ecs_" in str(r.url)]
+        assert len(index_requests) > 0
+        assert "Overwritten+Index+Name" in str(index_requests[0].url)
+
+        # Check Buckets call - should have overwritten bucket name
+        bucket_requests = [
+            r for r in requests if "Buckets" in str(r.url) and r.method == "GET"
+        ]
+        assert len(bucket_requests) > 0
+        bucket_query = parse_qs(urlparse(str(bucket_requests[0].url)).query)
+        # Bucket name typically in filter
+        assert "$filter" in bucket_query
+        assert "Overwritten Bucket Name" in bucket_query["$filter"][0]
+
+        # Check Processes call - should have overwritten process name
+        start_job_request = [r for r in requests if "StartJobs" in str(r.url)]
+        assert len(start_job_request) > 0
+        assert "Overwritten Process Name" in str(start_job_request[0].content)
+
+    def test_parse_overwrites_with_type_adapter(self, overwrites_data):
+        """Test that ResourceOverwriteParser correctly parses all resource types."""
+        parsed_overwrites = {}
+
+        for key, value in overwrites_data.items():
+            parsed_overwrites[key] = ResourceOverwriteParser.parse(key, value)
+
+        # Verify asset overwrite
+        asset = parsed_overwrites["asset.asset_name"]
+        assert asset.resource_identifier == "Overwritten Asset Name"
+        assert asset.folder_identifier == "Overwritten/Asset/Folder"
+
+        # Verify connection overwrite (uses different field names)
+        connection = parsed_overwrites["connection.connection_key"]
+        assert connection.resource_identifier == "overwritten-connection-id-12345"
+        assert connection.folder_identifier == "overwritten-folder-key-abc"
+
+        # Verify app overwrite
+        app = parsed_overwrites["app.app_name"]
+        assert app.resource_identifier == "Overwritten App Name"
+        assert app.folder_identifier == "Overwritten/App/Folder"
+
+        # Verify index overwrite
+        index = parsed_overwrites["index.index_name"]
+        assert index.resource_identifier == "Overwritten Index Name"
+        assert index.folder_identifier == "Overwritten/Index/Folder"
+
+        # Verify bucket overwrite
+        bucket = parsed_overwrites["bucket.bucket_name"]
+        assert bucket.resource_identifier == "Overwritten Bucket Name"
+        assert bucket.folder_identifier == "Overwritten/Bucket/Folder"
+
+        # Verify process overwrite
+        process = parsed_overwrites["process.process_name"]
+        assert process.resource_identifier == "Overwritten Process Name"
+        assert process.folder_identifier == "Overwritten/Process/Folder"
+
+        # Verify MCP Server overwrite
+        mcp_server = parsed_overwrites["mcpServer.mcp_server_name"]
+        assert mcp_server.resource_identifier == "Overwritten MCP Server Name"
+        assert mcp_server.folder_identifier == "Overwritten/MCPServer/Folder"
+
+        # Verify entity overwrite
+        entity = parsed_overwrites["entity.entity_name"]
+        assert entity.resource_identifier == "Overwritten Entity Name"
+        assert entity.folder_identifier == "overwritten-entity-folder-id-123"
+
+    def test_overrides_decorator_should_pop_kwargs_dict_when_present(self):
+        from uipath.platform.common import resource_override
+
+        @resource_override(resource_type="asset")
+        def some_method(a: str, b: str, **kwargs):
+            return kwargs
+
+        result = some_method("a", "b", kwargs_param=123)
+
+        assert "kwargs" not in result
+        assert len(result) == 1
+        assert result["kwargs_param"] == 123
+
+    def test_debug_with_resource_overwrites(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        sample_main_script: str,
+        overwrites_data: dict,
+        httpx_mock: HTTPXMock,
+    ):
+        """Test that uipath debug applies resource overwrites correctly."""
+        entrypoint = "main.py"
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create the main.py script
+            script_path = os.path.join(temp_dir, entrypoint)
+            with open(script_path, "w") as f:
+                f.write(sample_main_script)
+
+            # Create minimal uipath.json for debug (overwrites come from studio client)
+            with open(os.path.join(temp_dir, "uipath.json"), "w") as f:
+                json.dump(
+                    {"projectVersion": "1.0.0", "functions": {"main": "main.py:main"}},
+                    f,
+                )
+
+            org = "test-org"
+            tenant = "test-tenant"
+            base_url = f"https://example.com/{org}/{tenant}"
+            org_scoped_base_url = f"https://example.com/{org}"
+
+            # Set environment variables for debug mode
+            with patch.dict(
+                os.environ,
+                {
+                    "UIPATH_URL": base_url,
+                    "UIPATH_ACCESS_TOKEN": "test-access-token-12345",
+                    "UIPATH_ORGANIZATION_ID": org,
+                    "UIPATH_TENANT_ID": tenant,
+                    "UIPATH_PROJECT_ID": "test-project-id-12345",  # Required for debug mode
+                },
+            ):
+                # Patch StudioClient to return our test overwrites
+                async def mock_get_resource_overwrites():
+                    """Mock implementation that returns parsed overwrites."""
+                    parsed_overwrites = {}
+                    for key, value in overwrites_data.items():
+                        parsed_overwrites[key] = ResourceOverwriteParser.parse(
+                            key, value
+                        )
+                    return parsed_overwrites
+
+                with patch(
+                    "uipath._cli.cli_debug.StudioClient"
+                ) as mock_studio_client_class:
+                    mock_studio_client = MagicMock()
+                    mock_studio_client_class.return_value = mock_studio_client
+                    mock_studio_client.get_resource_overwrites = (
+                        mock_get_resource_overwrites
+                    )
+
+                    self._mock_calls(httpx_mock, base_url, org_scoped_base_url)
+
+                    current_dir_copy = os.getcwd()
+                    os.chdir(temp_dir)
+
+                    # Pass 'c' to continue execution in debug mode
+                    result = runner.invoke(cli, ["debug", "main"], input="c\n")
+
+                    # Restore cwd
+                    os.chdir(current_dir_copy)
+
+                    self._assert(result, httpx_mock)
+
+
+class TestBindingsAvailableDuringResourceOverwrites:
+    def test_overwrites_are_loaded_on_runtime_initialization(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        sample_main_script: str,
+        httpx_mock: HTTPXMock,
+    ):
+        entrypoint = "main.py"
+        bindings_file_created = False
+        bindings_existed_during_overwrites = None
+        overwrites_loaded = False
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            script_path = os.path.join(temp_dir, entrypoint)
+            with open(script_path, "w") as f:
+                f.write(sample_main_script)
+
+            with open(os.path.join(temp_dir, "uipath.json"), "w") as f:
+                json.dump(
+                    {"projectVersion": "1.0.0", "functions": {"main": "main.py:main"}},
+                    f,
+                )
+
+            org = "test-org"
+            tenant = "test-tenant"
+            base_url = f"https://example.com/{org}/{tenant}"
+
+            with patch.dict(
+                os.environ,
+                {
+                    "UIPATH_URL": base_url,
+                    "UIPATH_ACCESS_TOKEN": "test-access-token-12345",
+                    "UIPATH_ORGANIZATION_ID": org,
+                    "UIPATH_TENANT_ID": tenant,
+                    "UIPATH_PROJECT_ID": "test-project-id-12345",
+                },
+            ):
+                from uipath.platform.common import UiPathConfig
+
+                bindings_path = UiPathConfig.bindings_file_path
+
+                async def mock_get_resource_overwrites():
+                    nonlocal bindings_existed_during_overwrites
+                    nonlocal overwrites_loaded
+                    bindings_existed_during_overwrites = os.path.exists(bindings_path)
+                    if bindings_existed_during_overwrites:
+                        overwrites_loaded = True
+                    return {}
+
+                mock_debug_runtime = AsyncMock()
+                mock_debug_runtime.execute = AsyncMock(
+                    return_value=UiPathRuntimeResult()
+                )
+                mock_debug_runtime.dispose = AsyncMock()
+
+                async def mock_new_runtime(*args, **kwargs):
+                    assert overwrites_loaded
+                    return AsyncMock()
+
+                mock_factory = AsyncMock()
+                mock_factory.new_runtime = mock_new_runtime
+                mock_factory.get_settings = AsyncMock(return_value=None)
+                mock_factory.dispose = AsyncMock()
+
+                def mock_registry_get(**kwargs):
+                    nonlocal bindings_file_created
+                    bindings_data = {
+                        "version": "2",
+                        "resources": [],
+                    }
+                    with open(bindings_path, "w") as f:
+                        json.dump(bindings_data, f)
+                    bindings_file_created = True
+                    return mock_factory
+
+                with (
+                    patch(
+                        "uipath._cli.cli_debug.StudioClient"
+                    ) as mock_studio_client_class,
+                    patch(
+                        "uipath._cli.cli_debug.UiPathRuntimeFactoryRegistry"
+                    ) as mock_registry,
+                    patch(
+                        "uipath._cli.cli_debug.UiPathDebugRuntime",
+                        return_value=mock_debug_runtime,
+                    ),
+                ):
+                    mock_studio_client = MagicMock()
+                    mock_studio_client_class.return_value = mock_studio_client
+                    mock_studio_client.get_resource_overwrites = (
+                        mock_get_resource_overwrites
+                    )
+
+                    mock_registry.get.side_effect = mock_registry_get
+
+                    current_dir_copy = os.getcwd()
+                    os.chdir(temp_dir)
+
+                    runner.invoke(cli, ["debug", "main"], input="c\n")
+
+                    os.chdir(current_dir_copy)
+
+                    if os.path.exists(bindings_path):
+                        os.remove(bindings_path)
+
+                assert bindings_file_created
+                assert bindings_existed_during_overwrites is True
+
+
+class TestResourceOverrideWithTracing:
+    """Tests for resource_override decorator integration with tracing."""
+
+    @pytest.mark.anyio
+    async def test_traced_span_shows_overridden_resource_name(
+        self, tracer_provider_with_memory_exporter
+    ):
+        """Verify that spans show the overridden resource name, not the original value."""
+
+        from uipath.platform.common import (
+            GenericResourceOverwrite,
+            ResourceOverwritesContext,
+            resource_override,
+        )
+        from uipath.tracing import traced
+
+        provider, captured_spans = tracer_provider_with_memory_exporter
+
+        @resource_override(resource_type="bucket")
+        @traced(name="test_bucket_operation", run_type="uipath")
+        async def retrieve_resource(name: str, folder_path: str):
+            return {"resource_name": name, "folder": folder_path}
+
+        async def get_overwrites():
+            return {
+                "bucket.original_bucket.original_folder": GenericResourceOverwrite(
+                    resource_type="bucket",
+                    name="overridden_resource",
+                    folder_path="overridden_folder",
+                )
+            }
+
+        async with ResourceOverwritesContext(get_overwrites):
+            result = await retrieve_resource("original_bucket", "original_folder")
+
+        provider.force_flush()
+
+        assert result["resource_name"] == "overridden_resource"
+        assert result["folder"] == "overridden_folder"
+
+        assert len(captured_spans) > 0
+
+        span = captured_spans[-1]
+        attrs = dict(span.attributes) if span.attributes else {}
+
+        assert span.name == "test_bucket_operation"
+
+        input_attrs_dict = json.loads((attrs["input.value"]))
+        output_attrs_dict = json.loads((attrs["output.value"]))
+        assert input_attrs_dict["name"] == "overridden_resource"
+        assert input_attrs_dict["folder_path"] == "overridden_folder"
+        assert output_attrs_dict["resource_name"] == "overridden_resource"
+        assert output_attrs_dict["folder"] == "overridden_folder"
diff --git a/packages/uipath/tests/sdk/test_bindings.py b/packages/uipath/tests/sdk/test_bindings.py
new file mode 100644
index 000000000..1d51d7413
--- /dev/null
+++ b/packages/uipath/tests/sdk/test_bindings.py
@@ -0,0 +1,418 @@
+# type: ignore
+
+import pytest
+
+from uipath.platform.common import (
+    ConnectionResourceOverwrite,
+    GenericResourceOverwrite,
+    ResourceOverwriteParser,
+    ResourceOverwritesContext,
+    resource_override,
+)
+from uipath.platform.common._bindings import _resource_overwrites
+
+
+class TestBindingsInference:
+    def test_infer_bindings_overwrites_name_and_folder_path(self):
+        """Test that infer_bindings overwrites both name and folder_path when context is set."""
+        overwrites = {
+            "bucket.old_name.old_folder": GenericResourceOverwrite(
+                resource_type="bucket", name="new_name", folder_path="new_folder"
+            )
+        }
+
+        @resource_override(resource_type="bucket")
+        def dummy_func(name, folder_path):
+            return name, folder_path
+
+        # Set the context variable
+        token = _resource_overwrites.set(overwrites)
+        try:
+            result = dummy_func("old_name", "old_folder")
+            assert result == ("new_name", "new_folder")
+        finally:
+            _resource_overwrites.reset(token)
+
+    def test_infer_bindings_overwrites_without_folder_path(self):
+        """Test that infer_bindings overwrites when key doesn't include folder_path."""
+        overwrites = {
+            "bucket.old_name": GenericResourceOverwrite(
+                resource_type="bucket", name="new_name", folder_path="new_folder"
+            )
+        }
+
+        @resource_override(resource_type="bucket")
+        def dummy_func(name, folder_path):
+            return name, folder_path
+
+        # Set the context variable
+        token = _resource_overwrites.set(overwrites)
+        try:
+            result = dummy_func("old_name", "old_folder")
+            assert result == ("new_name", "new_folder")
+        finally:
+            _resource_overwrites.reset(token)
+
+    def test_infer_bindings_skips_when_no_context(self):
+        """Test that infer_bindings doesn't overwrite when context variable is not set."""
+
+        @resource_override(resource_type="bucket")
+        def dummy_func(name, folder_path):
+            return name, folder_path
+
+        result = dummy_func("old_name", "old_folder")
+        assert result == ("old_name", "old_folder")
+
+    def test_infer_bindings_skips_when_no_matching_overwrite(self):
+        """Test that infer_bindings doesn't overwrite when no matching key exists."""
+        overwrites = {
+            "bucket.different_name": GenericResourceOverwrite(
+                name="new_name", folder_path="new_folder", resource_type="bucket"
+            )
+        }
+
+        @resource_override(resource_type="bucket")
+        def dummy_func(name, folder_path):
+            return name, folder_path
+
+        # Set the context variable
+        token = _resource_overwrites.set(overwrites)
+        try:
+            result = dummy_func("old_name", "old_folder")
+            assert result == ("old_name", "old_folder")
+        finally:
+            _resource_overwrites.reset(token)
+
+    def test_infer_bindings_only_name_present(self):
+        """Test that infer_bindings works when only name parameter is present."""
+        overwrites = {
+            "asset.old_name": GenericResourceOverwrite(
+                name="new_name", folder_path="new_folder", resource_type="asset"
+            )
+        }
+
+        @resource_override(resource_type="asset")
+        def dummy_func(name, folder_path=None):
+            return name, folder_path
+
+        # Set the context variable
+        token = _resource_overwrites.set(overwrites)
+        try:
+            result = dummy_func("old_name")
+            assert result == ("new_name", "new_folder")
+        finally:
+            _resource_overwrites.reset(token)
+
+    def test_infer_bindings_prefers_specific_folder_path_key(self):
+        """Test that infer_bindings prefers the more specific key with folder_path."""
+        overwrites = {
+            "bucket.my_bucket": GenericResourceOverwrite(
+                name="generic_name",
+                folder_path="generic_folder",
+                resource_type="bucket",
+            ),
+            "bucket.my_bucket.specific_folder": GenericResourceOverwrite(
+                name="specific_name",
+                folder_path="specific_folder",
+                resource_type="bucket",
+            ),
+        }
+
+        @resource_override(resource_type="bucket")
+        def dummy_func(name, folder_path):
+            return name, folder_path
+
+        # Set the context variable
+        token = _resource_overwrites.set(overwrites)
+        try:
+            result = dummy_func("my_bucket", "specific_folder")
+            assert result == ("specific_name", "specific_folder")
+        finally:
+            _resource_overwrites.reset(token)
+
+
+class TestResourceOverwritesContext:
+    """Test that ResourceOverwritesContext works correctly with infer_bindings."""
+
+    @pytest.mark.anyio
+    async def test_context_with_simple_async_function(self):
+        """Test ResourceOverwritesContext with a simple async function."""
+
+        async def get_overwrites():
+            return {
+                "asset.test_asset": GenericResourceOverwrite(
+                    name="overwritten_asset",
+                    folder_path="overwritten_folder",
+                    resource_type="asset",
+                )
+            }
+
+        @resource_override(resource_type="asset")
+        def retrieve_asset(name, folder_path=None):
+            return name, folder_path
+
+        async with ResourceOverwritesContext(get_overwrites) as ctx:
+            # Verify context reports the correct count
+            assert ctx.overwrites_count == 1
+
+            # Verify infer_bindings applies the overwrites
+            result = retrieve_asset("test_asset", "original_folder")
+            assert result == ("overwritten_asset", "overwritten_folder")
+
+        # Verify context is cleaned up after exiting
+        result_after = retrieve_asset("test_asset", "original_folder")
+        assert result_after == ("test_asset", "original_folder")
+
+    @pytest.mark.anyio
+    async def test_context_with_lambda(self):
+        """Test ResourceOverwritesContext with a lambda (as used in CLI code)."""
+
+        class MockClient:
+            async def get_resource_overwrites(self):
+                return {
+                    "bucket.my_bucket": GenericResourceOverwrite(
+                        name="prod_bucket",
+                        folder_path="prod_folder",
+                        resource_type="bucket",
+                    )
+                }
+
+        client = MockClient()
+
+        @resource_override(resource_type="bucket")
+        def use_bucket(name, folder_path):
+            return name, folder_path
+
+        async with ResourceOverwritesContext(
+            lambda: client.get_resource_overwrites()
+        ) as ctx:
+            assert ctx.overwrites_count == 1
+            result = use_bucket("my_bucket", "dev_folder")
+            assert result == ("prod_bucket", "prod_folder")
+
+    @pytest.mark.anyio
+    async def test_context_with_read_from_file_pattern(self):
+        """Test ResourceOverwritesContext with file reading pattern."""
+
+        async def read_resource_overwrites_from_file(directory=None):
+            """Simulates reading from a file."""
+            return {
+                "process.my_process": GenericResourceOverwrite(
+                    name="overwritten_process",
+                    folder_path="overwritten_folder",
+                    resource_type="process",
+                )
+            }
+
+        @resource_override(resource_type="process")
+        def start_process(name, folder_path):
+            return name, folder_path
+
+        async with ResourceOverwritesContext(
+            lambda: read_resource_overwrites_from_file("/some/path")
+        ) as ctx:
+            assert ctx.overwrites_count == 1
+            result = start_process("my_process", "default_folder")
+            assert result == ("overwritten_process", "overwritten_folder")
+
+    @pytest.mark.anyio
+    async def test_context_with_multiple_overwrites(self):
+        """Test ResourceOverwritesContext with multiple resource overwrites."""
+
+        async def get_overwrites():
+            return {
+                "asset.asset1": GenericResourceOverwrite(
+                    name="new_asset1", folder_path="folder1", resource_type="asset"
+                ),
+                "asset.asset2": GenericResourceOverwrite(
+                    name="new_asset2", folder_path="folder2", resource_type="asset"
+                ),
+                "bucket.bucket1.specific": GenericResourceOverwrite(
+                    name="new_bucket1",
+                    folder_path="new_specific",
+                    resource_type="bucket",
+                ),
+            }
+
+        @resource_override(resource_type="asset")
+        def get_asset(name, folder_path):
+            return name, folder_path
+
+        @resource_override(resource_type="bucket")
+        def get_bucket(name, folder_path):
+            return name, folder_path
+
+        async with ResourceOverwritesContext(get_overwrites) as ctx:
+            assert ctx.overwrites_count == 3
+
+            # Test first asset
+            result1 = get_asset("asset1", "old_folder")
+            assert result1 == ("new_asset1", "folder1")
+
+            # Test second asset
+            result2 = get_asset("asset2", "old_folder")
+            assert result2 == ("new_asset2", "folder2")
+
+            # Test bucket with specific folder path
+            result3 = get_bucket("bucket1", "specific")
+            assert result3 == ("new_bucket1", "new_specific")
+
+    @pytest.mark.anyio
+    async def test_context_with_empty_overwrites(self):
+        """Test ResourceOverwritesContext with no overwrites."""
+
+        async def get_overwrites():
+            return {}
+
+        @resource_override(resource_type="asset")
+        def get_asset(name, folder_path):
+            return name, folder_path
+
+        async with ResourceOverwritesContext(get_overwrites) as ctx:
+            assert ctx.overwrites_count == 0
+
+            # Should not modify anything
+            result = get_asset("test_asset", "test_folder")
+            assert result == ("test_asset", "test_folder")
+
+    @pytest.mark.anyio
+    async def test_context_nested_function_calls(self):
+        """Test that overwrites work with nested function calls."""
+
+        async def get_overwrites():
+            return {
+                "asset.config_asset": GenericResourceOverwrite(
+                    name="prod_config", folder_path="prod", resource_type="asset"
+                ),
+                "bucket.data_bucket": GenericResourceOverwrite(
+                    name="prod_data", folder_path="prod", resource_type="bucket"
+                ),
+            }
+
+        @resource_override(resource_type="asset")
+        def get_config(name, folder_path):
+            return name, folder_path
+
+        @resource_override(resource_type="bucket")
+        def get_data(name, folder_path):
+            return name, folder_path
+
+        def process_data():
+            """Function that calls multiple inferred functions."""
+            config = get_config("config_asset", "dev")
+            data = get_data("data_bucket", "dev")
+            return config, data
+
+        async with ResourceOverwritesContext(get_overwrites):
+            config_result, data_result = process_data()
+            assert config_result == ("prod_config", "prod")
+            assert data_result == ("prod_data", "prod")
+
+    @pytest.mark.anyio
+    async def test_context_cleanup_after_exception(self):
+        """Test that context is properly cleaned up even after an exception."""
+
+        async def get_overwrites():
+            return {
+                "asset.test": GenericResourceOverwrite(
+                    name="overwritten", folder_path="overwritten", resource_type="asset"
+                )
+            }
+
+        @resource_override(resource_type="asset")
+        def get_asset(name, folder_path):
+            return name, folder_path
+
+        try:
+            async with ResourceOverwritesContext(get_overwrites):
+                # Verify overwrites are active
+                result = get_asset("test", "original")
+                assert result == ("overwritten", "overwritten")
+
+                # Raise an exception
+                raise ValueError("Test exception")
+        except ValueError:
+            pass
+
+        # Verify context was cleaned up despite the exception
+        result_after = get_asset("test", "original")
+        assert result_after == ("test", "original")
+
+
+class TestConnectionResourceOverwriteAliases:
+    """Test that ConnectionResourceOverwrite accepts both connectionId and ConnectionId aliases."""
+
+    def test_connection_resource_overwrite_with_lowercase_alias(self):
+        """Test that connectionId alias works."""
+        overwrite = ConnectionResourceOverwrite(
+            resource_type="connection",
+            connectionId="conn-123",
+            folderKey="folder1",
+        )
+        assert overwrite.connection_id == "conn-123"
+        assert overwrite.folder_key == "folder1"
+
+    def test_connection_resource_overwrite_with_capitalized_alias(self):
+        """Test that ConnectionId alias works."""
+        overwrite = ConnectionResourceOverwrite(
+            resource_type="connection",
+            ConnectionId="conn-456",
+            folderKey="folder2",
+        )
+        assert overwrite.connection_id == "conn-456"
+        assert overwrite.folder_key == "folder2"
+
+    def test_connection_resource_overwrite_with_field_name(self):
+        """Test that the actual field name connection_id also works."""
+        overwrite = ConnectionResourceOverwrite(
+            resource_type="connection",
+            connection_id="conn-789",
+            folder_key="folder3",
+        )
+        assert overwrite.connection_id == "conn-789"
+        assert overwrite.folder_key == "folder3"
+
+    def test_parse_connection_with_lowercase_alias(self):
+        """Test parsing a connection resource with lowercase connectionId alias."""
+        overwrite = ResourceOverwriteParser.parse(
+            key="connection.conn-123",
+            value={"connectionId": "conn-123", "folderKey": "folder1"},
+        )
+        assert isinstance(overwrite, ConnectionResourceOverwrite)
+        assert overwrite.connection_id == "conn-123"
+        assert overwrite.folder_key == "folder1"
+
+    def test_parse_connection_with_capitalized_alias(self):
+        """Test parsing a connection resource with capitalized ConnectionId alias."""
+        overwrite = ResourceOverwriteParser.parse(
+            key="connection.conn-456",
+            value={"ConnectionId": "conn-456", "folderKey": "folder2"},
+        )
+        assert isinstance(overwrite, ConnectionResourceOverwrite)
+        assert overwrite.connection_id == "conn-456"
+        assert overwrite.folder_key == "folder2"
+
+
+class TestRemoteA2aAgentResourceOverwrite:
+    """Test that Remote A2A agent resources parse as GenericResourceOverwrite."""
+
+    def test_remote_a2a_agent_resource_overwrite(self):
+        overwrite = GenericResourceOverwrite(
+            resource_type="remoteA2aAgent",
+            name="basica2a",
+            folder_path="Customers/ProjectA",
+        )
+        assert overwrite.resource_type == "remoteA2aAgent"
+        assert overwrite.resource_identifier == "basica2a"
+        assert overwrite.folder_identifier == "Customers/ProjectA"
+
+    def test_parse_remote_a2a_agent(self):
+        """Parser accepts a remoteA2aAgent-keyed overwrite without discriminator error."""
+        overwrite = ResourceOverwriteParser.parse(
+            key="remoteA2aAgent.basica2a.solution_folder",
+            value={"name": "basica2a", "folderPath": "Customers/ProjectA"},
+        )
+        assert isinstance(overwrite, GenericResourceOverwrite)
+        assert overwrite.resource_type == "remoteA2aAgent"
+        assert overwrite.resource_identifier == "basica2a"
+        assert overwrite.folder_identifier == "Customers/ProjectA"
diff --git a/tests/sdk/test_config.py b/packages/uipath/tests/sdk/test_config.py
similarity index 88%
rename from tests/sdk/test_config.py
rename to packages/uipath/tests/sdk/test_config.py
index 5cf1dd62c..84fa0eb14 100644
--- a/tests/sdk/test_config.py
+++ b/packages/uipath/tests/sdk/test_config.py
@@ -1,7 +1,7 @@
 import pytest
 
-from uipath import UiPath
-from uipath.models.errors import BaseUrlMissingError
+from uipath.platform import UiPath
+from uipath.platform.errors import BaseUrlMissingError
 
 
 class TestSdkConfig:
@@ -15,7 +15,7 @@ def test_no_config(self, monkeypatch):
 
         assert (
             str(exc_info.value)
-            == "Authentication required. Please run \033[1muipath auth\033[22m."
+            == "Authentication required. Please run \033[1muipath auth\033[22m or set the base URL via the UIPATH_URL environment variable."
         )
 
     def test_config_from_env(self, monkeypatch):
diff --git a/packages/uipath/tests/sdk/test_uipath_caching.py b/packages/uipath/tests/sdk/test_uipath_caching.py
new file mode 100644
index 000000000..0fe5fb75d
--- /dev/null
+++ b/packages/uipath/tests/sdk/test_uipath_caching.py
@@ -0,0 +1,328 @@
+"""Tests for service caching behavior in UiPath SDK.
+
+This module tests that services using @cached_property are properly cached
+and thread-safe, while stateless services create new instances as expected.
+"""
+
+import threading
+import time
+from typing import Any
+
+import pytest
+from pytest import MonkeyPatch
+
+from uipath.platform import UiPath
+
+
+@pytest.fixture
+def sdk(monkeypatch: MonkeyPatch) -> UiPath:
+    """Create a UiPath SDK instance with mocked credentials."""
+    monkeypatch.setenv("UIPATH_URL", "https://test.example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test_token_1234567890")
+    return UiPath()
+
+
+class TestCachedServices:
+    """Test suite for services that should be cached."""
+
+    def test_buckets_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that buckets property returns the same instance on multiple accesses."""
+        buckets1 = sdk.buckets
+        buckets2 = sdk.buckets
+
+        assert buckets1 is buckets2, "BucketsService should return cached instance"
+        assert id(buckets1) == id(buckets2), "Instance IDs should match"
+
+    def test_attachments_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that attachments property returns the same instance."""
+        attachments1 = sdk.attachments
+        attachments2 = sdk.attachments
+
+        assert attachments1 is attachments2, (
+            "AttachmentsService should return cached instance"
+        )
+        assert id(attachments1) == id(attachments2), "Instance IDs should match"
+
+    def test_connections_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that connections property returns the same instance."""
+        connections1 = sdk.connections
+        connections2 = sdk.connections
+
+        assert connections1 is connections2, (
+            "ConnectionsService should return cached instance"
+        )
+        assert id(connections1) == id(connections2), "Instance IDs should match"
+
+    def test_folders_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that folders property returns the same instance."""
+        folders1 = sdk.folders
+        folders2 = sdk.folders
+
+        assert folders1 is folders2, "FolderService should return cached instance"
+        assert id(folders1) == id(folders2), "Instance IDs should match"
+
+    @pytest.mark.parametrize(
+        "service_property",
+        [
+            "attachments",
+            "buckets",
+            "connections",
+            "folders",
+        ],
+    )
+    def test_all_cached_services_return_same_instance(
+        self, sdk: UiPath, service_property: str
+    ) -> None:
+        """Verify that all cached services return the same instance."""
+        service1 = getattr(sdk, service_property)
+        service2 = getattr(sdk, service_property)
+
+        assert service1 is service2, f"{service_property} should return cached instance"
+
+    def test_cached_services_share_config(self, sdk: UiPath) -> None:
+        """Verify that cached instances share the same config object."""
+        buckets1 = sdk.buckets
+        buckets2 = sdk.buckets
+
+        assert buckets1._config is buckets2._config, "Config should be shared"
+        assert buckets1._execution_context is buckets2._execution_context, (
+            "Execution context should be shared"
+        )
+
+    def test_different_sdk_instances_have_different_services(
+        self, monkeypatch: MonkeyPatch
+    ) -> None:
+        """Verify that different SDK instances have different service instances."""
+        monkeypatch.setenv("UIPATH_URL", "https://test.example.com")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test_token_1234567890")
+        sdk1 = UiPath()
+        sdk2 = UiPath()
+
+        assert sdk1.buckets is not sdk2.buckets, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.attachments is not sdk2.attachments, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.connections is not sdk2.connections, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.folders is not sdk2.folders, (
+            "Different SDK instances should have different service instances"
+        )
+
+
+class TestThreadSafety:
+    """Test suite for thread safety of cached services."""
+
+    def test_buckets_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify that cached_property handles concurrent access safely."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            # Small delay to increase chance of race condition
+            time.sleep(0.001)
+            instances.append(sdk.buckets)
+
+        # Create 10 threads accessing the service simultaneously
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+
+        for thread in threads:
+            thread.join()
+
+        # All threads should get the same instance
+        assert len(set(id(instance) for instance in instances)) == 1, (
+            "All threads should receive the same cached instance"
+        )
+
+        for instance in instances[1:]:
+            assert instances[0] is instance, "All instances should be identical"
+
+    def test_attachments_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify attachments service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.attachments)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+    def test_connections_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify connections service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.connections)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+    def test_folders_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify folders service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.folders)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+
+class TestStatelessServices:
+    """Test suite for services that should NOT be cached."""
+
+    def test_assets_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that assets service creates new instances (stateless)."""
+        assets1 = sdk.assets
+        assets2 = sdk.assets
+
+        # These should be different instances
+        assert assets1 is not assets2, "Assets service should create new instances"
+
+    def test_actions_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that actions service creates new instances (stateless)."""
+        actions1 = sdk.tasks
+        actions2 = sdk.tasks
+
+        assert actions1 is not actions2, (
+            "Action Center service should create new instances"
+        )
+
+    def test_queues_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that queues service creates new instances (stateless)."""
+        queues1 = sdk.queues
+        queues2 = sdk.queues
+
+        assert queues1 is not queues2, "Queues service should create new instances"
+
+    def test_jobs_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that jobs service creates new instances (stateless)."""
+        jobs1 = sdk.jobs
+        jobs2 = sdk.jobs
+
+        assert jobs1 is not jobs2, "Jobs service should create new instances"
+
+    @pytest.mark.parametrize(
+        "service_property",
+        [
+            "api_client",
+            "assets",
+            "tasks",
+            "processes",
+            "queues",
+            "jobs",
+            "documents",
+            "llm_openai",
+            "llm",
+            "entities",
+        ],
+    )
+    def test_stateless_services_create_new_instances(
+        self, sdk: UiPath, service_property: str
+    ) -> None:
+        """Verify that stateless services create new instances."""
+        service1 = getattr(sdk, service_property)
+        service2 = getattr(sdk, service_property)
+
+        assert service1 is not service2, (
+            f"{service_property} should create new instances"
+        )
+
+
+class TestServiceDependencies:
+    """Test suite for services with dependencies on cached services."""
+
+    def test_connections_uses_cached_folders(self, sdk: UiPath) -> None:
+        """Verify that connections service uses the cached folders service."""
+
+        # Access connections (which depends on folders)
+        _ = sdk.connections
+
+        # Access folders directly
+        folders = sdk.folders
+
+        # The folders instance used by connections should be the same cached instance
+        assert folders is sdk.folders, "Folders should be cached and reused"
+
+    def test_context_grounding_uses_cached_dependencies(self, sdk: UiPath) -> None:
+        """Verify that context_grounding uses cached folders and buckets."""
+
+        # Access dependencies first
+        folders = sdk.folders
+        buckets = sdk.buckets
+
+        # Access context_grounding (creates new instance but uses cached deps)
+        cg1 = sdk.context_grounding
+        cg2 = sdk.context_grounding
+
+        # context_grounding itself is not cached (creates new instances)
+        assert cg1 is not cg2, "ContextGroundingService should create new instances"
+
+        # But it should use the same cached dependencies
+        assert folders is sdk.folders, "Folders should remain cached"
+        assert buckets is sdk.buckets, "Buckets should remain cached"
+
+    def test_processes_uses_cached_attachments(self, sdk: UiPath) -> None:
+        """Verify that processes service uses the cached attachments service."""
+
+        # Access attachments directly
+        attachments = sdk.attachments
+
+        # Access processes (which depends on attachments)
+        _ = sdk.processes
+
+        # Attachments should still be cached
+        assert attachments is sdk.attachments, "Attachments should remain cached"
+
+
+class TestCachingBehavior:
+    """Test suite for general caching behavior."""
+
+    def test_cached_property_attribute_name(self, sdk: UiPath) -> None:
+        """Verify that @cached_property stores values in expected attribute names."""
+
+        # Access the service
+        _ = sdk.buckets
+
+        # @cached_property stores the value in an attribute with the property name
+        assert hasattr(sdk, "buckets"), "Cached value should be stored as attribute"
+
+    def test_service_initialization_order(self, sdk: UiPath) -> None:
+        """Verify that services can be accessed in any order."""
+
+        # Access in different order
+        connections = sdk.connections  # Depends on folders
+        folders = sdk.folders
+        buckets = sdk.buckets
+        attachments = sdk.attachments
+
+        # All should be cached and reusable
+        assert connections is sdk.connections
+        assert folders is sdk.folders
+        assert buckets is sdk.buckets
+        assert attachments is sdk.attachments
diff --git a/packages/uipath/tests/sdk/test_utils_validation.py b/packages/uipath/tests/sdk/test_utils_validation.py
new file mode 100644
index 000000000..0e59e00e2
--- /dev/null
+++ b/packages/uipath/tests/sdk/test_utils_validation.py
@@ -0,0 +1,60 @@
+"""Tests for shared validation utilities."""
+
+import pytest
+
+from uipath._utils.validation import validate_pagination_params
+
+
+class TestValidatePaginationParams:
+    """Test shared pagination parameter validation."""
+
+    def test_valid_parameters(self):
+        """Test validation passes with valid parameters."""
+        validate_pagination_params(skip=0, top=100)
+        validate_pagination_params(skip=5000, top=500)
+        validate_pagination_params(skip=10000, top=1000)
+
+    def test_skip_negative(self):
+        """Test error when skip is negative."""
+        with pytest.raises(ValueError, match="skip must be >= 0"):
+            validate_pagination_params(skip=-1, top=100)
+
+    def test_skip_exceeds_maximum(self):
+        """Test error when skip exceeds max_skip."""
+        with pytest.raises(
+            ValueError, match=r"skip must be <= 10000.*requested: 10001"
+        ):
+            validate_pagination_params(skip=10001, top=100)
+
+    def test_top_below_minimum(self):
+        """Test error when top is below 1."""
+        with pytest.raises(ValueError, match="top must be >= 1"):
+            validate_pagination_params(skip=0, top=0)
+
+    def test_top_exceeds_maximum(self):
+        """Test error when top exceeds max_top."""
+        with pytest.raises(ValueError, match=r"top must be <= 1000.*requested: 1001"):
+            validate_pagination_params(skip=0, top=1001)
+
+    def test_custom_limits(self):
+        """Test validation with custom max limits."""
+        validate_pagination_params(skip=500, top=50, max_skip=500, max_top=50)
+
+        with pytest.raises(ValueError):
+            validate_pagination_params(skip=501, top=50, max_skip=500, max_top=50)
+
+    def test_skip_at_boundary(self):
+        """Test that skip at maximum is allowed."""
+        validate_pagination_params(skip=10000, top=100)
+
+    def test_top_at_boundary(self):
+        """Test that top at maximum is allowed."""
+        validate_pagination_params(skip=0, top=1000)
+
+    def test_skip_zero_is_valid(self):
+        """Test that skip=0 is valid."""
+        validate_pagination_params(skip=0, top=100)
+
+    def test_top_one_is_valid(self):
+        """Test that top=1 is valid minimum."""
+        validate_pagination_params(skip=0, top=1)
diff --git a/packages/uipath/tests/telemetry/__init__.py b/packages/uipath/tests/telemetry/__init__.py
new file mode 100644
index 000000000..e673b8aab
--- /dev/null
+++ b/packages/uipath/tests/telemetry/__init__.py
@@ -0,0 +1 @@
+"""Tests for telemetry tracking functionality."""
diff --git a/packages/uipath/tests/telemetry/test_track.py b/packages/uipath/tests/telemetry/test_track.py
new file mode 100644
index 000000000..827b3878d
--- /dev/null
+++ b/packages/uipath/tests/telemetry/test_track.py
@@ -0,0 +1,870 @@
+"""Tests for telemetry tracking functionality."""
+
+import json
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath.platform.common.constants import (
+    ENV_PROJECT_KEY,
+    ENV_UIPATH_AGENT_ID,
+    ENV_UIPATH_PROJECT_ID,
+)
+from uipath.telemetry._track import (
+    _AppInsightsEventClient,
+    _DiagnosticSender,
+    _get_project_key,
+    _parse_connection_string,
+    _TelemetryClient,
+    flush_events,
+    is_telemetry_enabled,
+    reset_event_client,
+    set_event_connection_string_provider,
+    track,
+    track_event,
+)
+
+
+class TestGetProjectKey:
+    """`_get_project_key` resolution: uipath.json#id, then legacy telemetry file."""
+
+    @pytest.fixture(autouse=True)
+    def _clear_cache(self, monkeypatch):
+        from uipath.platform.common._span_utils import _read_config_id
+
+        _read_config_id.cache_clear()
+        for var in (ENV_UIPATH_AGENT_ID, ENV_UIPATH_PROJECT_ID, ENV_PROJECT_KEY):
+            monkeypatch.delenv(var, raising=False)
+        yield
+        _read_config_id.cache_clear()
+
+    def test_prefers_uipath_json_id(self, monkeypatch, tmp_path):
+        config_id = "00000000-0000-0000-0000-000000000001"
+        (tmp_path / "uipath.json").write_text(json.dumps({"id": config_id}))
+        os.makedirs(tmp_path / ".uipath", exist_ok=True)
+        (tmp_path / ".uipath" / ".telemetry.json").write_text(
+            json.dumps({"ProjectKey": "from-telemetry"})
+        )
+        monkeypatch.chdir(tmp_path)
+        assert _get_project_key() == config_id
+
+    def test_falls_back_to_legacy_telemetry_file(self, monkeypatch, tmp_path):
+        # No uipath.json#id and no env var; honor an existing .telemetry.json.
+        os.makedirs(tmp_path / ".uipath", exist_ok=True)
+        (tmp_path / ".uipath" / ".telemetry.json").write_text(
+            json.dumps({"ProjectKey": "from-telemetry"})
+        )
+        monkeypatch.chdir(tmp_path)
+        assert _get_project_key() == "from-telemetry"
+
+    def test_unknown_when_no_source(self, monkeypatch, tmp_path):
+        monkeypatch.chdir(tmp_path)
+        assert _get_project_key() == ""
+
+
+class TestParseConnectionString:
+    """Test connection string parsing functionality."""
+
+    def test_parse_valid_connection_string(self):
+        """Test parsing a valid Application Insights connection string."""
+        connection_string = (
+            "InstrumentationKey=test-key-123;"
+            "IngestionEndpoint=https://example.com/;"
+            "LiveEndpoint=https://live.example.com/"
+        )
+
+        result = _parse_connection_string(connection_string)
+
+        assert result == {
+            "InstrumentationKey": "test-key-123",
+            "IngestionEndpoint": "https://example.com/",
+        }
+
+    def test_parse_connection_string_only_instrumentation_key(self):
+        """Test parsing connection string with only InstrumentationKey."""
+        connection_string = "InstrumentationKey=simple-key"
+
+        result = _parse_connection_string(connection_string)
+
+        assert result == {"InstrumentationKey": "simple-key"}
+
+    def test_parse_connection_string_missing_instrumentation_key(self):
+        """Test parsing connection string without InstrumentationKey."""
+        connection_string = (
+            "IngestionEndpoint=https://example.com/;"
+            "LiveEndpoint=https://live.example.com/"
+        )
+
+        result = _parse_connection_string(connection_string)
+
+        assert result is None
+
+    def test_parse_malformed_connection_string(self):
+        """Test parsing malformed connection string."""
+        connection_string = "not-a-valid-connection-string"
+
+        result = _parse_connection_string(connection_string)
+
+        assert result is None
+
+    def test_parse_empty_connection_string(self):
+        """Test parsing empty connection string."""
+        result = _parse_connection_string("")
+
+        assert result is None
+
+    def test_parse_connection_string_with_special_chars_in_value(self):
+        """Test parsing connection string with special characters in value."""
+        connection_string = "InstrumentationKey=key=with=equals;Other=value"
+
+        result = _parse_connection_string(connection_string)
+
+        assert result == {"InstrumentationKey": "key=with=equals"}
+
+
+class TestAppInsightsEventClient:
+    """Test _AppInsightsEventClient functionality."""
+
+    def setup_method(self):
+        """Reset AppInsightsEventClient state before each test."""
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+        _AppInsightsEventClient._connection_string_provider = None
+
+    def teardown_method(self):
+        """Clean up after each test."""
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+        _AppInsightsEventClient._connection_string_provider = None
+
+    @patch("uipath.telemetry._track._CONNECTION_STRING", "$CONNECTION_STRING")
+    def test_initialize_no_connection_string(self):
+        """Test initialization when no connection string is provided."""
+        with patch.dict(os.environ, {}, clear=True):
+            # Remove TELEMETRY_CONNECTION_STRING if it exists
+            os.environ.pop("TELEMETRY_CONNECTION_STRING", None)
+
+            _AppInsightsEventClient._initialize()
+
+            assert _AppInsightsEventClient._initialized is True
+            assert _AppInsightsEventClient._client is None
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    @patch(
+        "uipath.telemetry._track._CONNECTION_STRING",
+        "InstrumentationKey=builtin-key;IngestionEndpoint=https://example.com/",
+    )
+    def test_initialize_falls_back_to_builtin_connection_string(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test initialization uses _CONNECTION_STRING when env var is not set."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        with patch.dict(os.environ, {}, clear=True):
+            os.environ.pop("TELEMETRY_CONNECTION_STRING", None)
+
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is mock_client
+        mock_sender_class.assert_called_once_with(
+            service_endpoint_uri="https://example.com/v2/track"
+        )
+        mock_client_class.assert_called_once_with(
+            "builtin-key", telemetry_channel=mock_channel_class.return_value
+        )
+
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", False)
+    def test_initialize_no_appinsights_package(self):
+        """Test initialization when applicationinsights package is not available."""
+        _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is None
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_initialize_creates_client(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test that initialization creates Application Insights client."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        with patch.dict(
+            os.environ,
+            {
+                "TELEMETRY_CONNECTION_STRING": (
+                    "InstrumentationKey=test-key;IngestionEndpoint=https://example.com/"
+                )
+            },
+        ):
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is mock_client
+        mock_sender_class.assert_called_once_with(
+            service_endpoint_uri="https://example.com/v2/track"
+        )
+        mock_client_class.assert_called_once_with(
+            "test-key", telemetry_channel=mock_channel_class.return_value
+        )
+
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_initialize_invalid_connection_string(
+        self, mock_client_class, mock_sender_class
+    ):
+        """Test initialization with invalid connection string."""
+        with patch.dict(
+            os.environ,
+            {"TELEMETRY_CONNECTION_STRING": "invalid-connection-string"},
+        ):
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is None
+        mock_client_class.assert_not_called()
+
+    def test_initialize_only_once(self):
+        """Test that initialization only happens once."""
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = "existing_client"
+
+        _AppInsightsEventClient._initialize()
+
+        # Should not change the client since already initialized
+        assert _AppInsightsEventClient._client == "existing_client"
+
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_track_event_calls_client(self, mock_client_class):
+        """Test that track_event calls the Application Insights client."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = mock_client
+
+        properties = {"key1": "value1", "key2": 123, "key3": None}
+
+        _AppInsightsEventClient.track_event("test_event", properties)
+
+        mock_client.track_event.assert_called_once_with(
+            name="test_event",
+            properties={
+                "key1": "value1",
+                "key2": "123",
+            },  # None filtered, int converted
+            measurements={},
+        )
+
+    def test_track_event_no_client(self):
+        """Test that track_event does nothing when client is not initialized."""
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = None
+
+        # Should not raise any exception
+        _AppInsightsEventClient.track_event("test_event", {"key": "value"})
+
+    def test_track_event_empty_properties(self):
+        """Test track_event with empty properties."""
+        mock_client = MagicMock()
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = mock_client
+
+        _AppInsightsEventClient.track_event("test_event", None)
+
+        mock_client.track_event.assert_called_once_with(
+            name="test_event",
+            properties={},
+            measurements={},
+        )
+
+    def test_flush_calls_client(self):
+        """Test that flush calls the client's flush method."""
+        mock_client = MagicMock()
+        _AppInsightsEventClient._client = mock_client
+
+        _AppInsightsEventClient.flush()
+
+        mock_client.flush.assert_called_once()
+
+    def test_flush_no_client(self):
+        """Test that flush does nothing when client is not available."""
+        _AppInsightsEventClient._client = None
+
+        # Should not raise any exception
+        _AppInsightsEventClient.flush()
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_connection_string_provider_overrides_default(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test that a custom provider is used instead of _get_connection_string."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        def provider() -> str:
+            return (
+                "InstrumentationKey=from-provider;IngestionEndpoint=https://custom.com/"
+            )
+
+        _AppInsightsEventClient.set_connection_string_provider(provider)
+
+        _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._client is mock_client
+        mock_client_class.assert_called_once_with(
+            "from-provider", telemetry_channel=mock_channel_class.return_value
+        )
+        mock_sender_class.assert_called_once_with(
+            service_endpoint_uri="https://custom.com/v2/track"
+        )
+
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    def test_connection_string_provider_returning_none_skips_client(self):
+        """Test that provider returning None results in no client."""
+        _AppInsightsEventClient.set_connection_string_provider(lambda: None)
+
+        _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is None
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    @patch(
+        "uipath.telemetry._track._CONNECTION_STRING",
+        "InstrumentationKey=builtin-key",
+    )
+    def test_provider_bypasses_builtin_fallback(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test that provider prevents fallback to _CONNECTION_STRING."""
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        _AppInsightsEventClient.set_connection_string_provider(
+            lambda: "InstrumentationKey=provider-key"
+        )
+
+        with patch.dict(os.environ, {}, clear=True):
+            _AppInsightsEventClient._initialize()
+
+        # Should use provider-key, not builtin-key
+        mock_client_class.assert_called_once_with(
+            "provider-key", telemetry_channel=mock_channel_class.return_value
+        )
+
+    def test_reset_clears_initialized_and_client(self):
+        """Test that reset clears initialized flag and client."""
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = MagicMock()
+
+        _AppInsightsEventClient.reset()
+
+        assert _AppInsightsEventClient._initialized is False
+        assert _AppInsightsEventClient._client is None
+
+    def test_reset_flushes_before_clearing(self):
+        """Test that reset flushes pending events before clearing."""
+        mock_client = MagicMock()
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = mock_client
+
+        _AppInsightsEventClient.reset()
+
+        mock_client.flush.assert_called_once()
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_reset_allows_reinitialization_with_new_connection_string(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test that after reset, next initialize reads current env."""
+        mock_client_1 = MagicMock()
+        mock_client_2 = MagicMock()
+        mock_client_class.side_effect = [mock_client_1, mock_client_2]
+
+        # First init with connection string A
+        with patch.dict(
+            os.environ,
+            {"TELEMETRY_CONNECTION_STRING": "InstrumentationKey=key-a"},
+        ):
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._client is mock_client_1
+
+        # Reset
+        _AppInsightsEventClient.reset()
+
+        # Second init with connection string B
+        with patch.dict(
+            os.environ,
+            {"TELEMETRY_CONNECTION_STRING": "InstrumentationKey=key-b"},
+        ):
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._client is mock_client_2
+        assert mock_client_class.call_count == 2
+
+
+class TestPublicProviderAndResetFunctions:
+    """Test the public set_event_connection_string_provider and reset_event_client."""
+
+    def setup_method(self) -> None:
+        """Reset state before each test."""
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+        _AppInsightsEventClient._connection_string_provider = None
+
+    def teardown_method(self) -> None:
+        """Clean up after each test."""
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+        _AppInsightsEventClient._connection_string_provider = None
+
+    def test_set_event_connection_string_provider_sets_provider(self) -> None:
+        """Test that the public function sets the provider on the client."""
+
+        def provider() -> str:
+            return "InstrumentationKey=test"
+
+        set_event_connection_string_provider(provider)
+
+        assert _AppInsightsEventClient._connection_string_provider is provider
+
+    def test_reset_event_client_resets_state(self) -> None:
+        """Test that the public function resets client state."""
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = MagicMock()
+
+        reset_event_client()
+
+        assert _AppInsightsEventClient._initialized is False
+        assert _AppInsightsEventClient._client is None
+
+
+class TestTelemetryClient:
+    """Test _TelemetryClient functionality."""
+
+    def setup_method(self):
+        """Reset TelemetryClient state before each test."""
+        _TelemetryClient._initialized = False
+
+    def teardown_method(self):
+        """Clean up after each test."""
+        _TelemetryClient._initialized = False
+
+    def test_is_enabled_default_true(self):
+        """Test that telemetry is enabled by default."""
+        with patch.dict(os.environ, {}, clear=True):
+            os.environ.pop("UIPATH_TELEMETRY_ENABLED", None)
+
+            assert _TelemetryClient._is_enabled() is True
+
+    def test_is_enabled_explicit_true(self):
+        """Test telemetry enabled when explicitly set to true."""
+        with patch.dict(os.environ, {"UIPATH_TELEMETRY_ENABLED": "true"}):
+            assert _TelemetryClient._is_enabled() is True
+
+    def test_is_enabled_explicit_false(self):
+        """Test telemetry disabled when set to false."""
+        with patch.dict(os.environ, {"UIPATH_TELEMETRY_ENABLED": "false"}):
+            assert _TelemetryClient._is_enabled() is False
+
+    def test_is_enabled_case_insensitive(self):
+        """Test that telemetry enabled check is case insensitive."""
+        with patch.dict(os.environ, {"UIPATH_TELEMETRY_ENABLED": "TRUE"}):
+            assert _TelemetryClient._is_enabled() is True
+
+        with patch.dict(os.environ, {"UIPATH_TELEMETRY_ENABLED": "False"}):
+            assert _TelemetryClient._is_enabled() is False
+
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=False)
+    def test_track_event_disabled(self, mock_is_enabled):
+        """Test that track_event does nothing when telemetry is disabled."""
+        with patch.object(_AppInsightsEventClient, "track_event") as mock_track:
+            _TelemetryClient.track_event("test_event", {"key": "value"})
+
+            mock_track.assert_not_called()
+
+    @patch.object(_AppInsightsEventClient, "register_atexit_flush")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    @patch.object(_AppInsightsEventClient, "track_event")
+    def test_track_event_enabled(self, mock_track, mock_is_enabled, mock_atexit):
+        """Test that track_event calls AppInsightsEventClient when enabled."""
+        properties = {"key": "value"}
+
+        _TelemetryClient.track_event("test_event", properties)
+
+        mock_track.assert_called_once_with("test_event", properties)
+
+    @patch.object(_AppInsightsEventClient, "register_atexit_flush")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    @patch.object(_AppInsightsEventClient, "track_event")
+    def test_track_event_registers_atexit_handler(
+        self, mock_track, mock_is_enabled, mock_atexit
+    ):
+        """Test that track_event registers atexit flush handler."""
+        _TelemetryClient.track_event("test_event", {"key": "value"})
+
+        mock_atexit.assert_called_once()
+
+
+class TestPublicFunctions:
+    """Test public telemetry functions."""
+
+    def setup_method(self):
+        """Reset state before each test."""
+        _TelemetryClient._initialized = False
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+
+    @patch.object(_TelemetryClient, "track_event")
+    def test_track_event_function(self, mock_track):
+        """Test the global track_event function."""
+        properties = {"key": "value"}
+
+        track_event("test_event", properties)
+
+        mock_track.assert_called_once_with("test_event", properties)
+
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_is_telemetry_enabled_true(self, mock_is_enabled):
+        """Test is_telemetry_enabled returns True when enabled."""
+        assert is_telemetry_enabled() is True
+
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=False)
+    def test_is_telemetry_enabled_false(self, mock_is_enabled):
+        """Test is_telemetry_enabled returns False when disabled."""
+        assert is_telemetry_enabled() is False
+
+    @patch.object(_AppInsightsEventClient, "flush")
+    def test_flush_events_function(self, mock_flush):
+        """Test the global flush_events function."""
+        flush_events()
+
+        mock_flush.assert_called_once()
+
+
+class TestTrackDecorator:
+    """Test the @track decorator functionality."""
+
+    def setup_method(self):
+        """Reset state before each test."""
+        _TelemetryClient._initialized = False
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_with_name(self, mock_is_enabled, mock_track_method):
+        """Test @track decorator with explicit name."""
+
+        @track("custom_name")
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        mock_track_method.assert_called_once_with("custom_name", None)
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_without_name(self, mock_is_enabled, mock_track_method):
+        """Test @track decorator without name uses function name."""
+
+        @track
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        mock_track_method.assert_called_once_with("my_function", None)
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_with_extra(self, mock_is_enabled, mock_track_method):
+        """Test @track decorator with extra attributes."""
+        extra = {"attr1": "value1"}
+
+        @track("event_name", extra=extra)
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        mock_track_method.assert_called_once_with("event_name", extra)
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_when_condition_true(
+        self, mock_is_enabled, mock_track_method
+    ):
+        """Test @track decorator with when condition that returns True."""
+
+        @track("event_name", when=True)
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        mock_track_method.assert_called_once()
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_when_condition_false(
+        self, mock_is_enabled, mock_track_method
+    ):
+        """Test @track decorator with when condition that returns False."""
+
+        @track("event_name", when=False)
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        mock_track_method.assert_not_called()
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_when_callable(self, mock_is_enabled, mock_track_method):
+        """Test @track decorator with callable when condition."""
+
+        @track("event_name", when=lambda x: x > 5)
+        def my_function(x):
+            return x * 2
+
+        # Should track when x > 5
+        result = my_function(10)
+        assert result == 20
+        mock_track_method.assert_called_once()
+
+        mock_track_method.reset_mock()
+
+        # Should not track when x <= 5
+        result = my_function(3)
+        assert result == 6
+        mock_track_method.assert_not_called()
+
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=False)
+    @patch.object(_TelemetryClient, "_initialize")
+    def test_track_decorator_telemetry_disabled(self, mock_initialize, mock_is_enabled):
+        """Test @track decorator doesn't initialize when telemetry is disabled.
+
+        The decorator still calls _track_method, but _track_method should
+        short-circuit and not initialize when telemetry is disabled.
+        """
+
+        @track("event_name")
+        def my_function():
+            return "result"
+
+        result = my_function()
+
+        assert result == "result"
+        # _initialize should not be called when telemetry is disabled
+        mock_initialize.assert_not_called()
+
+    @patch.object(_TelemetryClient, "_track_method")
+    @patch.object(_TelemetryClient, "_is_enabled", return_value=True)
+    def test_track_decorator_preserves_function_metadata(
+        self, mock_is_enabled, mock_track_method
+    ):
+        """Test that @track decorator preserves function metadata."""
+
+        @track("event_name")
+        def my_function_with_doc():
+            """This is a docstring."""
+            return "result"
+
+        assert my_function_with_doc.__name__ == "my_function_with_doc"
+        assert my_function_with_doc.__doc__ == "This is a docstring."
+
+
+class TestTelemetryExceptionHandling:
+    """Test that telemetry never breaks the main application."""
+
+    def setup_method(self):
+        """Reset state before each test."""
+        _AppInsightsEventClient._initialized = False
+        _AppInsightsEventClient._client = None
+
+    def test_track_event_handles_client_exception(self):
+        """Test that track_event handles exceptions from the client."""
+        mock_client = MagicMock()
+        mock_client.track_event.side_effect = Exception("Client error")
+        _AppInsightsEventClient._initialized = True
+        _AppInsightsEventClient._client = mock_client
+
+        # Should not raise exception
+        _AppInsightsEventClient.track_event("test_event", {"key": "value"})
+
+    def test_flush_handles_exception(self):
+        """Test that flush handles exceptions from the client."""
+        mock_client = MagicMock()
+        mock_client.flush.side_effect = Exception("Flush error")
+        _AppInsightsEventClient._client = mock_client
+
+        # Should not raise exception
+        _AppInsightsEventClient.flush()
+
+    @patch("uipath.telemetry._track.TelemetryChannel")
+    @patch("uipath.telemetry._track.SynchronousQueue")
+    @patch("uipath.telemetry._track._DiagnosticSender")
+    @patch("uipath.telemetry._track._HAS_APPINSIGHTS", True)
+    @patch("uipath.telemetry._track.AppInsightsTelemetryClient")
+    def test_initialize_handles_exception(
+        self, mock_client_class, mock_sender_class, mock_queue_class, mock_channel_class
+    ):
+        """Test that initialization handles exceptions."""
+        mock_client_class.side_effect = Exception("Init error")
+
+        with patch.dict(
+            os.environ,
+            {"TELEMETRY_CONNECTION_STRING": "InstrumentationKey=test-key"},
+        ):
+            # Should not raise exception
+            _AppInsightsEventClient._initialize()
+
+        assert _AppInsightsEventClient._initialized is True
+        assert _AppInsightsEventClient._client is None
+
+
+class TestDiagnosticSender:
+    """Test _DiagnosticSender retry, re-queue, and discard logic."""
+
+    def _make_sender(self):
+        """Create a _DiagnosticSender with a mock queue."""
+        sender = _DiagnosticSender.__new__(_DiagnosticSender)
+        sender._service_endpoint_uri = "https://example.com/v2/track"
+        sender._timeout = 10
+        sender._queue = MagicMock()
+        return sender
+
+    def _make_data_item(self, send_attempts=None):
+        item = MagicMock()
+        item.write.return_value = {"name": "test"}
+        if send_attempts is not None:
+            item._send_attempts = send_attempts
+        else:
+            del item._send_attempts
+        return item
+
+    @patch("urllib.request.urlopen")
+    def test_successful_send_does_not_requeue(self, mock_urlopen):
+        """Test that a 2xx response returns early without re-queuing."""
+        sender = self._make_sender()
+        mock_response = MagicMock()
+        mock_response.getcode.return_value = 200
+        mock_urlopen.return_value = mock_response
+
+        data = [self._make_data_item()]
+        sender.send(data)
+
+        sender._queue.put.assert_not_called()
+
+    @patch("urllib.request.urlopen")
+    def test_http_400_discards_without_requeue(self, mock_urlopen):
+        """Test that HTTP 400 logs a warning and returns before retry logic."""
+        from urllib.error import HTTPError
+
+        sender = self._make_sender()
+        mock_urlopen.side_effect = HTTPError(
+            url="https://example.com",
+            code=400,
+            msg="Bad Request",
+            hdrs=MagicMock(),
+            fp=None,
+        )
+
+        data = [self._make_data_item()]
+        sender.send(data)
+
+        sender._queue.put.assert_not_called()
+
+    @patch("urllib.request.urlopen")
+    def test_multiple_fresh_items_all_requeued_on_failure(self, mock_urlopen):
+        """Test that all fresh items in a batch are re-queued on failure."""
+        from urllib.error import HTTPError
+
+        sender = self._make_sender()
+        mock_urlopen.side_effect = HTTPError(
+            url="https://example.com",
+            code=503,
+            msg="Unavailable",
+            hdrs=MagicMock(),
+            fp=None,
+        )
+
+        items = [self._make_data_item() for _ in range(3)]
+        sender.send(items)
+
+        assert sender._queue.put.call_count == 3
+        for item in items:
+            assert item._send_attempts == 1
+
+    @patch("urllib.request.urlopen")
+    def test_item_with_one_prior_attempt_is_discarded(self, mock_urlopen):
+        """Test that an already-retried item (attempt=1) is discarded on next failure."""
+        from urllib.error import HTTPError
+
+        sender = self._make_sender()
+        mock_urlopen.side_effect = HTTPError(
+            url="https://example.com",
+            code=500,
+            msg="Server Error",
+            hdrs=MagicMock(),
+            fp=None,
+        )
+
+        item = self._make_data_item(send_attempts=1)  # already retried once
+        sender.send([item])
+
+        sender._queue.put.assert_not_called()
+
+    @patch("urllib.request.urlopen")
+    def test_mixed_batch_requeues_fresh_discards_retried(self, mock_urlopen):
+        """Test a batch with both fresh and already-retried items."""
+        from urllib.error import HTTPError
+
+        sender = self._make_sender()
+        mock_urlopen.side_effect = HTTPError(
+            url="https://example.com",
+            code=502,
+            msg="Bad Gateway",
+            hdrs=MagicMock(),
+            fp=None,
+        )
+
+        fresh_item = self._make_data_item()  # no prior attempts
+        retried_item = self._make_data_item(send_attempts=1)  # already retried
+
+        sender.send([fresh_item, retried_item])
+
+        sender._queue.put.assert_called_once_with(fresh_item)
+        assert fresh_item._send_attempts == 1
diff --git a/packages/uipath/tests/tracing/test_otel_exporters.py b/packages/uipath/tests/tracing/test_otel_exporters.py
new file mode 100644
index 000000000..fc5a370c0
--- /dev/null
+++ b/packages/uipath/tests/tracing/test_otel_exporters.py
@@ -0,0 +1,827 @@
+import json
+import os
+import unittest
+from unittest.mock import MagicMock, patch
+
+import pytest
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+
+from uipath.tracing._otel_exporters import (
+    LlmOpsHttpExporter,
+    SpanStatus,
+)
+
+
+@pytest.fixture
+def mock_env_vars():
+    """Fixture to set and clean up environment variables for testing."""
+    original_values = {}
+
+    # Save original values
+    for var in ["UIPATH_URL", "UIPATH_ACCESS_TOKEN"]:
+        original_values[var] = os.environ.get(var)
+
+    # Set test values
+    os.environ["UIPATH_URL"] = "https://test.uipath.com/org/tenant/"
+    os.environ["UIPATH_ACCESS_TOKEN"] = "test-token"
+
+    yield
+
+    # Restore original values
+    for var, value in original_values.items():
+        if value is None:
+            if var in os.environ:
+                del os.environ[var]
+        else:
+            os.environ[var] = value
+
+
+@pytest.fixture
+def mock_span():
+    """Create a mock ReadableSpan for testing."""
+    span = MagicMock(spec=ReadableSpan)
+    # Ensure span doesn't get filtered by _should_drop_span (whitelist approach)
+    # Only spans with uipath.custom_instrumentation=True are kept
+    span.attributes = {"uipath.custom_instrumentation": True}
+    return span
+
+
+@pytest.fixture
+def exporter(mock_env_vars):
+    """Create an exporter instance for testing."""
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
+        exporter = LlmOpsHttpExporter()
+        # Mock _build_url to include query parameters as in the actual implementation
+        exporter._build_url = MagicMock(  # type: ignore
+            return_value="https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=CodedAgents"
+        )
+        yield exporter
+
+
+def test_init_with_env_vars(mock_env_vars):
+    """Test initialization with environment variables."""
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
+        exporter = LlmOpsHttpExporter()
+
+        assert exporter.base_url == "https://test.uipath.com/org/tenant/llmopstenant_"
+        assert exporter.auth_token == "test-token"
+        assert exporter.headers == {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer test-token",
+        }
+
+
+def test_init_with_default_url():
+    """Test initialization with default URL when environment variable is not set."""
+    with (
+        patch("uipath.tracing._otel_exporters.httpx.Client"),
+        patch.dict(os.environ, {"UIPATH_ACCESS_TOKEN": "test-token"}, clear=True),
+    ):
+        exporter = LlmOpsHttpExporter()
+
+        assert (
+            exporter.base_url
+            == "https://cloud.uipath.com/dummyOrg/dummyTennant/llmopstenant_"
+        )
+        assert exporter.auth_token == "test-token"
+
+
+def test_export_success(exporter, mock_span):
+    """Test successful export of spans."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data", "TraceId": "test-trace-id"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        exporter.http_client.post.return_value = mock_response
+
+        result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.SUCCESS
+        exporter._build_url.assert_called_once_with(
+            [{"span": "data", "TraceId": "test-trace-id"}]
+        )
+        exporter.http_client.post.assert_called_once_with(
+            "https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=CodedAgents",
+            json=[{"span": "data", "TraceId": "test-trace-id"}],
+        )
+
+
+def test_export_failure(exporter, mock_span):
+    """Test export failure with multiple retries."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        mock_response = MagicMock()
+        mock_response.status_code = 500
+        mock_response.text = "Internal Server Error"
+        exporter.http_client.post.return_value = mock_response
+
+        with patch("uipath.tracing._otel_exporters.time.sleep") as mock_sleep:
+            result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.FAILURE
+        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
+        assert (
+            mock_sleep.call_count == 3
+        )  # Should sleep between retries (except after the last one)
+
+
+def test_export_exception(exporter, mock_span):
+    """Test export with exceptions during HTTP request."""
+    mock_uipath_span = MagicMock()
+    mock_uipath_span.to_dict.return_value = {"span": "data"}
+
+    with patch(
+        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+        return_value=mock_uipath_span,
+    ):
+        exporter.http_client.post.side_effect = Exception("Connection error")
+
+        with patch("uipath.tracing._otel_exporters.time.sleep"):
+            result = exporter.export([mock_span])
+
+        assert result == SpanExportResult.FAILURE
+        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
+
+
+def test_force_flush(exporter):
+    """Test force_flush returns True."""
+    assert exporter.force_flush() is True
+
+
+def test_get_base_url():
+    """Test _get_base_url method with different environment configurations."""
+    # Test with environment variable set
+    with patch.dict(
+        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"}, clear=True
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert (
+                exporter.base_url
+                == "https://custom.uipath.com/org/tenant/llmopstenant_"
+            )
+
+    # Test with environment variable set but with no trailing slash
+    with patch.dict(
+        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant"}, clear=True
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert (
+                exporter.base_url
+                == "https://custom.uipath.com/org/tenant/llmopstenant_"
+            )
+
+    # Test with no environment variable
+    with patch.dict(os.environ, {}, clear=True):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert (
+                exporter.base_url
+                == "https://cloud.uipath.com/dummyOrg/dummyTennant/llmopstenant_"
+            )
+
+    # Test UIPATH_TRACE_BASE_URL takes precedence over UIPATH_URL
+    with patch.dict(
+        os.environ,
+        {
+            "UIPATH_TRACE_BASE_URL": "https://custom-trace.example.com/my_prefix",
+            "UIPATH_URL": "https://custom.uipath.com/org/tenant",
+        },
+        clear=True,
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert exporter.base_url == "https://custom-trace.example.com/my_prefix"
+
+    # Test UIPATH_TRACE_BASE_URL strips trailing slash
+    with patch.dict(
+        os.environ,
+        {"UIPATH_TRACE_BASE_URL": "https://custom-trace.example.com/prefix/"},
+        clear=True,
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            assert exporter.base_url == "https://custom-trace.example.com/prefix"
+
+
+def test_internal_headers_set_when_trace_base_url_present():
+    """Test that internal tenant/account headers are set when UIPATH_TRACE_BASE_URL is configured."""
+    with patch.dict(
+        os.environ,
+        {
+            "UIPATH_TRACE_BASE_URL": "http://localhost:8888/llmops_",
+            "UIPATH_ACCESS_TOKEN": "test-token",
+            "UIPATH_TENANT_ID": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+            "UIPATH_ORGANIZATION_ID": "11111111-2222-3333-4444-555555555555",
+        },
+        clear=True,
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+
+            assert (
+                exporter.headers["X-UiPath-Internal-TenantId"]
+                == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+            )
+            assert (
+                exporter.headers["X-UiPath-Internal-AccountId"]
+                == "11111111-2222-3333-4444-555555555555"
+            )
+
+
+def test_internal_headers_not_set_without_trace_base_url():
+    """Test that internal headers are NOT set when UIPATH_TRACE_BASE_URL is absent (cloud mode)."""
+    with patch.dict(
+        os.environ,
+        {
+            "UIPATH_URL": "https://cloud.uipath.com/org/tenant",
+            "UIPATH_ACCESS_TOKEN": "test-token",
+            "UIPATH_TENANT_ID": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+            "UIPATH_ORGANIZATION_ID": "11111111-2222-3333-4444-555555555555",
+        },
+        clear=True,
+    ):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+
+            assert "X-UiPath-Internal-TenantId" not in exporter.headers
+            assert "X-UiPath-Internal-AccountId" not in exporter.headers
+
+
+def test_send_with_retries_success():
+    """Test _send_with_retries method with successful response."""
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
+        exporter = LlmOpsHttpExporter()
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        exporter.http_client.post.return_value = mock_response  # type: ignore
+
+        result = exporter._send_with_retries("http://example.com", [{"span": "data"}])
+
+        assert result == SpanExportResult.SUCCESS
+        exporter.http_client.post.assert_called_once_with(  # type: ignore
+            "http://example.com", json=[{"span": "data"}]
+        )
+
+
+class TestLangchainExporter(unittest.TestCase):
+    def setUp(self):
+        self.exporter = LlmOpsHttpExporter()
+
+    def test_process_span_with_dict_attributes(self):
+        """
+        Tests that the span is processed correctly when Attributes is a dictionary.
+        When attributes start as dict, they remain as dict (optimized path).
+        """
+        span_data = {
+            "Id": "501e2c8c-066a-43a8-8e14-7a8d51773a13",
+            "TraceId": "8b706075-9bfc-452c-be10-766aa8827c35",
+            "ParentId": "607b554d-f340-4cb7-9793-501d21c25bc1",
+            "Name": "UiPathChat",
+            "StartTime": "2025-09-18T14:35:47.523Z",
+            "EndTime": "2025-09-18T14:35:48.988Z",
+            "Attributes": {
+                "input.value": '{"messages": [[{"lc": 1, "type": "constructor", "id": ["langchain", "schema", "messages", "HumanMessage"], "kwargs": {"content": "Test content", "type": "human"}}]]}',
+                "output.value": '{"generations": []}',
+                "llm.model_name": "gpt-4o-mini-2024-07-18",
+                "openinference.span.kind": "LLM",
+            },
+            "Status": 1,
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        self.assertEqual(span_data["SpanType"], "completion")
+        self.assertIn("Attributes", span_data)
+
+        # When input is dict, output stays as dict (optimized path)
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertIsInstance(attributes, dict)
+        self.assertEqual(attributes["model"], "gpt-4o-mini-2024-07-18")
+        self.assertIn("input", attributes)
+        self.assertIn("output", attributes)
+
+    def test_process_span_with_json_string_attributes(self):
+        """
+        Tests that the span is processed correctly when Attributes is a JSON string.
+        """
+        attributes_dict = {
+            "input.value": '{"messages": [[{"lc": 1, "type": "constructor", "id": ["langchain", "schema", "messages", "HumanMessage"], "kwargs": {"content": "Test content", "type": "human"}}]]}',
+            "output.value": '{"generations": []}',
+            "llm.model_name": "gpt-4o-mini-2024-07-18",
+            "openinference.span.kind": "LLM",
+        }
+        span_data = {
+            "Id": "501e2c8c-066a-43a8-8e14-7a8d51773a13",
+            "TraceId": "8b706075-9bfc-452c-be10-766aa8827c35",
+            "ParentId": "607b554d-f340-4cb7-9793-501d21c25bc1",
+            "Name": "UiPathChat",
+            "StartTime": "2025-09-18T14:35:47.523Z",
+            "EndTime": "2025-09-18T14:35:48.988Z",
+            "Attributes": json.dumps(attributes_dict),
+            "Status": 1,
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        self.assertEqual(span_data["SpanType"], "completion")
+        self.assertIn("Attributes", span_data)
+
+        attributes_value = span_data["Attributes"]
+        assert isinstance(attributes_value, str)
+        attributes = json.loads(attributes_value)
+        self.assertEqual(attributes["model"], "gpt-4o-mini-2024-07-18")
+        self.assertIn("input", attributes)
+        self.assertIn("output", attributes)
+
+    def test_process_tool_span(self):
+        """
+        Tests that a tool span is processed correctly.
+        When attributes start as dict, they remain as dict (optimized path).
+        """
+        span_data = {
+            "Id": "b667e7d7-913f-4e99-8d95-1a7660e40edd",
+            "TraceId": "8b706075-9bfc-452c-be10-766aa8827c35",
+            "ParentId": "607b554d-f340-4cb7-9793-501d21c25bc1",
+            "Name": "get_current_time",
+            "StartTime": "2025-09-18T14:35:48.992Z",
+            "EndTime": "2025-09-18T14:35:48.993Z",
+            "Attributes": {
+                "input.value": "{}",
+                "output.value": "2025-09-18 14:35:48",
+                "tool.name": "get_current_time",
+                "openinference.span.kind": "TOOL",
+            },
+            "Status": 1,
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        self.assertEqual(span_data["SpanType"], "toolCall")
+        self.assertIn("Attributes", span_data)
+
+        # When input is dict, output stays as dict (optimized path)
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertIsInstance(attributes, dict)
+        self.assertEqual(attributes["toolName"], "get_current_time")
+        self.assertEqual(attributes["arguments"], {})
+        self.assertEqual(attributes["result"], "2025-09-18 14:35:48")
+        self.assertIn("input.value", attributes)
+        self.assertIn("output.value", attributes)
+
+    def test_process_span_attributes_tool_call(self):
+        span_data = {
+            "PermissionStatus": 0,
+            "Id": "7ec33180-5fe5-49ec-87aa-03d5a1e9ccc7",
+            "TraceId": "fde81e6a-cb40-496a-bff1-939b061dd6c9",
+            "ParentId": "0babf3dd-aff3-4961-a8b3-1e7f64259832",
+            "Name": "get_current_time",
+            "StartTime": "2025-09-18T14:58:31.417Z",
+            "EndTime": "2025-09-18T14:58:31.418Z",
+            "Attributes": {
+                "input.value": "{}",
+                "output.value": "2025-09-18 14:58:31",
+                "tool.name": "get_current_time",
+                "tool.description": "Get the current date and time.",
+                "session.id": "0b3cf051-6446-4467-a9a1-3b4b699f476b",
+                "metadata": '{"thread_id": "0b3cf051-6446-4467-a9a1-3b4b699f476b", "langgraph_step": 1, "langgraph_node": "make_tool_calls", "langgraph_triggers": ["branch:to:make_tool_calls"], "langgraph_path": ["__pregel_pull", "make_tool_calls"], "langgraph_checkpoint_ns": "make_tool_calls:efdce94a-e49a-99f3-180a-f1b3e44f08f7", "checkpoint_ns": "make_tool_calls:efdce94a-e49a-99f3-180a-f1b3e44f08f7"}',
+                "openinference.span.kind": "TOOL",
+            },
+            "Status": 1,
+            "OrganizationId": "b7006b1c-11c3-4a80-802e-fee0ebf9c360",
+            "TenantId": "6961a069-3392-40ca-bf5d-276f4e54c8ff",
+            "ExpiryTimeUtc": None,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "Source": 0,
+            "SpanType": "OpenTelemetry",
+            "ProcessKey": "65965c09-87e3-4fa3-a7be-3fdb3955bd47",
+            "JobKey": "0b3cf051-6446-4467-a9a1-3b4b699f476b",
+            "ReferenceId": None,
+            "VerbosityLevel": 2,
+            "ExecutionType": None,
+            "UpdatedAt": "2025-09-18T14:58:36.891Z",
+        }
+
+        self.exporter._process_span_attributes(span_data)
+        self.assertEqual(span_data["SpanType"], "toolCall")
+
+        # When input is dict, output stays as dict (optimized path)
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertIsInstance(attributes, dict)
+        self.assertEqual(attributes["toolName"], "get_current_time")
+        self.assertEqual(attributes["input"], {})
+        self.assertEqual(attributes["output"], "2025-09-18 14:58:31")
+
+    def test_tool_span_mapping_issue(self):
+        """
+        Test the specific TOOL span that fails to map correctly.
+        This reproduces the issue where TOOL spans don't get properly mapped.
+        """
+        span_data = {
+            "PermissionStatus": 0,
+            "Id": "79398bc6-f01f-424b-9238-342d71f38d3e",
+            "TraceId": "731b01dd-ae81-4681-ad27-a56d33e80fe1",
+            "ParentId": "2529b799-c3b9-4506-8e00-6824f6b5c30a",
+            "Name": "get_current_time",
+            "StartTime": "2025-09-18T15:14:19.639Z",
+            "EndTime": "2025-09-18T15:14:19.640Z",
+            "Attributes": {
+                "input.value": "{}",
+                "output.value": "2025-09-18 15:14:19",
+                "tool.name": "get_current_time",
+                "tool.description": "Get the current date and time.",
+                "session.id": "8364fdaf-3915-414b-9f64-f90a62a7454c",
+                "metadata": '{"thread_id": "8364fdaf-3915-414b-9f64-f90a62a7454c", "langgraph_step": 1, "langgraph_node": "make_tool_calls", "langgraph_triggers": ["branch:to:make_tool_calls"], "langgraph_path": ["__pregel_pull", "make_tool_calls"], "langgraph_checkpoint_ns": "make_tool_calls:1758151e-7e11-2f93-d853-06bf123710ca", "checkpoint_ns": "make_tool_calls:1758151e-7e11-2f93-d853-06bf123710ca"}',
+                "openinference.span.kind": "TOOL",
+            },
+            "Status": 1,
+            "OrganizationId": "b7006b1c-11c3-4a80-802e-fee0ebf9c360",
+            "TenantId": "6961a069-3392-40ca-bf5d-276f4e54c8ff",
+            "ExpiryTimeUtc": None,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "Source": 0,
+            "SpanType": "OpenTelemetry",
+            "ProcessKey": "65965c09-87e3-4fa3-a7be-3fdb3955bd47",
+            "JobKey": "8364fdaf-3915-414b-9f64-f90a62a7454c",
+            "ReferenceId": None,
+            "VerbosityLevel": 2,
+            "ExecutionType": None,
+            "UpdatedAt": "2025-09-18T15:14:20.482Z",
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        # SpanType should be mapped to toolCall
+        self.assertEqual(span_data["SpanType"], "toolCall")
+
+        # Attributes should be processed
+        self.assertIn("Attributes", span_data)
+
+        # When input is dict, output stays as dict (optimized path)
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertIsInstance(attributes, dict)
+
+        # These are the expected attributes for a tool call
+        self.assertEqual(attributes["toolName"], "get_current_time")
+        self.assertEqual(attributes["type"], "toolCall")
+        self.assertEqual(attributes["arguments"], {})
+        self.assertEqual(attributes["result"], "2025-09-18 15:14:19")
+        self.assertEqual(attributes["toolType"], "Integration")
+        self.assertNotIn("error", attributes)  # error should be absent when no error
+
+        # input.value should be mapped to input
+        self.assertIn("input", attributes)
+        self.assertEqual(attributes["input"], {})
+
+    def test_tool_span_preserves_existing_tool_type(self):
+        """Test that existing toolType in attributes is preserved, not overwritten."""
+        span_data = {
+            "Id": "test-span-id",
+            "TraceId": "test-trace-id",
+            "Attributes": {
+                "openinference.span.kind": "TOOL",
+                "tool.name": "my_custom_tool",
+                "input.value": "{}",
+                "output.value": '"result"',
+                "toolType": "Escalation",
+            },
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertEqual(attributes["toolType"], "Escalation")
+
+    def test_llm_span_mapping_consistency(self):
+        """
+        Test that LLM spans are consistently mapped to completion type.
+        This verifies the fix for flaky span type mapping.
+        """
+        span_data = {
+            "PermissionStatus": 0,
+            "Id": "8198780d-9d79-4270-b69d-aaf012189c50",
+            "TraceId": "78e8f5a6-d694-456f-a639-ab161ac8ac5b",
+            "ParentId": "c8c6e2bb-241b-429a-8471-95da8693a28f",
+            "Name": "UiPathChat",
+            "StartTime": "2025-09-18T15:25:36.486Z",
+            "EndTime": "2025-09-18T15:25:37.720Z",
+            "Attributes": {
+                "input.value": '{"messages": []}',
+                "output.value": '{"generations": []}',
+                "llm.model_name": "gpt-4o-mini-2024-07-18",
+                "llm.token_count.prompt": 219,
+                "llm.token_count.completion": 66,
+                "llm.token_count.total": 285,
+                "openinference.span.kind": "LLM",
+            },
+            "Status": 1,
+            "OrganizationId": "b7006b1c-11c3-4a80-802e-fee0ebf9c360",
+            "TenantId": "6961a069-3392-40ca-bf5d-276f4e54c8ff",
+            "ExpiryTimeUtc": None,
+            "FolderKey": "d0e09040-5997-44e1-93b7-4087689521b7",
+            "Source": 0,
+            "SpanType": "OpenTelemetry",
+            "ProcessKey": "65965c09-87e3-4fa3-a7be-3fdb3955bd47",
+            "JobKey": "04ecd5b3-72ef-4302-beae-7d21a94ab0de",
+            "ReferenceId": None,
+            "VerbosityLevel": 2,
+            "ExecutionType": None,
+            "UpdatedAt": "2025-09-18T15:25:38.591Z",
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        # Verify LLM span gets mapped to completion
+        self.assertEqual(span_data["SpanType"], "completion")
+
+        # Verify attributes are processed
+        self.assertIn("Attributes", span_data)
+
+        # When input is dict, output stays as dict (optimized path)
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+        self.assertIsInstance(attributes, dict)
+
+        # Verify LLM-specific attributes are present
+        self.assertEqual(attributes["model"], "gpt-4o-mini-2024-07-18")
+        self.assertIn("usage", attributes)
+        usage = attributes["usage"]
+        assert isinstance(usage, dict)
+        self.assertEqual(usage["promptTokens"], 219)
+        self.assertEqual(usage["completionTokens"], 66)
+        self.assertEqual(usage["totalTokens"], 285)
+
+    def test_unknown_span_type_preserved(self):
+        """
+        Test that spans with UNKNOWN or unrecognized openinference.span.kind
+        are still exported and don't get dropped.
+
+        This tests the real-world case from the logs where PydanticOutputParser
+        spans have openinference.span.kind=UNKNOWN and should be preserved.
+        """
+        # Original span data from actual logs
+        span_data = {
+            "Id": "7325f1a7-71ea-4ec1-82c0-266b0a7242a7",
+            "TraceId": "3d53656e-8523-4917-8c58-686ab29b98da",
+            "ParentId": "0d173f1f-015e-47b5-80c4-b63111b63536",
+            "Name": "PydanticOutputParser",
+            "StartTime": "2025-10-29T12:34:48.379494",
+            "EndTime": "2025-10-29T12:34:48.380852",
+            "Attributes": {
+                "input.value": '{"content": "```json\\n{\\"label\\": \\"security\\", \\"confidence\\": 0.95}\\n```", "additional_kwargs": {}, "response_metadata": {"token_usage": {"completion_tokens": 19, "prompt_tokens": 333, "total_tokens": 352}}}',
+                "input.mime_type": "application/json",
+                "output.value": '{"label": "security", "confidence": 0.95}',
+                "output.mime_type": "application/json",
+                "session.id": "default",
+                "metadata": '{"thread_id": "default", "langgraph_step": 2, "langgraph_node": "classify"}',
+                "openinference.span.kind": "UNKNOWN",
+            },
+            "Status": 1,
+            "SpanType": "OpenTelemetry",
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        self.assertEqual(span_data["SpanType"], "UNKNOWN")
+        self.assertIn("Attributes", span_data)
+
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+
+        self.assertIn("input", attributes)
+        self.assertIn("output", attributes)
+
+        self.assertEqual(attributes["input.mime_type"], "application/json")
+        self.assertEqual(attributes["output.mime_type"], "application/json")
+
+        input_val = attributes["input"]
+        assert isinstance(input_val, dict)
+        self.assertIn("content", input_val)
+
+        output_val = attributes["output"]
+        assert isinstance(output_val, dict)
+        self.assertEqual(output_val["label"], "security")
+        self.assertEqual(output_val["confidence"], 0.95)
+
+    def test_json_strings_parsed_to_objects(self):
+        """Test that JSON-encoded strings starting with { or [ are parsed to objects.
+
+        OTEL only accepts primitives, so agents serialize dicts/lists to JSON strings.
+        The exporter should parse these back to objects before final serialization.
+        """
+        span_data = {
+            "Id": "test-span-id",
+            "TraceId": "test-trace-id",
+            "ParentId": None,
+            "Name": "Test span",
+            "StartTime": "2025-01-01T00:00:00Z",
+            "EndTime": "2025-01-01T00:00:01Z",
+            "Attributes": {
+                "type": "agentRun",
+                "inputSchema": '{"type": "object", "properties": {}}',
+                "outputSchema": '{"type": "object", "properties": {"content": {"type": "string"}}}',
+                "settings": '{"maxTokens": 16384, "temperature": 0.0}',
+                "toolCalls": '[{"id": "call_123", "name": "test_tool"}]',
+                "regularString": "not json",
+                "emptyString": "",
+            },
+            "Status": 1,
+        }
+
+        self.exporter._process_span_attributes(span_data)
+
+        attributes = span_data["Attributes"]
+        assert isinstance(attributes, dict)
+
+        # JSON strings should be parsed to objects
+        input_schema = attributes["inputSchema"]
+        assert isinstance(input_schema, dict)
+        self.assertEqual(input_schema["type"], "object")
+
+        output_schema = attributes["outputSchema"]
+        assert isinstance(output_schema, dict)
+        self.assertIn("content", output_schema["properties"])
+
+        settings = attributes["settings"]
+        assert isinstance(settings, dict)
+        self.assertEqual(settings["maxTokens"], 16384)
+
+        tool_calls = attributes["toolCalls"]
+        assert isinstance(tool_calls, list)
+        self.assertEqual(tool_calls[0]["name"], "test_tool")
+
+        # Non-JSON strings should remain as strings
+        self.assertIsInstance(attributes["regularString"], str)
+        self.assertEqual(attributes["regularString"], "not json")
+
+        self.assertIsInstance(attributes["emptyString"], str)
+        self.assertEqual(attributes["emptyString"], "")
+
+
+class TestUpsertSpan:
+    """Tests for upsert_span method."""
+
+    @pytest.fixture
+    def exporter_with_mocks(self, mock_env_vars):
+        """Create exporter with mocked HTTP client."""
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
+            exporter = LlmOpsHttpExporter()
+            exporter._build_url = MagicMock(  # type: ignore
+                return_value="https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=CodedAgents"
+            )
+            yield exporter
+
+    def test_upsert_span_success(self, exporter_with_mocks, mock_span):
+        """Test successful upsert of a span."""
+        mock_uipath_span = MagicMock()
+        mock_uipath_span.to_dict.return_value = {
+            "TraceId": "test-trace-id",
+            "Id": "span-id",
+            "Attributes": {},
+        }
+
+        with patch(
+            "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+            return_value=mock_uipath_span,
+        ):
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            exporter_with_mocks.http_client.post.return_value = mock_response
+
+            result = exporter_with_mocks.upsert_span(mock_span)
+
+            assert result == SpanExportResult.SUCCESS
+            exporter_with_mocks.http_client.post.assert_called_once()
+
+    def test_upsert_span_with_status_override(self, exporter_with_mocks, mock_span):
+        """Test upsert_span applies status_override correctly."""
+        mock_uipath_span = MagicMock()
+        mock_uipath_span.to_dict.return_value = {
+            "TraceId": "test-trace-id",
+            "Id": "span-id",
+            "Status": SpanStatus.OK,
+            "Attributes": {},
+        }
+
+        with patch(
+            "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+            return_value=mock_uipath_span,
+        ):
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            exporter_with_mocks.http_client.post.return_value = mock_response
+
+            result = exporter_with_mocks.upsert_span(
+                mock_span, status_override=SpanStatus.RUNNING
+            )
+
+            assert result == SpanExportResult.SUCCESS
+            # Verify payload has overridden status
+            call_args = exporter_with_mocks.http_client.post.call_args
+            payload = call_args.kwargs["json"]
+            assert payload[0]["Status"] == SpanStatus.RUNNING
+
+    def test_upsert_span_failure_retries(self, exporter_with_mocks, mock_span):
+        """Test upsert_span retries on failure."""
+        mock_uipath_span = MagicMock()
+        mock_uipath_span.to_dict.return_value = {
+            "TraceId": "test-trace-id",
+            "Id": "span-id",
+            "Attributes": {},
+        }
+
+        with patch(
+            "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+            return_value=mock_uipath_span,
+        ):
+            mock_response = MagicMock()
+            mock_response.status_code = 500
+            mock_response.text = "Internal Server Error"
+            exporter_with_mocks.http_client.post.return_value = mock_response
+
+            with patch("uipath.tracing._otel_exporters.time.sleep"):
+                result = exporter_with_mocks.upsert_span(mock_span)
+
+            assert result == SpanExportResult.FAILURE
+            assert exporter_with_mocks.http_client.post.call_count == 4  # max_retries=4
+
+
+class TestNilUuidProcessKey:
+    """ProcessKey nil UUID normalization during export."""
+
+    def _export_with_process_key(self, mock_env_vars, mock_span, process_key):
+        """Export a span with the given ProcessKey and return the exported payload."""
+        mock_uipath_span = MagicMock()
+        mock_uipath_span.to_dict.return_value = {
+            "TraceId": "test-trace-id",
+            "Id": "span-id",
+            "ProcessKey": process_key,
+            "Attributes": {},
+        }
+
+        with (
+            patch("uipath.tracing._otel_exporters.httpx.Client"),
+            patch(
+                "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
+                return_value=mock_uipath_span,
+            ),
+        ):
+            exporter = LlmOpsHttpExporter()
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            exporter.http_client.post.return_value = mock_response  # type: ignore
+            exporter._build_url = MagicMock(return_value="http://test/api")  # type: ignore
+
+            exporter.export([mock_span])
+
+            return exporter.http_client.post.call_args.kwargs["json"][0]  # type: ignore
+
+    def test_nil_uuid_normalized_to_none(self, mock_env_vars, mock_span):
+        payload = self._export_with_process_key(
+            mock_env_vars, mock_span, "00000000-0000-0000-0000-000000000000"
+        )
+        assert payload["ProcessKey"] is None
+
+    def test_valid_uuid_preserved(self, mock_env_vars, mock_span):
+        real_key = "65965c09-87e3-4fa3-a7be-3fdb3955bd47"
+        payload = self._export_with_process_key(mock_env_vars, mock_span, real_key)
+        assert payload["ProcessKey"] == real_key
+
+    def test_none_stays_none(self, mock_env_vars, mock_span):
+        payload = self._export_with_process_key(mock_env_vars, mock_span, None)
+        assert payload["ProcessKey"] is None
+
+
+class TestVerbosityLevelReexport:
+    """VerbosityLevel from uipath-platform is re-exported via uipath.tracing."""
+
+    def test_uipath_tracing_reexports_verbosity_level(self) -> None:
+        from uipath.platform.common._span_utils import (
+            VerbosityLevel as _CommonVerbosity,
+        )
+        from uipath.tracing import VerbosityLevel as _TracingVerbosity
+
+        assert _TracingVerbosity is _CommonVerbosity
+        assert _TracingVerbosity.OFF == 6
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/packages/uipath/uv.lock b/packages/uipath/uv.lock
new file mode 100644
index 000000000..989e4b5ea
--- /dev/null
+++ b/packages/uipath/uv.lock
@@ -0,0 +1,3040 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[options]
+exclude-newer = "2026-06-22T13:56:19.8527915Z"
+exclude-newer-span = "P2D"
+
+[options.exclude-newer-package]
+uipath-runtime = false
+uipath-platform = false
+uipath-core = false
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" },
+    { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" },
+    { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" },
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "applicationinsights"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f2/46a75ac6096d60da0e71a068015b610206e697de01fa2fb5bba8564b0798/applicationinsights-0.11.10.tar.gz", hash = "sha256:0b761f3ef0680acf4731906dfc1807faa6f2a57168ae74592db0084a6099f7b3", size = 44722, upload-time = "2021-04-22T23:22:45.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/0d/cb6b23164eb55eebaa5f9f302dfe557cfa751bd7b2779863f1abd0343b6b/applicationinsights-0.11.10-py2.py3-none-any.whl", hash = "sha256:e89a890db1c6906b6a7d0bcfd617dac83974773c64573147c8d6654f9cf2a6ea", size = 55068, upload-time = "2021-04-22T23:22:44.451Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
+]
+
+[[package]]
+name = "backrefs"
+version = "6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/e3/bb3a439d5cb255c4774724810ad8073830fac9c9dee123555820c1bcc806/backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231", size = 7011962, upload-time = "2025-11-15T14:52:08.323Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ee/c216d52f58ea75b5e1841022bbae24438b19834a29b163cb32aa3a2a7c6e/backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1", size = 381059, upload-time = "2025-11-15T14:51:59.758Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9a/8da246d988ded941da96c7ed945d63e94a445637eaad985a0ed88787cb89/backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7", size = 392854, upload-time = "2025-11-15T14:52:01.194Z" },
+    { url = "https://files.pythonhosted.org/packages/37/c9/fd117a6f9300c62bbc33bc337fd2b3c6bfe28b6e9701de336b52d7a797ad/backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a", size = 398770, upload-time = "2025-11-15T14:52:02.584Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/95/7118e935b0b0bd3f94dfec2d852fd4e4f4f9757bdb49850519acd245cd3a/backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05", size = 400726, upload-time = "2025-11-15T14:52:04.093Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/6296bad135bfafd3254ae3648cd152980a424bd6fed64a101af00cc7ba31/backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853", size = 412584, upload-time = "2025-11-15T14:52:05.233Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" },
+]
+
+[[package]]
+name = "bandit"
+version = "1.9.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "stevedore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/89/76/a7f3e639b78601118aaa4a394db2c66ae2597fbd8c39644c32874ed11e0c/bandit-1.9.3.tar.gz", hash = "sha256:ade4b9b7786f89ef6fc7344a52b34558caec5da74cb90373aed01de88472f774", size = 4242154, upload-time = "2026-01-19T04:05:22.802Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/0b/8bdc52111c83e2dc2f97403dc87c0830b8989d9ae45732b34b686326fb2c/bandit-1.9.3-py3-none-any.whl", hash = "sha256:4745917c88d2246def79748bde5e08b9d5e9b92f877863d43fab70cd8814ce6a", size = 134451, upload-time = "2026-01-19T04:05:20.938Z" },
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "bidict"
+version = "0.23.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093, upload-time = "2024-02-18T19:09:05.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
+]
+
+[[package]]
+name = "cairocffi"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/70/c5/1a4dc131459e68a173cbdab5fad6b524f53f9c1ef7861b7698e998b837cc/cairocffi-1.7.1.tar.gz", hash = "sha256:2e48ee864884ec4a3a34bfa8c9ab9999f688286eb714a15a43ec9d068c36557b", size = 88096, upload-time = "2024-06-18T10:56:06.741Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d8/ba13451aa6b745c49536e87b6bf8f629b950e84bd0e8308f7dc6883b67e2/cairocffi-1.7.1-py3-none-any.whl", hash = "sha256:9803a0e11f6c962f3b0ae2ec8ba6ae45e957a146a004697a1ac1bbf16b073b3f", size = 75611, upload-time = "2024-06-18T10:55:59.489Z" },
+]
+
+[[package]]
+name = "cairosvg"
+version = "2.8.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cairocffi" },
+    { name = "cssselect2" },
+    { name = "defusedxml" },
+    { name = "pillow" },
+    { name = "tinycss2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ab/b9/5106168bd43d7cd8b7cc2a2ee465b385f14b63f4c092bb89eee2d48c8e67/cairosvg-2.8.2.tar.gz", hash = "sha256:07cbf4e86317b27a92318a4cac2a4bb37a5e9c1b8a27355d06874b22f85bef9f", size = 8398590, upload-time = "2025-05-15T06:56:32.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/48/816bd4aaae93dbf9e408c58598bc32f4a8c65f4b86ab560864cb3ee60adb/cairosvg-2.8.2-py3-none-any.whl", hash = "sha256:eab46dad4674f33267a671dce39b64be245911c901c70d65d2b7b0821e852bf5", size = 45773, upload-time = "2025-05-15T06:56:28.552Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/ad/b59e5b451cf7172b8d1043dc0fa718f23aab379bc1521ee13d4bd9bfa960/coverage-7.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d490ba50c3f35dd7c17953c68f3270e7ccd1c6642e2d2afe2d8e720b98f5a053", size = 219278, upload-time = "2026-02-09T12:56:31.673Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/17/0cb7ca3de72e5f4ef2ec2fa0089beafbcaaaead1844e8b8a63d35173d77d/coverage-7.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:19bc3c88078789f8ef36acb014d7241961dbf883fd2533d18cb1e7a5b4e28b11", size = 219783, upload-time = "2026-02-09T12:56:33.104Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/63/325d8e5b11e0eaf6d0f6a44fad444ae58820929a9b0de943fa377fe73e85/coverage-7.13.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3998e5a32e62fdf410c0dbd3115df86297995d6e3429af80b8798aad894ca7aa", size = 250200, upload-time = "2026-02-09T12:56:34.474Z" },
+    { url = "https://files.pythonhosted.org/packages/76/53/c16972708cbb79f2942922571a687c52bd109a7bd51175aeb7558dff2236/coverage-7.13.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e264226ec98e01a8e1054314af91ee6cde0eacac4f465cc93b03dbe0bce2fd7", size = 252114, upload-time = "2026-02-09T12:56:35.749Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c2/7ab36d8b8cc412bec9ea2d07c83c48930eb4ba649634ba00cb7e4e0f9017/coverage-7.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3aa4e7b9e416774b21797365b358a6e827ffadaaca81b69ee02946852449f00", size = 254220, upload-time = "2026-02-09T12:56:37.796Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/4d/cf52c9a3322c89a0e6febdfbc83bb45c0ed3c64ad14081b9503adee702e7/coverage-7.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71ca20079dd8f27fcf808817e281e90220475cd75115162218d0e27549f95fef", size = 256164, upload-time = "2026-02-09T12:56:39.016Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/eb1dd17bd6de8289df3580e967e78294f352a5df8a57ff4671ee5fc3dcd0/coverage-7.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e2f25215f1a359ab17320b47bcdaca3e6e6356652e8256f2441e4ef972052903", size = 250325, upload-time = "2026-02-09T12:56:40.668Z" },
+    { url = "https://files.pythonhosted.org/packages/71/07/8c1542aa873728f72267c07278c5cc0ec91356daf974df21335ccdb46368/coverage-7.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d65b2d373032411e86960604dc4edac91fdfb5dca539461cf2cbe78327d1e64f", size = 251913, upload-time = "2026-02-09T12:56:41.97Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d7/c62e2c5e4483a748e27868e4c32ad3daa9bdddbba58e1bc7a15e252baa74/coverage-7.13.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94eb63f9b363180aff17de3e7c8760c3ba94664ea2695c52f10111244d16a299", size = 249974, upload-time = "2026-02-09T12:56:43.323Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9f/4c5c015a6e98ced54efd0f5cf8d31b88e5504ecb6857585fc0161bb1e600/coverage-7.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e856bf6616714c3a9fbc270ab54103f4e685ba236fa98c054e8f87f266c93505", size = 253741, upload-time = "2026-02-09T12:56:45.155Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/59/0f4eef89b9f0fcd9633b5d350016f54126ab49426a70ff4c4e87446cabdc/coverage-7.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:65dfcbe305c3dfe658492df2d85259e0d79ead4177f9ae724b6fb245198f55d6", size = 249695, upload-time = "2026-02-09T12:56:46.636Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/b7476f938deb07166f3eb281a385c262675d688ff4659ad56c6c6b8e2e70/coverage-7.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b507778ae8a4c915436ed5c2e05b4a6cecfa70f734e19c22a005152a11c7b6a9", size = 250599, upload-time = "2026-02-09T12:56:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/34/c3420709d9846ee3785b9f2831b4d94f276f38884032dca1457fa83f7476/coverage-7.13.4-cp311-cp311-win32.whl", hash = "sha256:784fc3cf8be001197b652d51d3fd259b1e2262888693a4636e18879f613a62a9", size = 221780, upload-time = "2026-02-09T12:56:50.479Z" },
+    { url = "https://files.pythonhosted.org/packages/61/08/3d9c8613079d2b11c185b865de9a4c1a68850cfda2b357fae365cf609f29/coverage-7.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:2421d591f8ca05b308cf0092807308b2facbefe54af7c02ac22548b88b95c98f", size = 222715, upload-time = "2026-02-09T12:56:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1a/54c3c80b2f056164cc0a6cdcb040733760c7c4be9d780fe655f356f433e4/coverage-7.13.4-cp311-cp311-win_arm64.whl", hash = "sha256:79e73a76b854d9c6088fe5d8b2ebe745f8681c55f7397c3c0a016192d681045f", size = 221385, upload-time = "2026-02-09T12:56:53.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
+    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
+    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
+    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
+    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
+    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
+    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
+    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
+    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
+    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
+    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
+    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
+    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
+    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
+    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
+    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cssselect2"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tinycss2" },
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9f/86/fd7f58fc498b3166f3a7e8e0cddb6e620fe1da35b02248b1bd59e95dbaaa/cssselect2-0.8.0.tar.gz", hash = "sha256:7674ffb954a3b46162392aee2a3a0aedb2e14ecf99fcc28644900f4e6e3e9d3a", size = 35716, upload-time = "2025-03-05T14:46:07.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/e7/aa315e6a749d9b96c2504a1ba0ba031ba2d0517e972ce22682e3fccecb09/cssselect2-0.8.0-py3-none-any.whl", hash = "sha256:46fc70ebc41ced7a32cd42d58b1884d72ade23d21e5a4eaaf022401c13f0e76e", size = 15454, upload-time = "2025-03-05T14:46:06.463Z" },
+]
+
+[[package]]
+name = "defusedxml"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.20.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/65/ce7f1b70157833bf3cb851b556a37d4547ceafc158aa9b34b36782f23696/filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1", size = 19485, upload-time = "2026-01-09T17:55:05.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "ghp-import"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
+]
+
+[[package]]
+name = "graphtty"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/b3/0756e1b1e46b61a4db4a463a76ca113e62113742f97ac6cf383dd05d6a97/graphtty-0.1.8.tar.gz", hash = "sha256:069cd84764cc64d414928451071fc9c97c05becbf564c2f0278691a6451a8240", size = 638011, upload-time = "2026-02-15T12:47:17.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/a9/66d01580a4a92b576c056e9967d552a28ed836540eaf73b436474c514bc2/graphtty-0.1.8-py3-none-any.whl", hash = "sha256:4e19e6d66b9ef79e2715377163f61a6542b5b9ee00d50406b80a40d0ba094f67", size = 25474, upload-time = "2026-02-15T12:47:16.377Z" },
+]
+
+[[package]]
+name = "griffe"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffecli" },
+    { name = "griffelib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/56/28a0accac339c164b52a92c6cfc45a903acc0c174caa5c1713803467b533/griffe-2.0.0.tar.gz", hash = "sha256:c68979cd8395422083a51ea7cf02f9c119d889646d99b7b656ee43725de1b80f", size = 293906, upload-time = "2026-03-23T21:06:53.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/94/ee21d41e7eb4f823b94603b9d40f86d3c7fde80eacc2c3c71845476dddaa/griffe-2.0.0-py3-none-any.whl", hash = "sha256:5418081135a391c3e6e757a7f3f156f1a1a746cc7b4023868ff7d5e2f9a980aa", size = 5214, upload-time = "2026-02-09T19:09:44.105Z" },
+]
+
+[[package]]
+name = "griffecli"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+    { name = "griffelib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a4/f8/2e129fd4a86e52e58eefe664de05e7d502decf766e7316cc9e70fdec3e18/griffecli-2.0.0.tar.gz", hash = "sha256:312fa5ebb4ce6afc786356e2d0ce85b06c1c20d45abc42d74f0cda65e159f6ef", size = 56213, upload-time = "2026-03-23T21:06:54.8Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ed/d93f7a447bbf7a935d8868e9617cbe1cadf9ee9ee6bd275d3040fbf93d60/griffecli-2.0.0-py3-none-any.whl", hash = "sha256:9f7cd9ee9b21d55e91689358978d2385ae65c22f307a63fb3269acf3f21e643d", size = 9345, upload-time = "2026-02-09T19:09:42.554Z" },
+]
+
+[[package]]
+name = "griffelib"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ad/06/eccbd311c9e2b3ca45dbc063b93134c57a1ccc7607c5e545264ad092c4a9/griffelib-2.0.0.tar.gz", hash = "sha256:e504d637a089f5cab9b5daf18f7645970509bf4f53eda8d79ed71cce8bd97934", size = 166312, upload-time = "2026-03-23T21:06:55.954Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/51/c936033e16d12b627ea334aaaaf42229c37620d0f15593456ab69ab48161/griffelib-2.0.0-py3-none-any.whl", hash = "sha256:01284878c966508b6d6f1dbff9b6fa607bc062d8261c5c7253cb285b06422a7f", size = 142004, upload-time = "2026-02-09T19:09:40.561Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/8d/e8b97e6bd3fb6fb271346f7981362f1e04d6a7463abd0de79e1fda17c067/identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980", size = 99360, upload-time = "2026-01-12T18:58:58.201Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/58/40fbbcefeda82364720eba5cf2270f98496bdfa19ea75b4cccae79c698e6/identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0", size = 99202, upload-time = "2026-01-12T18:58:56.627Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "inflection"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/7e/691d061b7329bc8d54edbf0ec22fbfb2afe61facb681f9aaa9bff7a27d04/inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417", size = 15091, upload-time = "2020-08-22T08:16:29.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/91/aa6bde563e0085a02a435aa99b49ef75b0a4b062635e606dab23ce18d720/inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2", size = 9454, upload-time = "2020-08-22T08:16:27.816Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.7.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/24/5f3646ff414285e0f7708fa4e946b9bf538345a41d1c375c439467721a5e/librt-0.7.8.tar.gz", hash = "sha256:1a4ede613941d9c3470b0368be851df6bb78ab218635512d0370b27a277a0862", size = 148323, upload-time = "2026-01-14T12:56:16.876Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/a3/87ea9c1049f2c781177496ebee29430e4631f439b8553a4969c88747d5d8/librt-0.7.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3e9c11aa260c31493d4b3197d1e28dd07768594a4f92bec4506849d736248f", size = 56507, upload-time = "2026-01-14T12:54:54.156Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/4a/23bcef149f37f771ad30203d561fcfd45b02bc54947b91f7a9ac34815747/librt-0.7.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ddb52499d0b3ed4aa88746aaf6f36a08314677d5c346234c3987ddc506404eac", size = 58455, upload-time = "2026-01-14T12:54:55.978Z" },
+    { url = "https://files.pythonhosted.org/packages/22/6e/46eb9b85c1b9761e0f42b6e6311e1cc544843ac897457062b9d5d0b21df4/librt-0.7.8-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e9c0afebbe6ce177ae8edba0c7c4d626f2a0fc12c33bb993d163817c41a7a05c", size = 164956, upload-time = "2026-01-14T12:54:57.311Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/3f/aa7c7f6829fb83989feb7ba9aa11c662b34b4bd4bd5b262f2876ba3db58d/librt-0.7.8-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:631599598e2c76ded400c0a8722dec09217c89ff64dc54b060f598ed68e7d2a8", size = 174364, upload-time = "2026-01-14T12:54:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/2d/d57d154b40b11f2cb851c4df0d4c4456bacd9b1ccc4ecb593ddec56c1a8b/librt-0.7.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c1ba843ae20db09b9d5c80475376168feb2640ce91cd9906414f23cc267a1ff", size = 188034, upload-time = "2026-01-14T12:55:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f9/36c4dad00925c16cd69d744b87f7001792691857d3b79187e7a673e812fb/librt-0.7.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b5b007bb22ea4b255d3ee39dfd06d12534de2fcc3438567d9f48cdaf67ae1ae3", size = 186295, upload-time = "2026-01-14T12:55:01.303Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9b/8a9889d3df5efb67695a67785028ccd58e661c3018237b73ad081691d0cb/librt-0.7.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:dbd79caaf77a3f590cbe32dc2447f718772d6eea59656a7dcb9311161b10fa75", size = 181470, upload-time = "2026-01-14T12:55:02.492Z" },
+    { url = "https://files.pythonhosted.org/packages/43/64/54d6ef11afca01fef8af78c230726a9394759f2addfbf7afc5e3cc032a45/librt-0.7.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:87808a8d1e0bd62a01cafc41f0fd6818b5a5d0ca0d8a55326a81643cdda8f873", size = 201713, upload-time = "2026-01-14T12:55:03.919Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/29/73e7ed2991330b28919387656f54109139b49e19cd72902f466bd44415fd/librt-0.7.8-cp311-cp311-win32.whl", hash = "sha256:31724b93baa91512bd0a376e7cf0b59d8b631ee17923b1218a65456fa9bda2e7", size = 43803, upload-time = "2026-01-14T12:55:04.996Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/de/66766ff48ed02b4d78deea30392ae200bcbd99ae61ba2418b49fd50a4831/librt-0.7.8-cp311-cp311-win_amd64.whl", hash = "sha256:978e8b5f13e52cf23a9e80f3286d7546baa70bc4ef35b51d97a709d0b28e537c", size = 50080, upload-time = "2026-01-14T12:55:06.489Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e3/33450438ff3a8c581d4ed7f798a70b07c3206d298cf0b87d3806e72e3ed8/librt-0.7.8-cp311-cp311-win_arm64.whl", hash = "sha256:20e3946863d872f7cabf7f77c6c9d370b8b3d74333d3a32471c50d3a86c0a232", size = 43383, upload-time = "2026-01-14T12:55:07.49Z" },
+    { url = "https://files.pythonhosted.org/packages/56/04/79d8fcb43cae376c7adbab7b2b9f65e48432c9eced62ac96703bcc16e09b/librt-0.7.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9b6943885b2d49c48d0cff23b16be830ba46b0152d98f62de49e735c6e655a63", size = 57472, upload-time = "2026-01-14T12:55:08.528Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ba/60b96e93043d3d659da91752689023a73981336446ae82078cddf706249e/librt-0.7.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46ef1f4b9b6cc364b11eea0ecc0897314447a66029ee1e55859acb3dd8757c93", size = 58986, upload-time = "2026-01-14T12:55:09.466Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/26/5215e4cdcc26e7be7eee21955a7e13cbf1f6d7d7311461a6014544596fac/librt-0.7.8-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:907ad09cfab21e3c86e8f1f87858f7049d1097f77196959c033612f532b4e592", size = 168422, upload-time = "2026-01-14T12:55:10.499Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/84/e8d1bc86fa0159bfc24f3d798d92cafd3897e84c7fea7fe61b3220915d76/librt-0.7.8-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2991b6c3775383752b3ca0204842743256f3ad3deeb1d0adc227d56b78a9a850", size = 177478, upload-time = "2026-01-14T12:55:11.577Z" },
+    { url = "https://files.pythonhosted.org/packages/57/11/d0268c4b94717a18aa91df1100e767b010f87b7ae444dafaa5a2d80f33a6/librt-0.7.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03679b9856932b8c8f674e87aa3c55ea11c9274301f76ae8dc4d281bda55cf62", size = 192439, upload-time = "2026-01-14T12:55:12.7Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/56/1e8e833b95fe684f80f8894ae4d8b7d36acc9203e60478fcae599120a975/librt-0.7.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3968762fec1b2ad34ce57458b6de25dbb4142713e9ca6279a0d352fa4e9f452b", size = 191483, upload-time = "2026-01-14T12:55:13.838Z" },
+    { url = "https://files.pythonhosted.org/packages/17/48/f11cf28a2cb6c31f282009e2208312aa84a5ee2732859f7856ee306176d5/librt-0.7.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bb7a7807523a31f03061288cc4ffc065d684c39db7644c676b47d89553c0d714", size = 185376, upload-time = "2026-01-14T12:55:15.017Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/6a/d7c116c6da561b9155b184354a60a3d5cdbf08fc7f3678d09c95679d13d9/librt-0.7.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad64a14b1e56e702e19b24aae108f18ad1bf7777f3af5fcd39f87d0c5a814449", size = 206234, upload-time = "2026-01-14T12:55:16.571Z" },
+    { url = "https://files.pythonhosted.org/packages/61/de/1975200bb0285fc921c5981d9978ce6ce11ae6d797df815add94a5a848a3/librt-0.7.8-cp312-cp312-win32.whl", hash = "sha256:0241a6ed65e6666236ea78203a73d800dbed896cf12ae25d026d75dc1fcd1dac", size = 44057, upload-time = "2026-01-14T12:55:18.077Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/cd/724f2d0b3461426730d4877754b65d39f06a41ac9d0a92d5c6840f72b9ae/librt-0.7.8-cp312-cp312-win_amd64.whl", hash = "sha256:6db5faf064b5bab9675c32a873436b31e01d66ca6984c6f7f92621656033a708", size = 50293, upload-time = "2026-01-14T12:55:19.179Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cf/7e899acd9ee5727ad8160fdcc9994954e79fab371c66535c60e13b968ffc/librt-0.7.8-cp312-cp312-win_arm64.whl", hash = "sha256:57175aa93f804d2c08d2edb7213e09276bd49097611aefc37e3fa38d1fb99ad0", size = 43574, upload-time = "2026-01-14T12:55:20.185Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fe/b1f9de2829cf7fc7649c1dcd202cfd873837c5cc2fc9e526b0e7f716c3d2/librt-0.7.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4c3995abbbb60b3c129490fa985dfe6cac11d88fc3c36eeb4fb1449efbbb04fc", size = 57500, upload-time = "2026-01-14T12:55:21.219Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/d4/4a60fbe2e53b825f5d9a77325071d61cd8af8506255067bf0c8527530745/librt-0.7.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:44e0c2cbc9bebd074cf2cdbe472ca185e824be4e74b1c63a8e934cea674bebf2", size = 59019, upload-time = "2026-01-14T12:55:22.256Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/37/61ff80341ba5159afa524445f2d984c30e2821f31f7c73cf166dcafa5564/librt-0.7.8-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4d2f1e492cae964b3463a03dc77a7fe8742f7855d7258c7643f0ee32b6651dd3", size = 169015, upload-time = "2026-01-14T12:55:23.24Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/86/13d4f2d6a93f181ebf2fc953868826653ede494559da8268023fe567fca3/librt-0.7.8-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:451e7ffcef8f785831fdb791bd69211f47e95dc4c6ddff68e589058806f044c6", size = 178161, upload-time = "2026-01-14T12:55:24.826Z" },
+    { url = "https://files.pythonhosted.org/packages/88/26/e24ef01305954fc4d771f1f09f3dd682f9eb610e1bec188ffb719374d26e/librt-0.7.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3469e1af9f1380e093ae06bedcbdd11e407ac0b303a56bbe9afb1d6824d4982d", size = 193015, upload-time = "2026-01-14T12:55:26.04Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a0/92b6bd060e720d7a31ed474d046a69bd55334ec05e9c446d228c4b806ae3/librt-0.7.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f11b300027ce19a34f6d24ebb0a25fd0e24a9d53353225a5c1e6cadbf2916b2e", size = 192038, upload-time = "2026-01-14T12:55:27.208Z" },
+    { url = "https://files.pythonhosted.org/packages/06/bb/6f4c650253704279c3a214dad188101d1b5ea23be0606628bc6739456624/librt-0.7.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4adc73614f0d3c97874f02f2c7fd2a27854e7e24ad532ea6b965459c5b757eca", size = 186006, upload-time = "2026-01-14T12:55:28.594Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/00/1c409618248d43240cadf45f3efb866837fa77e9a12a71481912135eb481/librt-0.7.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:60c299e555f87e4c01b2eca085dfccda1dde87f5a604bb45c2906b8305819a93", size = 206888, upload-time = "2026-01-14T12:55:30.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/83/b2cfe8e76ff5c1c77f8a53da3d5de62d04b5ebf7cf913e37f8bca43b5d07/librt-0.7.8-cp313-cp313-win32.whl", hash = "sha256:b09c52ed43a461994716082ee7d87618096851319bf695d57ec123f2ab708951", size = 44126, upload-time = "2026-01-14T12:55:31.44Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/0b/c59d45de56a51bd2d3a401fc63449c0ac163e4ef7f523ea8b0c0dee86ec5/librt-0.7.8-cp313-cp313-win_amd64.whl", hash = "sha256:f8f4a901a3fa28969d6e4519deceab56c55a09d691ea7b12ca830e2fa3461e34", size = 50262, upload-time = "2026-01-14T12:55:33.01Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b9/973455cec0a1ec592395250c474164c4a58ebf3e0651ee920fef1a2623f1/librt-0.7.8-cp313-cp313-win_arm64.whl", hash = "sha256:43d4e71b50763fcdcf64725ac680d8cfa1706c928b844794a7aa0fa9ac8e5f09", size = 43600, upload-time = "2026-01-14T12:55:34.054Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/73/fa8814c6ce2d49c3827829cadaa1589b0bf4391660bd4510899393a23ebc/librt-0.7.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:be927c3c94c74b05128089a955fba86501c3b544d1d300282cc1b4bd370cb418", size = 57049, upload-time = "2026-01-14T12:55:35.056Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fe/f6c70956da23ea235fd2e3cc16f4f0b4ebdfd72252b02d1164dd58b4e6c3/librt-0.7.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7b0803e9008c62a7ef79058233db7ff6f37a9933b8f2573c05b07ddafa226611", size = 58689, upload-time = "2026-01-14T12:55:36.078Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4d/7a2481444ac5fba63050d9abe823e6bc16896f575bfc9c1e5068d516cdce/librt-0.7.8-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:79feb4d00b2a4e0e05c9c56df707934f41fcb5fe53fd9efb7549068d0495b758", size = 166808, upload-time = "2026-01-14T12:55:37.595Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/3c/10901d9e18639f8953f57c8986796cfbf4c1c514844a41c9197cf87cb707/librt-0.7.8-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9122094e3f24aa759c38f46bd8863433820654927370250f460ae75488b66ea", size = 175614, upload-time = "2026-01-14T12:55:38.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/01/5cbdde0951a5090a80e5ba44e6357d375048123c572a23eecfb9326993a7/librt-0.7.8-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e03bea66af33c95ce3addf87a9bf1fcad8d33e757bc479957ddbc0e4f7207ac", size = 189955, upload-time = "2026-01-14T12:55:39.939Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b4/e80528d2f4b7eaf1d437fcbd6fc6ba4cbeb3e2a0cb9ed5a79f47c7318706/librt-0.7.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1ade7f31675db00b514b98f9ab9a7698c7282dad4be7492589109471852d398", size = 189370, upload-time = "2026-01-14T12:55:41.057Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/938368f8ce31a9787ecd4becb1e795954782e4312095daf8fd22420227c8/librt-0.7.8-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a14229ac62adcf1b90a15992f1ab9c69ae8b99ffb23cb64a90878a6e8a2f5b81", size = 183224, upload-time = "2026-01-14T12:55:42.328Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/10/559c310e7a6e4014ac44867d359ef8238465fb499e7eb31b6bfe3e3f86f5/librt-0.7.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5bcaaf624fd24e6a0cb14beac37677f90793a96864c67c064a91458611446e83", size = 203541, upload-time = "2026-01-14T12:55:43.501Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/db/a0db7acdb6290c215f343835c6efda5b491bb05c3ddc675af558f50fdba3/librt-0.7.8-cp314-cp314-win32.whl", hash = "sha256:7aa7d5457b6c542ecaed79cec4ad98534373c9757383973e638ccced0f11f46d", size = 40657, upload-time = "2026-01-14T12:55:44.668Z" },
+    { url = "https://files.pythonhosted.org/packages/72/e0/4f9bdc2a98a798511e81edcd6b54fe82767a715e05d1921115ac70717f6f/librt-0.7.8-cp314-cp314-win_amd64.whl", hash = "sha256:3d1322800771bee4a91f3b4bd4e49abc7d35e65166821086e5afd1e6c0d9be44", size = 46835, upload-time = "2026-01-14T12:55:45.655Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3d/59c6402e3dec2719655a41ad027a7371f8e2334aa794ed11533ad5f34969/librt-0.7.8-cp314-cp314-win_arm64.whl", hash = "sha256:5363427bc6a8c3b1719f8f3845ea53553d301382928a86e8fab7984426949bce", size = 39885, upload-time = "2026-01-14T12:55:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/9c/2481d80950b83085fb14ba3c595db56330d21bbc7d88a19f20165f3538db/librt-0.7.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ca916919793a77e4a98d4a1701e345d337ce53be4a16620f063191f7322ac80f", size = 59161, upload-time = "2026-01-14T12:55:48.45Z" },
+    { url = "https://files.pythonhosted.org/packages/96/79/108df2cfc4e672336765d54e3ff887294c1cc36ea4335c73588875775527/librt-0.7.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:54feb7b4f2f6706bb82325e836a01be805770443e2400f706e824e91f6441dde", size = 61008, upload-time = "2026-01-14T12:55:49.527Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f2/30179898f9994a5637459d6e169b6abdc982012c0a4b2d4c26f50c06f911/librt-0.7.8-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:39a4c76fee41007070f872b648cc2f711f9abf9a13d0c7162478043377b52c8e", size = 187199, upload-time = "2026-01-14T12:55:50.587Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/da/f7563db55cebdc884f518ba3791ad033becc25ff68eb70902b1747dc0d70/librt-0.7.8-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac9c8a458245c7de80bc1b9765b177055efff5803f08e548dd4bb9ab9a8d789b", size = 198317, upload-time = "2026-01-14T12:55:51.991Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/6c/4289acf076ad371471fa86718c30ae353e690d3de6167f7db36f429272f1/librt-0.7.8-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b67aa7eff150f075fda09d11f6bfb26edffd300f6ab1666759547581e8f666", size = 210334, upload-time = "2026-01-14T12:55:53.682Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/7f/377521ac25b78ac0a5ff44127a0360ee6d5ddd3ce7327949876a30533daa/librt-0.7.8-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:535929b6eff670c593c34ff435d5440c3096f20fa72d63444608a5aef64dd581", size = 211031, upload-time = "2026-01-14T12:55:54.827Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b1/e1e96c3e20b23d00cf90f4aad48f0deb4cdfec2f0ed8380d0d85acf98bbf/librt-0.7.8-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:63937bd0f4d1cb56653dc7ae900d6c52c41f0015e25aaf9902481ee79943b33a", size = 204581, upload-time = "2026-01-14T12:55:56.811Z" },
+    { url = "https://files.pythonhosted.org/packages/43/71/0f5d010e92ed9747e14bef35e91b6580533510f1e36a8a09eb79ee70b2f0/librt-0.7.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf243da9e42d914036fd362ac3fa77d80a41cadcd11ad789b1b5eec4daaf67ca", size = 224731, upload-time = "2026-01-14T12:55:58.175Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f0/07fb6ab5c39a4ca9af3e37554f9d42f25c464829254d72e4ebbd81da351c/librt-0.7.8-cp314-cp314t-win32.whl", hash = "sha256:171ca3a0a06c643bd0a2f62a8944e1902c94aa8e5da4db1ea9a8daf872685365", size = 41173, upload-time = "2026-01-14T12:55:59.315Z" },
+    { url = "https://files.pythonhosted.org/packages/24/d4/7e4be20993dc6a782639625bd2f97f3c66125c7aa80c82426956811cfccf/librt-0.7.8-cp314-cp314t-win_amd64.whl", hash = "sha256:445b7304145e24c60288a2f172b5ce2ca35c0f81605f5299f3fa567e189d2e32", size = 47668, upload-time = "2026-01-14T12:56:00.261Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+]
+
+[[package]]
+name = "markdownify"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3f/bc/c8c8eea5335341306b0fa7e1cb33c5e1c8d24ef70ddd684da65f41c49c92/markdownify-1.2.2.tar.gz", hash = "sha256:b274f1b5943180b031b699b199cbaeb1e2ac938b75851849a31fd0c3d6603d09", size = 18816, upload-time = "2025-11-16T19:21:18.565Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/ce/f1e3e9d959db134cedf06825fae8d5b294bd368aacdd0831a3975b7c4d55/markdownify-1.2.2-py3-none-any.whl", hash = "sha256:3f02d3cc52714084d6e589f70397b6fc9f2f3a8531481bf35e8cc39f975e186a", size = 15724, upload-time = "2025-11-16T19:21:17.622Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "mdformat"
+version = "0.7.22"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/eb/b5cbf2484411af039a3d4aeb53a5160fae25dd8c84af6a4243bc2f3fedb3/mdformat-0.7.22.tar.gz", hash = "sha256:eef84fa8f233d3162734683c2a8a6222227a229b9206872e6139658d99acb1ea", size = 34610, upload-time = "2025-01-30T18:00:51.418Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/6f/94a7344f6d634fe3563bea8b33bccedee37f2726f7807e9a58440dc91627/mdformat-0.7.22-py3-none-any.whl", hash = "sha256:61122637c9e1d9be1329054f3fa216559f0d1f722b7919b060a8c2a4ae1850e5", size = 34447, upload-time = "2025-01-30T18:00:48.708Z" },
+]
+
+[[package]]
+name = "mdformat-tables"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdformat" },
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/64/fc/995ba209096bdebdeb8893d507c7b32b7e07d9a9f2cdc2ec07529947794b/mdformat_tables-1.0.0.tar.gz", hash = "sha256:a57db1ac17c4a125da794ef45539904bb8a9592e80557d525e1f169c96daa2c8", size = 6106, upload-time = "2024-08-23T23:41:33.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/37/d78e37d14323da3f607cd1af7daf262cb87fe614a245c15ad03bb03a2706/mdformat_tables-1.0.0-py3-none-any.whl", hash = "sha256:94cd86126141b2adc3b04c08d1441eb1272b36c39146bab078249a41c7240a9a", size = 5104, upload-time = "2024-08-23T23:41:31.863Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mergedeep"
+version = "1.3.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
+]
+
+[[package]]
+name = "mermaid-builder"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/57/d83e7e62de05adbba2476b7596ed4a253907a4f4c19be74c40e7ce2944dc/mermaid_builder-0.0.3.tar.gz", hash = "sha256:3016ef25668bcb28de4a4746aabdfaa531c06a7e7f89fa1596e6a274c7c73705", size = 7183, upload-time = "2024-06-14T17:14:51.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/7480454b7ee7de5c2c8561e83b4564196ecf1c9847e893dfbb51032e5a3b/mermaid_builder-0.0.3-py3-none-any.whl", hash = "sha256:decd7d25268bda7a520ce0cab7873e50fac1e33b41e5a1dd7daec5c0ae3c7ffb", size = 6696, upload-time = "2024-06-14T17:14:38.48Z" },
+]
+
+[[package]]
+name = "mkdocs"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "ghp-import" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mergedeep" },
+    { name = "mkdocs-get-deps" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
+]
+
+[[package]]
+name = "mkdocs-autorefs"
+version = "1.4.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/51/fa/9124cd63d822e2bcbea1450ae68cdc3faf3655c69b455f3a7ed36ce6c628/mkdocs_autorefs-1.4.3.tar.gz", hash = "sha256:beee715b254455c4aa93b6ef3c67579c399ca092259cc41b7d9342573ff1fc75", size = 55425, upload-time = "2025-08-26T14:23:17.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/4d/7123b6fa2278000688ebd338e2a06d16870aaf9eceae6ba047ea05f92df1/mkdocs_autorefs-1.4.3-py3-none-any.whl", hash = "sha256:469d85eb3114801d08e9cc55d102b3ba65917a869b893403b8987b601cf55dc9", size = 25034, upload-time = "2025-08-26T14:23:15.906Z" },
+]
+
+[[package]]
+name = "mkdocs-click"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "markdown" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/c7/8c25f3a3b379def41e6d0bb5c4beeab7aa8a394b17e749f498504102cfa5/mkdocs_click-0.9.0.tar.gz", hash = "sha256:6050917628d4740517541422b607404d044117bc31b770c4f9e9e1939a50c908", size = 18720, upload-time = "2025-04-07T16:59:36.387Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/fc/9124ab36e2341e78d8d9c669511bd70f52ea0de8105760c31fabec1f9396/mkdocs_click-0.9.0-py3-none-any.whl", hash = "sha256:5208e828f4f68f63c847c1ef7be48edee9964090390afc8f5b3d4cbe5ea9bbed", size = 15104, upload-time = "2025-04-07T16:59:34.807Z" },
+]
+
+[[package]]
+name = "mkdocs-get-deps"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mergedeep" },
+    { name = "platformdirs" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239, upload-time = "2023-11-20T17:51:09.981Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521, upload-time = "2023-11-20T17:51:08.587Z" },
+]
+
+[[package]]
+name = "mkdocs-llmstxt"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "markdownify" },
+    { name = "mdformat" },
+    { name = "mdformat-tables" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7f/f5/4c31cdffa7c09bf48d8c7a50d8342dc100abac98ac4150826bc11afc0c9f/mkdocs_llmstxt-0.5.0.tar.gz", hash = "sha256:b2fa9e6d68df41d7467e948a4745725b6c99434a36b36204857dbd7bb3dfe041", size = 33909, upload-time = "2025-11-20T14:02:24.861Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/2b/82928cc9e8d9269cd79e7ebf015efdc4945e6c646e86ec1d4dba1707f215/mkdocs_llmstxt-0.5.0-py3-none-any.whl", hash = "sha256:753c699913d2d619a9072604b26b6dc9f5fb6d257d9b107857f80c8a0b787533", size = 12040, upload-time = "2025-11-20T14:02:23.483Z" },
+]
+
+[[package]]
+name = "mkdocs-material"
+version = "9.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "backrefs" },
+    { name = "colorama" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material-extensions" },
+    { name = "paginate" },
+    { name = "pygments" },
+    { name = "pymdown-extensions" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/27/e2/2ffc356cd72f1473d07c7719d82a8f2cbd261666828614ecb95b12169f41/mkdocs_material-9.7.1.tar.gz", hash = "sha256:89601b8f2c3e6c6ee0a918cc3566cb201d40bf37c3cd3c2067e26fadb8cce2b8", size = 4094392, upload-time = "2025-12-18T09:49:00.308Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/32/ed071cb721aca8c227718cffcf7bd539620e9799bbf2619e90c757bfd030/mkdocs_material-9.7.1-py3-none-any.whl", hash = "sha256:3f6100937d7d731f87f1e3e3b021c97f7239666b9ba1151ab476cabb96c60d5c", size = 9297166, upload-time = "2025-12-18T09:48:56.664Z" },
+]
+
+[package.optional-dependencies]
+imaging = [
+    { name = "cairosvg" },
+    { name = "pillow" },
+]
+
+[[package]]
+name = "mkdocs-material-extensions"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
+]
+
+[[package]]
+name = "mkdocs-open-in-new-tab"
+version = "1.0.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0a/0e/f72a506a21bdb27b807124e00c688226848a388d1fd3980b80ae3cc27203/mkdocs_open_in_new_tab-1.0.8.tar.gz", hash = "sha256:3e0dad08cc9938b0b13097be8e0aa435919de1eeb2d1a648e66b5dee8d57e048", size = 5791, upload-time = "2024-11-18T13:15:13.977Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/94/44f3c868495481c868d08eea065c82803f1affd8553d3383b782f497613c/mkdocs_open_in_new_tab-1.0.8-py3-none-any.whl", hash = "sha256:051d767a4467b12d89827e1fea0ec660b05b027c726317fe4fceee5456e36ad2", size = 7717, upload-time = "2024-11-18T13:15:12.286Z" },
+]
+
+[[package]]
+name = "mkdocs-simple-hooks"
+version = "0.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/93/565f98d6810e3b493e61160aea1cceb8653331576e7fa7f048ac7e7cdf62/mkdocs-simple-hooks-0.1.5.tar.gz", hash = "sha256:dddbdf151a18723c9302a133e5cf79538be8eb9d274e8e07d2ac3ac34890837c", size = 4037, upload-time = "2022-01-07T09:11:18.345Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/e9/7bf0f928f5b6cdd602d4a01d52e5fc1eba8d3ba6d97619a88fc271a625f8/mkdocs_simple_hooks-0.1.5-py3-none-any.whl", hash = "sha256:efeabdbb98b0850a909adee285f3404535117159d5cb3a34f541d6eaa644d50a", size = 4596, upload-time = "2022-01-07T09:11:17.022Z" },
+]
+
+[[package]]
+name = "mkdocstrings"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+    { name = "mkdocs-autorefs" },
+    { name = "pymdown-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/62/0dfc5719514115bf1781f44b1d7f2a0923fcc01e9c5d7990e48a05c9ae5d/mkdocstrings-1.0.3.tar.gz", hash = "sha256:ab670f55040722b49bb45865b2e93b824450fb4aef638b00d7acb493a9020434", size = 100946, upload-time = "2026-02-07T14:31:40.973Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/41/1cf02e3df279d2dd846a1bf235a928254eba9006dd22b4a14caa71aed0f7/mkdocstrings-1.0.3-py3-none-any.whl", hash = "sha256:0d66d18430c2201dc7fe85134277382baaa15e6b30979f3f3bdbabd6dbdb6046", size = 35523, upload-time = "2026-02-07T14:31:39.27Z" },
+]
+
+[package.optional-dependencies]
+python = [
+    { name = "mkdocstrings-python" },
+]
+
+[[package]]
+name = "mkdocstrings-python"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffe" },
+    { name = "mkdocs-autorefs" },
+    { name = "mkdocstrings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/84/78243847ad9d5c21d30a2842720425b17e880d99dfe824dee11d6b2149b4/mkdocstrings_python-2.0.2.tar.gz", hash = "sha256:4a32ccfc4b8d29639864698e81cfeb04137bce76bb9f3c251040f55d4b6e1ad8", size = 199124, upload-time = "2026-02-09T15:12:01.543Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/31/7ee938abbde2322e553a2cb5f604cdd1e4728e08bba39c7ee6fae9af840b/mkdocstrings_python-2.0.2-py3-none-any.whl", hash = "sha256:31241c0f43d85a69306d704d5725786015510ea3f3c4bdfdb5a5731d83cdc2b0", size = 104900, upload-time = "2026-02-09T15:12:00.166Z" },
+]
+
+[[package]]
+name = "mockito"
+version = "1.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/71/12c56464071524a7941744e8b8fb02c6614500d27475c2d643d2e780a4b0/mockito-1.5.5.tar.gz", hash = "sha256:49826e3901dc826d0204e93b16dce1c61dde9d3a94eadc9c209ab0e130283393", size = 60707, upload-time = "2025-11-17T11:28:41.21Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/f0/fc3475ef7732d080c6a555e4ce12e606c699e82e220eb4bcafb9e801fc07/mockito-1.5.5-py3-none-any.whl", hash = "sha256:422a6ce2666e3c32d756547b98ee67e83a339f457e132476689643015845fc36", size = 30456, upload-time = "2025-11-17T11:28:40.371Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" },
+    { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" },
+    { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" },
+    { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
+    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
+    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
+    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/0f/7e6b713ac117c1f5e4e3300748af699b9902a2e5e34c9cf443dde25a01fa/opentelemetry_instrumentation-0.60b1.tar.gz", hash = "sha256:57ddc7974c6eb35865af0426d1a17132b88b2ed8586897fee187fd5b8944bd6a", size = 31706, upload-time = "2025-12-11T13:36:42.515Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/d2/6788e83c5c86a2690101681aeef27eeb2a6bf22df52d3f263a22cee20915/opentelemetry_instrumentation-0.60b1-py3-none-any.whl", hash = "sha256:04480db952b48fb1ed0073f822f0ee26012b7be7c3eac1a3793122737c78632d", size = 33096, upload-time = "2025-12-11T13:35:33.067Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
+]
+
+[[package]]
+name = "outcome"
+version = "1.3.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060, upload-time = "2023-10-26T04:26:04.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692, upload-time = "2023-10-26T04:26:02.532Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "paginate"
+version = "0.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
+]
+
+[[package]]
+name = "pathlib"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298, upload-time = "2014-09-03T15:41:57.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363, upload-time = "2022-05-04T13:37:20.585Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "11.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload-time = "2025-07-01T09:13:59.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload-time = "2025-07-01T09:14:01.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload-time = "2025-07-03T13:09:55.638Z" },
+    { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload-time = "2025-07-03T13:10:00.37Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload-time = "2025-07-01T09:14:04.491Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload-time = "2025-07-01T09:14:06.235Z" },
+    { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload-time = "2025-07-01T09:14:07.978Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516, upload-time = "2025-07-01T09:14:10.233Z" },
+    { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768, upload-time = "2025-07-01T09:14:11.921Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055, upload-time = "2025-07-01T09:14:13.623Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload-time = "2025-07-01T09:14:15.268Z" },
+    { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" },
+    { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" },
+    { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" },
+    { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload-time = "2025-07-01T09:14:35.276Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload-time = "2025-07-01T09:14:37.203Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" },
+    { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" },
+    { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload-time = "2025-07-01T09:14:51.962Z" },
+    { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload-time = "2025-07-01T09:14:54.142Z" },
+    { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload-time = "2025-07-01T09:14:56.436Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" },
+    { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" },
+    { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload-time = "2025-07-01T09:15:09.317Z" },
+    { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload-time = "2025-07-01T09:15:11.311Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload-time = "2025-07-01T09:15:13.164Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload-time = "2025-07-01T09:15:17.429Z" },
+    { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload-time = "2025-07-01T09:15:19.423Z" },
+    { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload-time = "2025-07-03T13:10:38.404Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload-time = "2025-07-03T13:10:44.987Z" },
+    { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload-time = "2025-07-01T09:15:21.237Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload-time = "2025-07-01T09:15:23.186Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload-time = "2025-07-01T09:15:25.1Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload-time = "2025-07-01T09:15:27.378Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload-time = "2025-07-01T09:15:29.294Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload-time = "2025-07-01T09:15:31.128Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload-time = "2025-07-01T09:15:33.328Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload-time = "2025-07-01T09:15:35.194Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload-time = "2025-07-01T09:15:37.114Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload-time = "2025-07-03T13:10:50.248Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload-time = "2025-07-03T13:10:56.432Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload-time = "2025-07-01T09:15:39.436Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload-time = "2025-07-01T09:15:41.269Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload-time = "2025-07-01T09:15:43.13Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload-time = "2025-07-01T09:15:44.937Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload-time = "2025-07-01T09:15:46.673Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload-time = "2025-07-01T09:15:48.512Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload-time = "2025-07-01T09:16:19.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload-time = "2025-07-01T09:16:21.818Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload-time = "2025-07-03T13:11:20.738Z" },
+    { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload-time = "2025-07-03T13:11:26.283Z" },
+    { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload-time = "2025-07-01T09:16:23.762Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload-time = "2025-07-01T09:16:25.593Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-function-models"
+version = "0.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/9f/9f89602abf782693974d1812657b7b0bab346c011f31d7a05ca71f5643e2/pydantic_function_models-0.1.11.tar.gz", hash = "sha256:28292961bc71f9e4d75ae608ef1cf820ce650ba019067776ee82c6612ccf1cca", size = 9018, upload-time = "2025-11-29T20:16:39.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cd8bd73e893604e335f4347539851a8f8dede32fbf6d7a009f564c2c6681/pydantic_function_models-0.1.11-py3-none-any.whl", hash = "sha256:1c17d45f7b7b95ad1644226a9b8d6d05ce1565a0d0bbe03f4ec86e21487aff2b", size = 8028, upload-time = "2025-11-29T20:16:38.391Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/5a/b46fa56bf322901eee5b0454a34343cdbdae202cd421775a8ee4e42fd519/pyjwt-2.11.0.tar.gz", hash = "sha256:35f95c1f0fbe5d5ba6e43f00271c275f7a1a4db1dab27bf708073b75318ea623", size = 98019, upload-time = "2026-01-30T19:59:55.694Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/01/c26ce75ba460d5cd503da9e13b21a33804d38c2165dec7b716d06b13010c/pyjwt-2.11.0-py3-none-any.whl", hash = "sha256:94a6bde30eb5c8e04fee991062b534071fd1439ef58d2adc9ccb823e7bcd0469", size = 28224, upload-time = "2026-01-30T19:59:54.539Z" },
+]
+
+[[package]]
+name = "pymdown-extensions"
+version = "10.20.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1e/6c/9e370934bfa30e889d12e61d0dae009991294f40055c238980066a7fbd83/pymdown_extensions-10.20.1.tar.gz", hash = "sha256:e7e39c865727338d434b55f1dd8da51febcffcaebd6e1a0b9c836243f660740a", size = 852860, upload-time = "2026-01-24T05:56:56.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/6d/b6ee155462a0156b94312bdd82d2b92ea56e909740045a87ccb98bf52405/pymdown_extensions-10.20.1-py3-none-any.whl", hash = "sha256:24af7feacbca56504b313b7b418c4f5e1317bb5fea60f03d57be7fcc40912aa0", size = 268768, upload-time = "2026-01-24T05:56:54.537Z" },
+]
+
+[[package]]
+name = "pysignalr"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "msgpack" },
+    { name = "orjson" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/a6/ac80bd4972604c6930050e8b0eba41d6fde41cb3286087be0188a8865f55/pysignalr-1.3.0.tar.gz", hash = "sha256:ca2e4372f213d82148fa2f060f0fefd096f1f66fca1107ac05e76ec6abd4cf52", size = 16790, upload-time = "2025-04-29T21:23:38.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/54/74e35563927ab8538e1bd1404b35027861434aecf2bcc945ff30c188e56d/pysignalr-1.3.0-py3-none-any.whl", hash = "sha256:423c91b0d1dc8387f37118ac2d1dc87ed6b9e01993a04612eab8452193f40344", size = 19966, upload-time = "2025-04-29T21:23:37.513Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
+[[package]]
+name = "pytest-httpx"
+version = "0.36.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/5574834da9499066fa1a5ea9c336f94dba2eae02298d36dab192fcf95c86/pytest_httpx-0.36.0.tar.gz", hash = "sha256:9edb66a5fd4388ce3c343189bc67e7e1cb50b07c2e3fc83b97d511975e8a831b", size = 56793, upload-time = "2025-12-02T16:34:57.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/d2/1eb1ea9c84f0d2033eb0b49675afdc71aa4ea801b74615f00f3c33b725e3/pytest_httpx-0.36.0-py3-none-any.whl", hash = "sha256:bd4c120bb80e142df856e825ec9f17981effb84d159f9fa29ed97e2357c3a9c8", size = 20229, upload-time = "2025-12-02T16:34:56.45Z" },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
+]
+
+[[package]]
+name = "pytest-timeout"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
+]
+
+[[package]]
+name = "pytest-trio"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "outcome" },
+    { name = "pytest" },
+    { name = "trio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/08/056279526554c6c6e6ad6d4a479a338d14dc785ac30be8bdc6ca0153c1be/pytest-trio-0.8.0.tar.gz", hash = "sha256:8363db6336a79e6c53375a2123a41ddbeccc4aa93f93788651641789a56fb52e", size = 46525, upload-time = "2022-11-01T17:24:29.352Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/22/71953f47e0da5852c899f58cd7a31e6100f37c632b7b9ee52d067613a844/pytest_trio-0.8.0-py3-none-any.whl", hash = "sha256:e6a7e7351ae3e8ec3f4564d30ee77d1ec66e1df611226e5618dbb32f9545c841", size = 27221, upload-time = "2022-11-01T17:24:27.501Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+]
+
+[[package]]
+name = "python-engineio"
+version = "4.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "simple-websocket" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/12/bdef9dbeedbe2cdeba2a2056ad27b1fb081557d34b69a97f574843462cae/python_engineio-4.13.1.tar.gz", hash = "sha256:0a853fcef52f5b345425d8c2b921ac85023a04dfcf75d7b74696c61e940fd066", size = 92348, upload-time = "2026-02-06T23:38:06.12Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/54/0cce26da03a981f949bb8449c9778537f75f5917c172e1d2992ff25cb57d/python_engineio-4.13.1-py3-none-any.whl", hash = "sha256:f32ad10589859c11053ad7d9bb3c9695cdf862113bfb0d20bc4d890198287399", size = 59847, upload-time = "2026-02-06T23:38:04.861Z" },
+]
+
+[[package]]
+name = "python-socketio"
+version = "5.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bidict" },
+    { name = "python-engineio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/81/cf8284f45e32efa18d3848ed82cdd4dcc1b657b082458fbe01ad3e1f2f8d/python_socketio-5.16.1.tar.gz", hash = "sha256:f863f98eacce81ceea2e742f6388e10ca3cdd0764be21d30d5196470edf5ea89", size = 128508, upload-time = "2026-02-06T23:42:07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c7/deb8c5e604404dbf10a3808a858946ca3547692ff6316b698945bb72177e/python_socketio-5.16.1-py3-none-any.whl", hash = "sha256:a3eb1702e92aa2f2b5d3ba00261b61f062cce51f1cfb6900bf3ab4d1934d2d35", size = 82054, upload-time = "2026-02-06T23:42:05.772Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "pyyaml-env-tag"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/99/a4cab2acbb884f80e558b0771e97e21e939c5dfb460f488d19df485e8298/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8", size = 230143, upload-time = "2026-02-01T16:20:47.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/39/5cee96809fbca590abea6b46c6d1c586b49663d1d2830a751cc8fc42c666/ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a", size = 4524893, upload-time = "2026-02-03T17:53:35.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/88/3fd1b0aa4b6330d6aaa63a285bc96c9f71970351579152d231ed90914586/ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455", size = 10354332, upload-time = "2026-02-03T17:52:54.892Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f6/62e173fbb7eb75cc29fe2576a1e20f0a46f671a2587b5f604bfb0eaf5f6f/ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d", size = 10767189, upload-time = "2026-02-03T17:53:19.778Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/968ae17b676d1d2ff101d56dc69cf333e3a4c985e1ec23803df84fc7bf9e/ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce", size = 10075384, upload-time = "2026-02-03T17:53:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/bf/9843c6044ab9e20af879c751487e61333ca79a2c8c3058b15722386b8cae/ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621", size = 10481363, upload-time = "2026-02-03T17:52:43.332Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d9/4ada5ccf4cd1f532db1c8d44b6f664f2208d3d93acbeec18f82315e15193/ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9", size = 10187736, upload-time = "2026-02-03T17:53:00.522Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e2/f25eaecd446af7bb132af0a1d5b135a62971a41f5366ff41d06d25e77a91/ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179", size = 10968415, upload-time = "2026-02-03T17:53:15.705Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/dc/f06a8558d06333bf79b497d29a50c3a673d9251214e0d7ec78f90b30aa79/ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d", size = 11809643, upload-time = "2026-02-03T17:53:23.031Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/45/0ece8db2c474ad7df13af3a6d50f76e22a09d078af63078f005057ca59eb/ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78", size = 11234787, upload-time = "2026-02-03T17:52:46.432Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/d9/0e3a81467a120fd265658d127db648e4d3acfe3e4f6f5d4ea79fac47e587/ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4", size = 11112797, upload-time = "2026-02-03T17:52:49.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cb/8c0b3b0c692683f8ff31351dfb6241047fa873a4481a76df4335a8bff716/ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e", size = 11033133, upload-time = "2026-02-03T17:53:33.105Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5e/23b87370cf0f9081a8c89a753e69a4e8778805b8802ccfe175cc410e50b9/ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662", size = 10442646, upload-time = "2026-02-03T17:53:06.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9a/3c94de5ce642830167e6d00b5c75aacd73e6347b4c7fc6828699b150a5ee/ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1", size = 10195750, upload-time = "2026-02-03T17:53:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/30/15/e396325080d600b436acc970848d69df9c13977942fb62bb8722d729bee8/ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16", size = 10676120, upload-time = "2026-02-03T17:53:09.363Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/229a23d52a2983de1ad0fb0ee37d36e0257e6f28bfd6b498ee2c76361874/ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3", size = 11201636, upload-time = "2026-02-03T17:52:57.281Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/b0/69adf22f4e24f3677208adb715c578266842e6e6a3cc77483f48dd999ede/ruff-0.15.0-py3-none-win32.whl", hash = "sha256:238a717ef803e501b6d51e0bdd0d2c6e8513fe9eec14002445134d3907cd46c3", size = 10465945, upload-time = "2026-02-03T17:53:12.591Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ad/f813b6e2c97e9b4598be25e94a9147b9af7e60523b0cb5d94d307c15229d/ruff-0.15.0-py3-none-win_amd64.whl", hash = "sha256:dd5e4d3301dc01de614da3cdffc33d4b1b96fb89e45721f1598e5532ccf78b18", size = 11564657, upload-time = "2026-02-03T17:52:51.893Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b0/2d823f6e77ebe560f4e397d078487e8d52c1516b331e3521bc75db4272ca/ruff-0.15.0-py3-none-win_arm64.whl", hash = "sha256:c480d632cc0ca3f0727acac8b7d053542d9e114a462a145d0b00e7cd658c515a", size = 10865753, upload-time = "2026-02-03T17:53:03.014Z" },
+]
+
+[[package]]
+name = "rust-just"
+version = "1.46.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/50/3828817f76e19977a4048c2c8b39a7f48babc21dd9dbed4af2f3c18d4570/rust_just-1.46.0.tar.gz", hash = "sha256:84437481c814577529835132e2cc5fcc35a981c1712e4877cb20fc2f5ec5b2d6", size = 1447346, upload-time = "2026-01-03T02:03:17.948Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/0b/a5bf2707b02a484d91f8275efa39f76fe19304f5bfba82293fa4b18608d2/rust_just-1.46.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7d6d4c67a443f1acb1f78f9ba4b3349fa04f17e8be2d4448b771cdc93a382812", size = 1739556, upload-time = "2026-01-03T02:02:42.835Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ae/40bcd996ccb2fcb0152b5bfde7beaf3840877a8837611421c495b45c82da/rust_just-1.46.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0caf9b77d30455558d017c9e625ce94c373f88d81656477127727604fa5d36ab", size = 1620974, upload-time = "2026-01-03T02:02:45.341Z" },
+    { url = "https://files.pythonhosted.org/packages/62/36/7067e0eaf674ed7c98b35ed50d713c0c885f2d2b57847a627e11502da1b8/rust_just-1.46.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b63521acd91c65164c202ded3ae730130c7fb4377f59cd2f9847b45161c94fd", size = 1703423, upload-time = "2026-01-03T02:02:47.681Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/47/3e98182f5e03c48880d647651385863552a3e24cfec5c51d116c06e6f180/rust_just-1.46.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46a35110c7acf27bdded79cf3bbfea9eb80a53f6f81f374248fe3340584c92e5", size = 1666645, upload-time = "2026-01-03T02:02:50.38Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5e/b9badf6e6982e5744f076d12ab911e5ac8b4b03a0674bab4f498ed9d0b4c/rust_just-1.46.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a2407cefc2e5ed4527297747bd5bcb61a885776021cb2438c3a7b118b2cabc2", size = 1847430, upload-time = "2026-01-03T02:02:52.716Z" },
+    { url = "https://files.pythonhosted.org/packages/98/10/6916d7c862b99de600a1fd3739d13353c220dfbc0229a0b2c5012c2f801d/rust_just-1.46.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0dab319619f600561b993242312a344953b1ea44637b30257af905a70ce6f568", size = 1926224, upload-time = "2026-01-03T02:02:55.194Z" },
+    { url = "https://files.pythonhosted.org/packages/24/93/18bc615e68a80f43105d5e7cc3571e85776aec829ac40faae4de5d5dc2f3/rust_just-1.46.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3b4c26dd86e5d96047fc0935967f22cb9f49c687767d78b7d3fe511eba39ffa", size = 1902165, upload-time = "2026-01-03T02:02:57.636Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/e3c19a24ff64e78a04df0bdf4c61e15c28dcac8b7b5c3a5505eb5749d40a/rust_just-1.46.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdb496ca26efc508be0e625309b74b1f6316b4f7295d13247c3b791dfa77eb1", size = 1835209, upload-time = "2026-01-03T02:03:00.256Z" },
+    { url = "https://files.pythonhosted.org/packages/26/75/0850c38e41025794826165329a097f657152902a785c0579f213b7d61ae6/rust_just-1.46.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3cf1c32a258f8ee44af877ec271e2eea257923a3303a6d2610b0b5f1523daaab", size = 1719519, upload-time = "2026-01-03T02:03:02.774Z" },
+    { url = "https://files.pythonhosted.org/packages/48/85/53c6ee2b9cdbbe1bd43cd0f8096036c29e9e6ba2d3d6344206c490e2ce18/rust_just-1.46.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:657ab85882c124b0fbcd75763035d0dbd20b06c582cc6d4f55017d7b517d5a89", size = 1685664, upload-time = "2026-01-03T02:03:05.514Z" },
+    { url = "https://files.pythonhosted.org/packages/33/04/1ad3a66bef0d0f554f0f9971b048bbaf7b3955458f3fda47b48fbf8ff009/rust_just-1.46.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:644b71bfe68863b71ee2618a88dbfd446ea70e2dcfa7b0e5eaec7b6dc4faceca", size = 1838231, upload-time = "2026-01-03T02:03:07.618Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/75/33c2e887a68e57b356cda74d325d6ebe406bb72ad8c4e2d067d4fa9b697b/rust_just-1.46.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e9d8a879fb86eb1c7f7f83953999ae4ce53ea4e5c0ca531cf6ff09e1e9335ff7", size = 1900319, upload-time = "2026-01-03T02:03:09.873Z" },
+    { url = "https://files.pythonhosted.org/packages/44/30/6b1677aa64a4f69f3ec174b5e2a9a49e0ffd06946d4b4dc8295366fbd9dd/rust_just-1.46.0-py3-none-win32.whl", hash = "sha256:100701de91bded3f6f2bf564d09c2f8e483b8dfb490d1c74008ce3c01ff0ff67", size = 1623463, upload-time = "2026-01-03T02:03:12.343Z" },
+    { url = "https://files.pythonhosted.org/packages/64/61/97ad7a1ea67b9485404b18150c258015842cf116a1ce626421863fd8f0e1/rust_just-1.46.0-py3-none-win_amd64.whl", hash = "sha256:ccaf8e473f64f5c815b0039e883a1feaf5634b9cdffd1dbff9e5fde77b5926f4", size = 1801103, upload-time = "2026-01-03T02:03:15.256Z" },
+]
+
+[[package]]
+name = "simple-websocket"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/59/0782e51887ac6b07ffd1570e0364cf901ebc36345fea669969d2084baebb/simple_websocket-1.1.0-py3-none-any.whl", hash = "sha256:4af6069630a38ed6c561010f0e11a5bc0d4ca569b36306eb257cd9a192497c8c", size = 13842, upload-time = "2024-10-10T22:39:29.645Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
+]
+
+[[package]]
+name = "stevedore"
+version = "5.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/5b/496f8abebd10c3301129abba7ddafd46c71d799a70c44ab080323987c4c9/stevedore-5.6.0.tar.gz", hash = "sha256:f22d15c6ead40c5bbfa9ca54aa7e7b4a07d59b36ae03ed12ced1a54cf0b51945", size = 516074, upload-time = "2025-11-20T10:06:07.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/40/8561ce06dc46fd17242c7724ab25b257a2ac1b35f4ebf551b40ce6105cfa/stevedore-5.6.0-py3-none-any.whl", hash = "sha256:4a36dccefd7aeea0c70135526cecb7766c4c84c473b1af68db23d541b6dc1820", size = 54428, upload-time = "2025-11-20T10:06:05.946Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "termynal"
+version = "0.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6c/a6/099ed030e3e534ec91aec84dfe2cb11cea6ec8dcbec454fe569cdbbb4888/termynal-0.13.1.tar.gz", hash = "sha256:c7abecfdbda3ccdeee2723049a70f0e2e7f63e1973bb9b8f0b3fe6c1bfb391cd", size = 174253, upload-time = "2025-09-01T13:03:35.02Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/72/6949a512f16653cecebb737b8512ee76ca078d8e0e4e948d7322b528fb4d/termynal-0.13.1-py3-none-any.whl", hash = "sha256:7a1605a4d4ed38bf851bf25f842aafa52ef29786d52762aecee59622ed030592", size = 10628, upload-time = "2025-09-01T13:03:34.236Z" },
+]
+
+[[package]]
+name = "tinycss2"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
+]
+
+[[package]]
+name = "tomli-w"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" },
+]
+
+[[package]]
+name = "trio"
+version = "0.32.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
+    { name = "idna" },
+    { name = "outcome" },
+    { name = "sniffio" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d8/ce/0041ddd9160aac0031bcf5ab786c7640d795c797e67c438e15cfedf815c8/trio-0.32.0.tar.gz", hash = "sha256:150f29ec923bcd51231e1d4c71c7006e65247d68759dd1c19af4ea815a25806b", size = 605323, upload-time = "2025-10-31T07:18:17.466Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/bf/945d527ff706233636c73880b22c7c953f3faeb9d6c7e2e85bfbfd0134a0/trio-0.32.0-py3-none-any.whl", hash = "sha256:4ab65984ef8370b79a76659ec87aa3a30c5c7c83ff250b4de88c29a8ab6123c5", size = 512030, upload-time = "2025-10-31T07:18:15.885Z" },
+]
+
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
+[[package]]
+name = "types-toml"
+version = "0.10.8.20240310"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/47/3e4c75042792bff8e90d7991aa5c51812cc668828cc6cce711e97f63a607/types-toml-0.10.8.20240310.tar.gz", hash = "sha256:3d41501302972436a6b8b239c850b26689657e25281b48ff0ec06345b8830331", size = 4392, upload-time = "2024-03-10T02:18:37.518Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/a2/d32ab58c0b216912638b140ab2170ee4b8644067c293b170e19fba340ccc/types_toml-0.10.8.20240310-py3-none-any.whl", hash = "sha256:627b47775d25fa29977d9c70dc0cbab3f314f32c8d8d0c012f2ef5de7aaec05d", size = 4777, upload-time = "2024-03-10T02:18:36.568Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uipath"
+version = "2.11.12"
+source = { editable = "." }
+dependencies = [
+    { name = "applicationinsights" },
+    { name = "click" },
+    { name = "coverage" },
+    { name = "graphtty" },
+    { name = "httpx" },
+    { name = "mermaid-builder" },
+    { name = "mockito" },
+    { name = "pathlib" },
+    { name = "pydantic-function-models" },
+    { name = "pyjwt" },
+    { name = "pysignalr" },
+    { name = "python-dotenv" },
+    { name = "python-socketio" },
+    { name = "rich" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+    { name = "uipath-platform" },
+    { name = "uipath-runtime" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "bandit" },
+    { name = "filelock" },
+    { name = "inflection" },
+    { name = "mkdocs" },
+    { name = "mkdocs-click" },
+    { name = "mkdocs-llmstxt" },
+    { name = "mkdocs-material", extra = ["imaging"] },
+    { name = "mkdocs-open-in-new-tab" },
+    { name = "mkdocs-simple-hooks" },
+    { name = "mkdocstrings", extra = ["python"] },
+    { name = "mypy" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "pytest-httpx" },
+    { name = "pytest-mock" },
+    { name = "pytest-timeout" },
+    { name = "pytest-trio" },
+    { name = "ruff" },
+    { name = "rust-just" },
+    { name = "termynal" },
+    { name = "tomli-w" },
+    { name = "types-toml" },
+    { name = "virtualenv" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "applicationinsights", specifier = ">=0.11.10" },
+    { name = "click", specifier = ">=8.3.1" },
+    { name = "coverage", specifier = ">=7.8.2" },
+    { name = "graphtty", specifier = "==0.1.8" },
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "mermaid-builder", specifier = "==0.0.3" },
+    { name = "mockito", specifier = ">=1.5.4" },
+    { name = "pathlib", specifier = ">=1.0.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "pyjwt", specifier = ">=2.10.1" },
+    { name = "pysignalr", specifier = "==1.3.0" },
+    { name = "python-dotenv", specifier = ">=1.0.1" },
+    { name = "python-socketio", specifier = ">=5.15.0,<6.0.0" },
+    { name = "rich", specifier = ">=14.2.0" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../uipath-core" },
+    { name = "uipath-platform", editable = "../uipath-platform" },
+    { name = "uipath-runtime", specifier = ">=0.11.0,<0.12.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "filelock", specifier = ">=3.20.3" },
+    { name = "inflection", specifier = ">=0.5.1" },
+    { name = "mkdocs", specifier = ">=1.6.1" },
+    { name = "mkdocs-click", specifier = ">=0.9.0" },
+    { name = "mkdocs-llmstxt", specifier = ">=0.5.0" },
+    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.7.0" },
+    { name = "mkdocs-open-in-new-tab", specifier = ">=1.0.8" },
+    { name = "mkdocs-simple-hooks", specifier = ">=0.1.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.30.1" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.5.1" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+    { name = "termynal", specifier = ">=0.13.1" },
+    { name = "tomli-w", specifier = ">=1.2.0" },
+    { name = "types-toml", specifier = ">=0.10.8" },
+    { name = "virtualenv", specifier = ">=20.36.1" },
+]
+
+[[package]]
+name = "uipath-core"
+version = "0.5.22"
+source = { editable = "../uipath-core" }
+dependencies = [
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "pydantic" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "opentelemetry-instrumentation", specifier = ">=0.60b0,<1.0.0" },
+    { name = "opentelemetry-sdk", specifier = ">=1.39.0,<2.0.0" },
+    { name = "pydantic", specifier = ">=2.12.5,<3.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.14.1" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-platform"
+version = "0.1.76"
+source = { editable = "../uipath-platform" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic-function-models" },
+    { name = "sqlparse" },
+    { name = "tenacity" },
+    { name = "truststore" },
+    { name = "uipath-core" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pydantic-function-models", specifier = ">=0.1.11" },
+    { name = "sqlparse", specifier = ">=0.5.5" },
+    { name = "tenacity", specifier = ">=9.0.0" },
+    { name = "truststore", specifier = ">=0.10.1" },
+    { name = "uipath-core", editable = "../uipath-core" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "bandit", specifier = ">=1.8.2" },
+    { name = "mypy", specifier = ">=1.19.0" },
+    { name = "pre-commit", specifier = ">=4.1.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=1.0.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
+    { name = "pytest-httpx", specifier = ">=0.35.0" },
+    { name = "pytest-mock", specifier = ">=3.11.1" },
+    { name = "pytest-trio", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.9.4" },
+    { name = "rust-just", specifier = ">=1.39.0" },
+]
+
+[[package]]
+name = "uipath-runtime"
+version = "0.11.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uipath-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/87/fed3a5bd3479b9e7dc6cba769b054f5f1c00e93762356a70010e32f1f03c/uipath_runtime-0.11.2.tar.gz", hash = "sha256:8b3cc986644d6c9f2365345c231577f97d3bad8fb105fe8a6c7e16508d00d9ef", size = 145770, upload-time = "2026-06-22T16:31:40.786Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/62/c649c18ac39f53e5603abbcfa6917f6e880ac08047b1ce69d4c3ee937de8/uipath_runtime-0.11.2-py3-none-any.whl", hash = "sha256:a3a14dc2378bc934437bbd7523cf884d0cee0eeef26c736a9d6ce504d8a9fea0", size = 43874, upload-time = "2026-06-22T16:31:39.328Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.36.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" },
+    { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" },
+    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" },
+    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
+]
+
+[[package]]
+name = "webencodings"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "wsproto"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/79/12135bdf8b9c9367b8701c2c19a14c913c120b882d50b014ca0d38083c2c/wsproto-1.3.2.tar.gz", hash = "sha256:b86885dcf294e15204919950f666e06ffc6c7c114ca900b060d6e16293528294", size = 50116, upload-time = "2025-11-20T18:18:01.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/27/5ab13fc84c76a0250afd3d26d5936349a35be56ce5785447d6c423b26d92/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511", size = 141607, upload-time = "2025-10-06T14:09:16.298Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/a1/d065d51d02dc02ce81501d476b9ed2229d9a990818332242a882d5d60340/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6", size = 94027, upload-time = "2025-10-06T14:09:17.786Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/da/8da9f6a53f67b5106ffe902c6fa0164e10398d4e150d85838b82f424072a/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028", size = 94963, upload-time = "2025-10-06T14:09:19.662Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fe/2c1f674960c376e29cb0bec1249b117d11738db92a6ccc4a530b972648db/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d", size = 368406, upload-time = "2025-10-06T14:09:21.402Z" },
+    { url = "https://files.pythonhosted.org/packages/95/26/812a540e1c3c6418fec60e9bbd38e871eaba9545e94fa5eff8f4a8e28e1e/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503", size = 336581, upload-time = "2025-10-06T14:09:22.98Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f5/5777b19e26fdf98563985e481f8be3d8a39f8734147a6ebf459d0dab5a6b/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65", size = 388924, upload-time = "2025-10-06T14:09:24.655Z" },
+    { url = "https://files.pythonhosted.org/packages/86/08/24bd2477bd59c0bbd994fe1d93b126e0472e4e3df5a96a277b0a55309e89/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e", size = 392890, upload-time = "2025-10-06T14:09:26.617Z" },
+    { url = "https://files.pythonhosted.org/packages/46/00/71b90ed48e895667ecfb1eaab27c1523ee2fa217433ed77a73b13205ca4b/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d", size = 365819, upload-time = "2025-10-06T14:09:28.544Z" },
+    { url = "https://files.pythonhosted.org/packages/30/2d/f715501cae832651d3282387c6a9236cd26bd00d0ff1e404b3dc52447884/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7", size = 363601, upload-time = "2025-10-06T14:09:30.568Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f9/a678c992d78e394e7126ee0b0e4e71bd2775e4334d00a9278c06a6cce96a/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967", size = 358072, upload-time = "2025-10-06T14:09:32.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d1/b49454411a60edb6fefdcad4f8e6dbba7d8019e3a508a1c5836cba6d0781/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed", size = 385311, upload-time = "2025-10-06T14:09:34.634Z" },
+    { url = "https://files.pythonhosted.org/packages/87/e5/40d7a94debb8448c7771a916d1861d6609dddf7958dc381117e7ba36d9e8/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6", size = 381094, upload-time = "2025-10-06T14:09:36.268Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d8/611cc282502381ad855448643e1ad0538957fc82ae83dfe7762c14069e14/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e", size = 370944, upload-time = "2025-10-06T14:09:37.872Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/df/fadd00fb1c90e1a5a8bd731fa3d3de2e165e5a3666a095b04e31b04d9cb6/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca", size = 81804, upload-time = "2025-10-06T14:09:39.359Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f7/149bb6f45f267cb5c074ac40c01c6b3ea6d8a620d34b337f6321928a1b4d/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b", size = 86858, upload-time = "2025-10-06T14:09:41.068Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/13/88b78b93ad3f2f0b78e13bfaaa24d11cbc746e93fe76d8c06bf139615646/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376", size = 81637, upload-time = "2025-10-06T14:09:42.712Z" },
+    { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" },
+    { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" },
+    { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" },
+    { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" },
+    { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" },
+    { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload-time = "2025-10-06T14:10:14.601Z" },
+    { url = "https://files.pythonhosted.org/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload-time = "2025-10-06T14:10:16.115Z" },
+    { url = "https://files.pythonhosted.org/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload-time = "2025-10-06T14:10:17.993Z" },
+    { url = "https://files.pythonhosted.org/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload-time = "2025-10-06T14:10:19.44Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload-time = "2025-10-06T14:10:21.124Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload-time = "2025-10-06T14:10:22.902Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload-time = "2025-10-06T14:10:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload-time = "2025-10-06T14:10:26.406Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload-time = "2025-10-06T14:10:28.461Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload-time = "2025-10-06T14:10:30.541Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload-time = "2025-10-06T14:10:33.352Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload-time = "2025-10-06T14:10:35.034Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload-time = "2025-10-06T14:10:37.76Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload-time = "2025-10-06T14:10:39.649Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload-time = "2025-10-06T14:10:41.313Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload-time = "2025-10-06T14:10:43.167Z" },
+    { url = "https://files.pythonhosted.org/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload-time = "2025-10-06T14:10:44.643Z" },
+    { url = "https://files.pythonhosted.org/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload-time = "2025-10-06T14:10:46.554Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload-time = "2025-10-06T14:10:48.007Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload-time = "2025-10-06T14:10:49.997Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload-time = "2025-10-06T14:10:52.004Z" },
+    { url = "https://files.pythonhosted.org/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload-time = "2025-10-06T14:10:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload-time = "2025-10-06T14:10:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload-time = "2025-10-06T14:10:57.985Z" },
+    { url = "https://files.pythonhosted.org/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload-time = "2025-10-06T14:10:59.633Z" },
+    { url = "https://files.pythonhosted.org/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload-time = "2025-10-06T14:11:01.454Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload-time = "2025-10-06T14:11:03.452Z" },
+    { url = "https://files.pythonhosted.org/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload-time = "2025-10-06T14:11:05.115Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload-time = "2025-10-06T14:11:08.137Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload-time = "2025-10-06T14:11:10.284Z" },
+    { url = "https://files.pythonhosted.org/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload-time = "2025-10-06T14:11:11.739Z" },
+    { url = "https://files.pythonhosted.org/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload-time = "2025-10-06T14:11:13.586Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" },
+    { url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" },
+    { url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" },
+    { url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" },
+    { url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" },
+    { url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" },
+    { url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" },
+    { url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" },
+    { url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" },
+    { url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" },
+    { url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" },
+    { url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" },
+    { url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/samples/google-ADK-agent/.env.example b/samples/google-ADK-agent/.env.example
deleted file mode 100644
index 326450f5b..000000000
--- a/samples/google-ADK-agent/.env.example
+++ /dev/null
@@ -1,2 +0,0 @@
-GOOGLE_GENAI_USE_VERTEXAI=FALSE
-GOOGLE_API_KEY=YOUR_GOOGLE_API_KEY_HERE
diff --git a/samples/google-ADK-agent/README.md b/samples/google-ADK-agent/README.md
deleted file mode 100644
index 49484f606..000000000
--- a/samples/google-ADK-agent/README.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# UiPath Google ADK Agent
-
-## Overview
-
-This project showcases how to run Google's Agent Development Kit (ADK) agents on the UiPath Platform using the UiPath SDK. The implementation follows the [Google ADK Quickstart](https://google.github.io/adk-docs/get-started/quickstart/#agentpy) guide, demonstrating the ability to deploy and execute ADK agents within the UiPath ecosystem.
-
-## Features
-
-- Integration with Google's Gemini model
-- Seamless deployment to UiPath Platform
-
-## Prerequisites
-
-1. Python 3.10+
-2. Google AI Studio API key
-3. UiPath Platform account
-
-## Setup and Configuration
-
-1. **Create and activate a virtual environment**:
-   ```bash
-   pip install uv
-   uv venv
-   # Windows
-   .venv\Scripts\activate
-   # Unix/MacOS
-   source .venv/bin/activate
-   ```
-
-2. **Install dependencies**:
-   ```bash
-   uv sync
-   ```
-
-3. **Initialize UiPath configuration**:
-   ```bash
-   uipath init .\multi_tool_agent\agent.py
-   ```
-   This command will create (or update):
-   - `uipath.json`: Contains input/output schemas and bindings
-   - `.env`: Template for environment variables
-
-   For more details about the init command, see the [CLI Reference documentation](https://uipath.github.io/uipath-python/cli/#init).
-
-4. **Configure environment variables**:
-   Update the `.env` file with:
-   ```
-   GOOGLE_GENAI_USE_VERTEXAI=FALSE
-   GOOGLE_API_KEY=YOUR_API_KEY_HERE
-   ```
-
-## Deployment to UiPath Platform
-
-1. **Authenticate with UiPath**:
-   ```bash
-   uipath auth
-   ```
-
-2. **Package the agent**:
-   ```bash
-   uipath pack
-   ```
-
-3. **Publish to your workspace**:
-   ```bash
-   uipath publish --my-workspace
-   ```
-
-## Running the Agent
-
-### On UiPath Platform
-
-1. **Using CLI**:
-   ```bash
-   uipath invoke agent --file input.json
-   ```
-
-2. **From Orchestrator**:
-   - Navigate to Processes
-   - Find your published agent
-   - Click Run
-   - Provide input parameters
-
-### Local Development
-
-For local testing and development:
-```bash
-uipath run agent --file input.json
-# Debug mode
-uipath run agent --file input.json --debug
-```
-
-## Example Query and Output
-
-Query:
-```
-"What time is it in New York, and what's the weather like?"
-```
-
-When running on the UiPath Platform, you'll see the output in the job details:
-
-![Agent Output in UiPath Platform](../../docs/sample_images/google-ADK-agent/agent-output.png)
-
-## Notes
-
-- The agent uses Google's Gemini model for natural language processing
-- All agent interactions are logged and can be monitored through UiPath's tracing capabilities
-- The agent can be extended with additional tools and capabilities
-
-For more information about Google ADK, visit the [official documentation](https://google.github.io/adk-docs/).
diff --git a/samples/google-ADK-agent/input.json b/samples/google-ADK-agent/input.json
deleted file mode 100644
index 9e67919bc..000000000
--- a/samples/google-ADK-agent/input.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "query": "What time is it in New York, and what's the weather like?"
-}
diff --git a/samples/google-ADK-agent/multi_tool_agent/__init__.py b/samples/google-ADK-agent/multi_tool_agent/__init__.py
deleted file mode 100644
index 02c597e11..000000000
--- a/samples/google-ADK-agent/multi_tool_agent/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from . import agent
diff --git a/samples/google-ADK-agent/multi_tool_agent/agent.py b/samples/google-ADK-agent/multi_tool_agent/agent.py
deleted file mode 100644
index 7038cbdbf..000000000
--- a/samples/google-ADK-agent/multi_tool_agent/agent.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import dataclasses
-import datetime
-from typing import Dict
-from zoneinfo import ZoneInfo
-
-from google.adk.agents import Agent
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from google.genai.types import Content, Part
-
-
-def get_weather(city: str) -> Dict[str, str]:
-    """Retrieves the current weather report for a specified city.
-
-    Args:
-        city (str): The name of the city for which to retrieve the weather report.
-
-    Returns:
-        Dict[str, str]: Dictionary containing status and result or error message.
-    """
-    if city.lower() == "new york":
-        return {
-            "status": "success",
-            "report": (
-                "The weather in New York is sunny with a temperature of 25 degrees"
-                " Celsius (77 degrees Fahrenheit)."
-            ),
-        }
-    else:
-        return {
-            "status": "error",
-            "error_message": f"Weather information for '{city}' is not available.",
-        }
-
-
-def get_current_time(city: str) -> Dict[str, str]:
-    """Returns the current time in a specified city.
-
-    Args:
-        city (str): The name of the city for which to retrieve the current time.
-
-    Returns:
-        Dict[str, str]: Dictionary containing status and result or error message.
-    """
-    if city.lower() == "new york":
-        tz_identifier = "America/New_York"
-    else:
-        return {
-            "status": "error",
-            "error_message": (f"Sorry, I don't have timezone information for {city}."),
-        }
-
-    tz = ZoneInfo(tz_identifier)
-    now = datetime.datetime.now(tz)
-    report = f"The current time in {city} is {now.strftime('%Y-%m-%d %H:%M:%S %Z%z')}"
-    return {"status": "success", "report": report}
-
-
-root_agent = Agent(
-    name="weather_time_agent",
-    model="gemini-1.5-flash",
-    description=("Agent to answer questions about the time and weather in a city."),
-    instruction=(
-        "You are a helpful agent who can answer user questions about the time and weather in a city."
-    ),
-    tools=[get_weather, get_current_time],
-)
-
-
-@dataclasses.dataclass
-class AgentInput:
-    """Input data structure for the agent.
-
-    Attributes:
-        query (str): The user's query string.
-    """
-
-    query: str
-
-
-def configure_ssl_context() -> None:
-    """Configure SSL context with proper certificate paths."""
-    import os
-    import ssl
-
-    default_paths = ssl.get_default_verify_paths()
-    if default_paths.cafile:
-        os.environ["SSL_CERT_FILE"] = default_paths.cafile
-    if not os.getenv("SSL_CERT_DIR", None):
-        os.environ["SSL_CERT_DIR"] = default_paths.capath or "/etc/ssl/certs"
-
-
-async def main(input: AgentInput) -> str:
-    """Main entry point for the agent.
-
-    Args:
-        input (AgentInput): The input containing the user's query.
-
-    Returns:
-        str: The agent's response to the query.
-    """
-    user_id = "test_user"
-    session_service = InMemorySessionService()
-    session = await session_service.create_session(
-        app_name="multi-tool-agent", user_id=user_id
-    )
-    configure_ssl_context()
-
-    runner = Runner(
-        app_name=session.app_name,
-        agent=root_agent,
-        session_service=session_service,
-    )
-    content = Content(parts=[Part(text=input.query)], role="user")
-    output = ""
-    async for event in runner.run_async(
-        new_message=content,
-        user_id=user_id,
-        session_id=session.id,
-    ):
-        if event.content and event.content.parts:
-            if text := "".join(part.text or "" for part in event.content.parts):
-                output = text
-    return output
diff --git a/samples/google-ADK-agent/pyproject.toml b/samples/google-ADK-agent/pyproject.toml
deleted file mode 100644
index 7220ae91c..000000000
--- a/samples/google-ADK-agent/pyproject.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[project]
-name = "google-adk-agent"
-version = "0.0.1"
-description = "UiPath - Google ADK agent"
-authors = [{ name = "John Doe" }]
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "google-adk>=1.4.2",
-    "uipath>=2.0.79",
-]
diff --git a/samples/google-ADK-agent/uv.lock b/samples/google-ADK-agent/uv.lock
deleted file mode 100644
index 144f40bdd..000000000
--- a/samples/google-ADK-agent/uv.lock
+++ /dev/null
@@ -1,2496 +0,0 @@
-version = 1
-revision = 1
-requires-python = ">=3.10"
-resolution-markers = [
-    "python_full_version >= '3.13'",
-    "python_full_version >= '3.11' and python_full_version < '3.13'",
-    "python_full_version < '3.11'",
-]
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
-]
-
-[[package]]
-name = "anyio"
-version = "4.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "idna" },
-    { name = "sniffio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 },
-]
-
-[[package]]
-name = "asgiref"
-version = "3.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/90/61/0aa957eec22ff70b830b22ff91f825e70e1ef732c06666a805730f28b36b/asgiref-3.9.1.tar.gz", hash = "sha256:a5ab6582236218e5ef1648f242fd9f10626cfd4de8dc377db215d5d5098e3142", size = 36870 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/3c/0464dcada90d5da0e71018c04a140ad6349558afb30b3051b4264cc5b965/asgiref-3.9.1-py3-none-any.whl", hash = "sha256:f3bba7092a48005b5f5bacd747d36ee4a5a61f4a269a6df590b43144355ebd2c", size = 23790 },
-]
-
-[[package]]
-name = "attrs"
-version = "25.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 },
-]
-
-[[package]]
-name = "authlib"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cryptography" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/9d/b1e08d36899c12c8b894a44a5583ee157789f26fc4b176f8e4b6217b56e1/authlib-1.6.0.tar.gz", hash = "sha256:4367d32031b7af175ad3a323d571dc7257b7099d55978087ceae4a0d88cd3210", size = 158371 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/29/587c189bbab1ccc8c86a03a5d0e13873df916380ef1be461ebe6acebf48d/authlib-1.6.0-py2.py3-none-any.whl", hash = "sha256:91685589498f79e8655e8a8947431ad6288831d643f11c55c2143ffcc738048d", size = 239981 },
-]
-
-[[package]]
-name = "azure-core"
-version = "1.35.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "requests" },
-    { name = "six" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/89/f53968635b1b2e53e4aad2dd641488929fef4ca9dfb0b97927fa7697ddf3/azure_core-1.35.0.tar.gz", hash = "sha256:c0be528489485e9ede59b6971eb63c1eaacf83ef53001bfe3904e475e972be5c", size = 339689 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/78/bf94897361fdd650850f0f2e405b2293e2f12808239046232bdedf554301/azure_core-1.35.0-py3-none-any.whl", hash = "sha256:8db78c72868a58f3de8991eb4d22c4d368fae226dac1002998d6c50437e7dad1", size = 210708 },
-]
-
-[[package]]
-name = "azure-core-tracing-opentelemetry"
-version = "1.0.0b12"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "opentelemetry-api" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/7f/5de13a331a5f2919417819cc37dcf7c897018f02f83aa82b733e6629a6a6/azure_core_tracing_opentelemetry-1.0.0b12.tar.gz", hash = "sha256:bb454142440bae11fd9d68c7c1d67ae38a1756ce808c5e4d736730a7b4b04144", size = 26010 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/5e/97a471f66935e7f89f521d0e11ae49c7f0871ca38f5c319dccae2155c8d8/azure_core_tracing_opentelemetry-1.0.0b12-py3-none-any.whl", hash = "sha256:38fd42709f1cc4bbc4f2797008b1c30a6a01617e49910c05daa3a0d0c65053ac", size = 11962 },
-]
-
-[[package]]
-name = "azure-identity"
-version = "1.23.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "cryptography" },
-    { name = "msal" },
-    { name = "msal-extensions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/41/52/458c1be17a5d3796570ae2ed3c6b7b55b134b22d5ef8132b4f97046a9051/azure_identity-1.23.0.tar.gz", hash = "sha256:d9cdcad39adb49d4bb2953a217f62aec1f65bbb3c63c9076da2be2a47e53dde4", size = 265280 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/16/a51d47780f41e4b87bb2d454df6aea90a44a346e918ac189d3700f3d728d/azure_identity-1.23.0-py3-none-any.whl", hash = "sha256:dbbeb64b8e5eaa81c44c565f264b519ff2de7ff0e02271c49f3cb492762a50b0", size = 186097 },
-]
-
-[[package]]
-name = "azure-monitor-opentelemetry"
-version = "1.6.10"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "azure-core-tracing-opentelemetry" },
-    { name = "azure-monitor-opentelemetry-exporter" },
-    { name = "opentelemetry-instrumentation-django" },
-    { name = "opentelemetry-instrumentation-fastapi" },
-    { name = "opentelemetry-instrumentation-flask" },
-    { name = "opentelemetry-instrumentation-psycopg2" },
-    { name = "opentelemetry-instrumentation-requests" },
-    { name = "opentelemetry-instrumentation-urllib" },
-    { name = "opentelemetry-instrumentation-urllib3" },
-    { name = "opentelemetry-resource-detector-azure" },
-    { name = "opentelemetry-sdk" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5b/d0/6c315ddec1490989404cbf21909c232e9e5285b1117972ed488d7d2d7f46/azure_monitor_opentelemetry-1.6.10.tar.gz", hash = "sha256:1f8145f665abb1626ac1caf14f75fc9b4fc43b818694798f7a43ea369e265683", size = 48990 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/f9/762e29bcb2c05ec24bee39f28f20e95d0efab57ea3edcc591422308570d6/azure_monitor_opentelemetry-1.6.10-py3-none-any.whl", hash = "sha256:8b5953454f72da42f7959a8017e5f9712427b931d1d08be008d32722c4605a0d", size = 25274 },
-]
-
-[[package]]
-name = "azure-monitor-opentelemetry-exporter"
-version = "1.0.0b39"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "azure-identity" },
-    { name = "fixedint" },
-    { name = "msrest" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-sdk" },
-    { name = "psutil" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/49/70/3d8bcd1ed71ff23233cd1f600ad9b3527a18bae7d95dccadd606ed0ea8e2/azure_monitor_opentelemetry_exporter-1.0.0b39.tar.gz", hash = "sha256:c28f5f56261ad40ab69eb00ba4e60d50417ec30e343afccc65c5c89ba4056087", size = 193192 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/a4/8b7fe3ad137516ff6d2fa7b8662ada88f6ef8408f93ccf81e3e569469fee/azure_monitor_opentelemetry_exporter-1.0.0b39-py2.py3-none-any.whl", hash = "sha256:22419084272affeb117e47abd7420a4040ae370ee844c0167ccbc77c26490cc3", size = 155944 },
-]
-
-[[package]]
-name = "cachetools"
-version = "5.5.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080 },
-]
-
-[[package]]
-name = "certifi"
-version = "2025.7.14"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722 },
-]
-
-[[package]]
-name = "cffi"
-version = "1.17.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pycparser" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 },
-    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 },
-    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 },
-    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 },
-    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 },
-    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 },
-    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 },
-    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 },
-    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 },
-    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 },
-    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 },
-    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 },
-    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 },
-    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 },
-    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 },
-    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 },
-    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 },
-    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 },
-    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 },
-    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 },
-    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 },
-    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 },
-    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 },
-    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 },
-    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
-    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
-    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
-    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
-    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
-    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
-    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
-    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
-    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
-    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
-    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
-    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
-    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
-    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
-    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
-    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
-    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
-    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
-    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
-    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/28/9901804da60055b406e1a1c5ba7aac1276fb77f1dde635aabfc7fd84b8ab/charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941", size = 201818 },
-    { url = "https://files.pythonhosted.org/packages/d9/9b/892a8c8af9110935e5adcbb06d9c6fe741b6bb02608c6513983048ba1a18/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd", size = 144649 },
-    { url = "https://files.pythonhosted.org/packages/7b/a5/4179abd063ff6414223575e008593861d62abfc22455b5d1a44995b7c101/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6", size = 155045 },
-    { url = "https://files.pythonhosted.org/packages/3b/95/bc08c7dfeddd26b4be8c8287b9bb055716f31077c8b0ea1cd09553794665/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d", size = 147356 },
-    { url = "https://files.pythonhosted.org/packages/a8/2d/7a5b635aa65284bf3eab7653e8b4151ab420ecbae918d3e359d1947b4d61/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86", size = 149471 },
-    { url = "https://files.pythonhosted.org/packages/ae/38/51fc6ac74251fd331a8cfdb7ec57beba8c23fd5493f1050f71c87ef77ed0/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c", size = 151317 },
-    { url = "https://files.pythonhosted.org/packages/b7/17/edee1e32215ee6e9e46c3e482645b46575a44a2d72c7dfd49e49f60ce6bf/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0", size = 146368 },
-    { url = "https://files.pythonhosted.org/packages/26/2c/ea3e66f2b5f21fd00b2825c94cafb8c326ea6240cd80a91eb09e4a285830/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef", size = 154491 },
-    { url = "https://files.pythonhosted.org/packages/52/47/7be7fa972422ad062e909fd62460d45c3ef4c141805b7078dbab15904ff7/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6", size = 157695 },
-    { url = "https://files.pythonhosted.org/packages/2f/42/9f02c194da282b2b340f28e5fb60762de1151387a36842a92b533685c61e/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366", size = 154849 },
-    { url = "https://files.pythonhosted.org/packages/67/44/89cacd6628f31fb0b63201a618049be4be2a7435a31b55b5eb1c3674547a/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db", size = 150091 },
-    { url = "https://files.pythonhosted.org/packages/1f/79/4b8da9f712bc079c0f16b6d67b099b0b8d808c2292c937f267d816ec5ecc/charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a", size = 98445 },
-    { url = "https://files.pythonhosted.org/packages/7d/d7/96970afb4fb66497a40761cdf7bd4f6fca0fc7bafde3a84f836c1f57a926/charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509", size = 105782 },
-    { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794 },
-    { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846 },
-    { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350 },
-    { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657 },
-    { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260 },
-    { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164 },
-    { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571 },
-    { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952 },
-    { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959 },
-    { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030 },
-    { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015 },
-    { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106 },
-    { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402 },
-    { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936 },
-    { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790 },
-    { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924 },
-    { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626 },
-    { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567 },
-    { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957 },
-    { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408 },
-    { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399 },
-    { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815 },
-    { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537 },
-    { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565 },
-    { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357 },
-    { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776 },
-    { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622 },
-    { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435 },
-    { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653 },
-    { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231 },
-    { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243 },
-    { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442 },
-    { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147 },
-    { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057 },
-    { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454 },
-    { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174 },
-    { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166 },
-    { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064 },
-    { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641 },
-    { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626 },
-]
-
-[[package]]
-name = "click"
-version = "8.2.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215 },
-]
-
-[[package]]
-name = "cloudpickle"
-version = "3.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/52/39/069100b84d7418bc358d81669d5748efb14b9cceacd2f9c75f550424132f/cloudpickle-3.1.1.tar.gz", hash = "sha256:b216fa8ae4019d5482a8ac3c95d8f6346115d8835911fd4aefd1a445e4242c64", size = 22113 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/e8/64c37fadfc2816a7701fa8a6ed8d87327c7d54eacfbfb6edab14a2f2be75/cloudpickle-3.1.1-py3-none-any.whl", hash = "sha256:c8c5a44295039331ee9dad40ba100a9c7297b6f988e50e87ccdf3765a668350e", size = 20992 },
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
-]
-
-[[package]]
-name = "cryptography"
-version = "45.0.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/1e/49527ac611af559665f71cbb8f92b332b5ec9c6fbc4e88b0f8e92f5e85df/cryptography-45.0.5.tar.gz", hash = "sha256:72e76caa004ab63accdf26023fccd1d087f6d90ec6048ff33ad0445abf7f605a", size = 744903 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f0/fb/09e28bc0c46d2c547085e60897fea96310574c70fb21cd58a730a45f3403/cryptography-45.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:101ee65078f6dd3e5a028d4f19c07ffa4dd22cce6a20eaa160f8b5219911e7d8", size = 7043092 },
-    { url = "https://files.pythonhosted.org/packages/b1/05/2194432935e29b91fb649f6149c1a4f9e6d3d9fc880919f4ad1bcc22641e/cryptography-45.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3a264aae5f7fbb089dbc01e0242d3b67dffe3e6292e1f5182122bdf58e65215d", size = 4205926 },
-    { url = "https://files.pythonhosted.org/packages/07/8b/9ef5da82350175e32de245646b1884fc01124f53eb31164c77f95a08d682/cryptography-45.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e74d30ec9c7cb2f404af331d5b4099a9b322a8a6b25c4632755c8757345baac5", size = 4429235 },
-    { url = "https://files.pythonhosted.org/packages/7c/e1/c809f398adde1994ee53438912192d92a1d0fc0f2d7582659d9ef4c28b0c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3af26738f2db354aafe492fb3869e955b12b2ef2e16908c8b9cb928128d42c57", size = 4209785 },
-    { url = "https://files.pythonhosted.org/packages/d0/8b/07eb6bd5acff58406c5e806eff34a124936f41a4fb52909ffa4d00815f8c/cryptography-45.0.5-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e6c00130ed423201c5bc5544c23359141660b07999ad82e34e7bb8f882bb78e0", size = 3893050 },
-    { url = "https://files.pythonhosted.org/packages/ec/ef/3333295ed58d900a13c92806b67e62f27876845a9a908c939f040887cca9/cryptography-45.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:dd420e577921c8c2d31289536c386aaa30140b473835e97f83bc71ea9d2baf2d", size = 4457379 },
-    { url = "https://files.pythonhosted.org/packages/d9/9d/44080674dee514dbb82b21d6fa5d1055368f208304e2ab1828d85c9de8f4/cryptography-45.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:d05a38884db2ba215218745f0781775806bde4f32e07b135348355fe8e4991d9", size = 4209355 },
-    { url = "https://files.pythonhosted.org/packages/c9/d8/0749f7d39f53f8258e5c18a93131919ac465ee1f9dccaf1b3f420235e0b5/cryptography-45.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:ad0caded895a00261a5b4aa9af828baede54638754b51955a0ac75576b831b27", size = 4456087 },
-    { url = "https://files.pythonhosted.org/packages/09/d7/92acac187387bf08902b0bf0699816f08553927bdd6ba3654da0010289b4/cryptography-45.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9024beb59aca9d31d36fcdc1604dd9bbeed0a55bface9f1908df19178e2f116e", size = 4332873 },
-    { url = "https://files.pythonhosted.org/packages/03/c2/840e0710da5106a7c3d4153c7215b2736151bba60bf4491bdb421df5056d/cryptography-45.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:91098f02ca81579c85f66df8a588c78f331ca19089763d733e34ad359f474174", size = 4564651 },
-    { url = "https://files.pythonhosted.org/packages/2e/92/cc723dd6d71e9747a887b94eb3827825c6c24b9e6ce2bb33b847d31d5eaa/cryptography-45.0.5-cp311-abi3-win32.whl", hash = "sha256:926c3ea71a6043921050eaa639137e13dbe7b4ab25800932a8498364fc1abec9", size = 2929050 },
-    { url = "https://files.pythonhosted.org/packages/1f/10/197da38a5911a48dd5389c043de4aec4b3c94cb836299b01253940788d78/cryptography-45.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:b85980d1e345fe769cfc57c57db2b59cff5464ee0c045d52c0df087e926fbe63", size = 3403224 },
-    { url = "https://files.pythonhosted.org/packages/fe/2b/160ce8c2765e7a481ce57d55eba1546148583e7b6f85514472b1d151711d/cryptography-45.0.5-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f3562c2f23c612f2e4a6964a61d942f891d29ee320edb62ff48ffb99f3de9ae8", size = 7017143 },
-    { url = "https://files.pythonhosted.org/packages/c2/e7/2187be2f871c0221a81f55ee3105d3cf3e273c0a0853651d7011eada0d7e/cryptography-45.0.5-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3fcfbefc4a7f332dece7272a88e410f611e79458fab97b5efe14e54fe476f4fd", size = 4197780 },
-    { url = "https://files.pythonhosted.org/packages/b9/cf/84210c447c06104e6be9122661159ad4ce7a8190011669afceeaea150524/cryptography-45.0.5-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:460f8c39ba66af7db0545a8c6f2eabcbc5a5528fc1cf6c3fa9a1e44cec33385e", size = 4420091 },
-    { url = "https://files.pythonhosted.org/packages/3e/6a/cb8b5c8bb82fafffa23aeff8d3a39822593cee6e2f16c5ca5c2ecca344f7/cryptography-45.0.5-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9b4cf6318915dccfe218e69bbec417fdd7c7185aa7aab139a2c0beb7468c89f0", size = 4198711 },
-    { url = "https://files.pythonhosted.org/packages/04/f7/36d2d69df69c94cbb2473871926daf0f01ad8e00fe3986ac3c1e8c4ca4b3/cryptography-45.0.5-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2089cc8f70a6e454601525e5bf2779e665d7865af002a5dec8d14e561002e135", size = 3883299 },
-    { url = "https://files.pythonhosted.org/packages/82/c7/f0ea40f016de72f81288e9fe8d1f6748036cb5ba6118774317a3ffc6022d/cryptography-45.0.5-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0027d566d65a38497bc37e0dd7c2f8ceda73597d2ac9ba93810204f56f52ebc7", size = 4450558 },
-    { url = "https://files.pythonhosted.org/packages/06/ae/94b504dc1a3cdf642d710407c62e86296f7da9e66f27ab12a1ee6fdf005b/cryptography-45.0.5-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:be97d3a19c16a9be00edf79dca949c8fa7eff621763666a145f9f9535a5d7f42", size = 4198020 },
-    { url = "https://files.pythonhosted.org/packages/05/2b/aaf0adb845d5dabb43480f18f7ca72e94f92c280aa983ddbd0bcd6ecd037/cryptography-45.0.5-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:7760c1c2e1a7084153a0f68fab76e754083b126a47d0117c9ed15e69e2103492", size = 4449759 },
-    { url = "https://files.pythonhosted.org/packages/91/e4/f17e02066de63e0100a3a01b56f8f1016973a1d67551beaf585157a86b3f/cryptography-45.0.5-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ff8728d8d890b3dda5765276d1bc6fb099252915a2cd3aff960c4c195745dd0", size = 4319991 },
-    { url = "https://files.pythonhosted.org/packages/f2/2e/e2dbd629481b499b14516eed933f3276eb3239f7cee2dcfa4ee6b44d4711/cryptography-45.0.5-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7259038202a47fdecee7e62e0fd0b0738b6daa335354396c6ddebdbe1206af2a", size = 4554189 },
-    { url = "https://files.pythonhosted.org/packages/f8/ea/a78a0c38f4c8736287b71c2ea3799d173d5ce778c7d6e3c163a95a05ad2a/cryptography-45.0.5-cp37-abi3-win32.whl", hash = "sha256:1e1da5accc0c750056c556a93c3e9cb828970206c68867712ca5805e46dc806f", size = 2911769 },
-    { url = "https://files.pythonhosted.org/packages/79/b3/28ac139109d9005ad3f6b6f8976ffede6706a6478e21c889ce36c840918e/cryptography-45.0.5-cp37-abi3-win_amd64.whl", hash = "sha256:90cb0a7bb35959f37e23303b7eed0a32280510030daba3f7fdfbb65defde6a97", size = 3390016 },
-    { url = "https://files.pythonhosted.org/packages/f8/8b/34394337abe4566848a2bd49b26bcd4b07fd466afd3e8cce4cb79a390869/cryptography-45.0.5-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:206210d03c1193f4e1ff681d22885181d47efa1ab3018766a7b32a7b3d6e6afd", size = 3575762 },
-    { url = "https://files.pythonhosted.org/packages/8b/5d/a19441c1e89afb0f173ac13178606ca6fab0d3bd3ebc29e9ed1318b507fc/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c648025b6840fe62e57107e0a25f604db740e728bd67da4f6f060f03017d5097", size = 4140906 },
-    { url = "https://files.pythonhosted.org/packages/4b/db/daceb259982a3c2da4e619f45b5bfdec0e922a23de213b2636e78ef0919b/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b8fa8b0a35a9982a3c60ec79905ba5bb090fc0b9addcfd3dc2dd04267e45f25e", size = 4374411 },
-    { url = "https://files.pythonhosted.org/packages/6a/35/5d06ad06402fc522c8bf7eab73422d05e789b4e38fe3206a85e3d6966c11/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:14d96584701a887763384f3c47f0ca7c1cce322aa1c31172680eb596b890ec30", size = 4140942 },
-    { url = "https://files.pythonhosted.org/packages/65/79/020a5413347e44c382ef1f7f7e7a66817cd6273e3e6b5a72d18177b08b2f/cryptography-45.0.5-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:57c816dfbd1659a367831baca4b775b2a5b43c003daf52e9d57e1d30bc2e1b0e", size = 4374079 },
-    { url = "https://files.pythonhosted.org/packages/9b/c5/c0e07d84a9a2a8a0ed4f865e58f37c71af3eab7d5e094ff1b21f3f3af3bc/cryptography-45.0.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b9e38e0a83cd51e07f5a48ff9691cae95a79bea28fe4ded168a8e5c6c77e819d", size = 3321362 },
-    { url = "https://files.pythonhosted.org/packages/c0/71/9bdbcfd58d6ff5084687fe722c58ac718ebedbc98b9f8f93781354e6d286/cryptography-45.0.5-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:8c4a6ff8a30e9e3d38ac0539e9a9e02540ab3f827a3394f8852432f6b0ea152e", size = 3587878 },
-    { url = "https://files.pythonhosted.org/packages/f0/63/83516cfb87f4a8756eaa4203f93b283fda23d210fc14e1e594bd5f20edb6/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bd4c45986472694e5121084c6ebbd112aa919a25e783b87eb95953c9573906d6", size = 4152447 },
-    { url = "https://files.pythonhosted.org/packages/22/11/d2823d2a5a0bd5802b3565437add16f5c8ce1f0778bf3822f89ad2740a38/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:982518cd64c54fcada9d7e5cf28eabd3ee76bd03ab18e08a48cad7e8b6f31b18", size = 4386778 },
-    { url = "https://files.pythonhosted.org/packages/5f/38/6bf177ca6bce4fe14704ab3e93627c5b0ca05242261a2e43ef3168472540/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:12e55281d993a793b0e883066f590c1ae1e802e3acb67f8b442e721e475e6463", size = 4151627 },
-    { url = "https://files.pythonhosted.org/packages/38/6a/69fc67e5266bff68a91bcb81dff8fb0aba4d79a78521a08812048913e16f/cryptography-45.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:5aa1e32983d4443e310f726ee4b071ab7569f58eedfdd65e9675484a4eb67bd1", size = 4385593 },
-    { url = "https://files.pythonhosted.org/packages/f6/34/31a1604c9a9ade0fdab61eb48570e09a796f4d9836121266447b0eaf7feb/cryptography-45.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e357286c1b76403dd384d938f93c46b2b058ed4dfcdce64a770f0537ed3feb6f", size = 3331106 },
-]
-
-[[package]]
-name = "deprecated"
-version = "1.2.18"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998 },
-]
-
-[[package]]
-name = "docstring-parser"
-version = "0.16"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/08/12/9c22a58c0b1e29271051222d8906257616da84135af9ed167c9e28f85cb3/docstring_parser-0.16.tar.gz", hash = "sha256:538beabd0af1e2db0146b6bd3caa526c35a34d61af9fd2887f3a8a27a739aa6e", size = 26565 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/7c/e9fcff7623954d86bdc17782036cbf715ecab1bec4847c008557affe1ca8/docstring_parser-0.16-py3-none-any.whl", hash = "sha256:bf0a1387354d3691d102edef7ec124f219ef639982d096e26e3b60aeffa90637", size = 36533 },
-]
-
-[[package]]
-name = "exceptiongroup"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674 },
-]
-
-[[package]]
-name = "fastapi"
-version = "0.116.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "starlette" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/78/d7/6c8b3bfe33eeffa208183ec037fee0cce9f7f024089ab1c5d12ef04bd27c/fastapi-0.116.1.tar.gz", hash = "sha256:ed52cbf946abfd70c5a0dccb24673f0670deeb517a88b3544d03c2a6bf283143", size = 296485 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl", hash = "sha256:c46ac7c312df840f0c9e220f7964bada936781bc4e2e6eb71f1c4d7553786565", size = 95631 },
-]
-
-[[package]]
-name = "fixedint"
-version = "0.1.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/32/c6/b1b9b3f69915d51909ef6ebe6352e286ec3d6f2077278af83ec6e3cc569c/fixedint-0.1.6.tar.gz", hash = "sha256:703005d090499d41ce7ce2ee7eae8f7a5589a81acdc6b79f1728a56495f2c799", size = 12750 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/6d/8f5307d26ce700a89e5a67d1e1ad15eff977211f9ed3ae90d7b0d67f4e66/fixedint-0.1.6-py3-none-any.whl", hash = "sha256:b8cf9f913735d2904deadda7a6daa9f57100599da1de57a7448ea1be75ae8c9c", size = 12702 },
-]
-
-[[package]]
-name = "google-adk"
-version = "1.4.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "authlib" },
-    { name = "click" },
-    { name = "fastapi" },
-    { name = "google-api-python-client" },
-    { name = "google-cloud-aiplatform", extra = ["agent-engines"] },
-    { name = "google-cloud-secret-manager" },
-    { name = "google-cloud-speech" },
-    { name = "google-cloud-storage" },
-    { name = "google-genai" },
-    { name = "graphviz" },
-    { name = "mcp" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-gcp-trace" },
-    { name = "opentelemetry-sdk" },
-    { name = "pydantic" },
-    { name = "python-dateutil" },
-    { name = "python-dotenv" },
-    { name = "pyyaml" },
-    { name = "requests" },
-    { name = "sqlalchemy" },
-    { name = "starlette" },
-    { name = "typing-extensions" },
-    { name = "tzlocal" },
-    { name = "uvicorn" },
-    { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/31/0e/c68b45d76b8634916054557827cac3575a8336fc72ef3aa29afeed4d3a3c/google_adk-1.4.2.tar.gz", hash = "sha256:f1d4ccf109aaeaf2af2ffd419432b337499e38d008e59944c036b84206f2806e", size = 1153068 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ff/fd/301204b06c9f306951f11bb00a9a2c0a96952c66a241161ebc72a39818aa/google_adk-1.4.2-py3-none-any.whl", hash = "sha256:5987096b4ad854aa2f9faa923e1632a65d69d21794766e44683f36505382ab6a", size = 1321176 },
-]
-
-[[package]]
-name = "google-adk-agent"
-version = "0.1.40"
-source = { virtual = "." }
-dependencies = [
-    { name = "google-adk" },
-    { name = "uipath" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "google-adk", specifier = ">=1.4.2" },
-    { name = "uipath", specifier = ">=2.0.78" },
-]
-
-[[package]]
-name = "google-api-core"
-version = "2.25.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-auth" },
-    { name = "googleapis-common-protos" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/dc/21/e9d043e88222317afdbdb567165fdbc3b0aad90064c7e0c9eb0ad9955ad8/google_api_core-2.25.1.tar.gz", hash = "sha256:d2aaa0b13c78c61cb3f4282c464c046e45fbd75755683c9c525e6e8f7ed0a5e8", size = 165443 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/4b/ead00905132820b623732b175d66354e9d3e69fcf2a5dcdab780664e7896/google_api_core-2.25.1-py3-none-any.whl", hash = "sha256:8a2a56c1fef82987a524371f99f3bd0143702fecc670c72e600c1cda6bf8dbb7", size = 160807 },
-]
-
-[package.optional-dependencies]
-grpc = [
-    { name = "grpcio" },
-    { name = "grpcio-status" },
-]
-
-[[package]]
-name = "google-api-python-client"
-version = "2.176.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-    { name = "google-auth-httplib2" },
-    { name = "httplib2" },
-    { name = "uritemplate" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3e/38/daf70faf6d05556d382bac640bc6765f09fcfb9dfb51ac4a595d3453a2a9/google_api_python_client-2.176.0.tar.gz", hash = "sha256:2b451cdd7fd10faeb5dd20f7d992f185e1e8f4124c35f2cdcc77c843139a4cf1", size = 13154773 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/2c/758f415a19a12c3c6d06902794b0dd4c521d912a59b98ab752bba48812df/google_api_python_client-2.176.0-py3-none-any.whl", hash = "sha256:e22239797f1d085341e12cd924591fc65c56d08e0af02549d7606092e6296510", size = 13678445 },
-]
-
-[[package]]
-name = "google-auth"
-version = "2.40.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cachetools" },
-    { name = "pyasn1-modules" },
-    { name = "rsa" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/9b/e92ef23b84fa10a64ce4831390b7a4c2e53c0132568d99d4ae61d04c8855/google_auth-2.40.3.tar.gz", hash = "sha256:500c3a29adedeb36ea9cf24b8d10858e152f2412e3ca37829b3fa18e33d63b77", size = 281029 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/17/63/b19553b658a1692443c62bd07e5868adaa0ad746a0751ba62c59568cd45b/google_auth-2.40.3-py2.py3-none-any.whl", hash = "sha256:1370d4593e86213563547f97a92752fc658456fe4514c809544f330fed45a7ca", size = 216137 },
-]
-
-[[package]]
-name = "google-auth-httplib2"
-version = "0.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-auth" },
-    { name = "httplib2" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/56/be/217a598a818567b28e859ff087f347475c807a5649296fb5a817c58dacef/google-auth-httplib2-0.2.0.tar.gz", hash = "sha256:38aa7badf48f974f1eb9861794e9c0cb2a0511a4ec0679b1f886d108f5640e05", size = 10842 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/8a/fe34d2f3f9470a27b01c9e76226965863f153d5fbe276f83608562e49c04/google_auth_httplib2-0.2.0-py2.py3-none-any.whl", hash = "sha256:b65a0a2123300dd71281a7bf6e64d65a0759287df52729bdd1ae2e47dc311a3d", size = 9253 },
-]
-
-[[package]]
-name = "google-cloud-aiplatform"
-version = "1.103.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "docstring-parser" },
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "google-cloud-bigquery" },
-    { name = "google-cloud-resource-manager" },
-    { name = "google-cloud-storage" },
-    { name = "google-genai" },
-    { name = "packaging" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-    { name = "pydantic" },
-    { name = "shapely" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/f1/deec517e3b10992d3b07e729f2682303c4c999499a1819fde90a57b44e48/google_cloud_aiplatform-1.103.0.tar.gz", hash = "sha256:0d0c0db3bde6182097f4db8ddcbfb2ab382009458cf594c09cfb4406896b9795", size = 9449712 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3a/8e/0779ce9d733c9073a00e2815c82e444f60332c2aac36148f62e2f3418b78/google_cloud_aiplatform-1.103.0-py2.py3-none-any.whl", hash = "sha256:bc14d90caed44580192ad8b60cf74c5a7089562a0dfa6425cad163971d3ae759", size = 7854846 },
-]
-
-[package.optional-dependencies]
-agent-engines = [
-    { name = "cloudpickle" },
-    { name = "google-cloud-logging" },
-    { name = "google-cloud-trace" },
-    { name = "opentelemetry-exporter-gcp-trace" },
-    { name = "opentelemetry-sdk" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "typing-extensions" },
-]
-
-[[package]]
-name = "google-cloud-appengine-logging"
-version = "1.6.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/ea/85da73d4f162b29d24ad591c4ce02688b44094ee5f3d6c0cc533c2b23b23/google_cloud_appengine_logging-1.6.2.tar.gz", hash = "sha256:4890928464c98da9eecc7bf4e0542eba2551512c0265462c10f3a3d2a6424b90", size = 16587 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/9e/dc1fd7f838dcaf608c465171b1a25d8ce63f9987e2d5c73bda98792097a9/google_cloud_appengine_logging-1.6.2-py3-none-any.whl", hash = "sha256:2b28ed715e92b67e334c6fcfe1deb523f001919560257b25fc8fcda95fd63938", size = 16889 },
-]
-
-[[package]]
-name = "google-cloud-audit-log"
-version = "0.3.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/85/af/53b4ef636e492d136b3c217e52a07bee569430dda07b8e515d5f2b701b1e/google_cloud_audit_log-0.3.2.tar.gz", hash = "sha256:2598f1533a7d7cdd6c7bf448c12e5519c1d53162d78784e10bcdd1df67791bc3", size = 33377 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/74/38a70339e706b174b3c1117ad931aaa0ff0565b599869317a220d1967e1b/google_cloud_audit_log-0.3.2-py3-none-any.whl", hash = "sha256:daaedfb947a0d77f524e1bd2b560242ab4836fe1afd6b06b92f152b9658554ed", size = 32472 },
-]
-
-[[package]]
-name = "google-cloud-bigquery"
-version = "3.34.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "google-cloud-core" },
-    { name = "google-resumable-media" },
-    { name = "packaging" },
-    { name = "python-dateutil" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/24/f9/e9da2d56d7028f05c0e2f5edf6ce43c773220c3172666c3dd925791d763d/google_cloud_bigquery-3.34.0.tar.gz", hash = "sha256:5ee1a78ba5c2ccb9f9a8b2bf3ed76b378ea68f49b6cac0544dc55cc97ff7c1ce", size = 489091 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/7e/7115c4f67ca0bc678f25bff1eab56cc37d06eb9a3978940b2ebd0705aa0a/google_cloud_bigquery-3.34.0-py3-none-any.whl", hash = "sha256:de20ded0680f8136d92ff5256270b5920dfe4fae479f5d0f73e90e5df30b1cf7", size = 253555 },
-]
-
-[[package]]
-name = "google-cloud-core"
-version = "2.4.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/b8/2b53838d2acd6ec6168fd284a990c76695e84c65deee79c9f3a4276f6b4f/google_cloud_core-2.4.3.tar.gz", hash = "sha256:1fab62d7102844b278fe6dead3af32408b1df3eb06f5c7e8634cbd40edc4da53", size = 35861 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/40/86/bda7241a8da2d28a754aad2ba0f6776e35b67e37c36ae0c45d49370f1014/google_cloud_core-2.4.3-py2.py3-none-any.whl", hash = "sha256:5130f9f4c14b4fafdff75c79448f9495cfade0d8775facf1b09c3bf67e027f6e", size = 29348 },
-]
-
-[[package]]
-name = "google-cloud-logging"
-version = "3.12.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "google-cloud-appengine-logging" },
-    { name = "google-cloud-audit-log" },
-    { name = "google-cloud-core" },
-    { name = "grpc-google-iam-v1" },
-    { name = "opentelemetry-api" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/14/9c/d42ecc94f795a6545930e5f846a7ae59ff685ded8bc086648dd2bee31a1a/google_cloud_logging-3.12.1.tar.gz", hash = "sha256:36efc823985055b203904e83e1c8f9f999b3c64270bcda39d57386ca4effd678", size = 289569 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/41/f8a3197d39b773a91f335dee36c92ef26a8ec96efe78d64baad89d367df4/google_cloud_logging-3.12.1-py2.py3-none-any.whl", hash = "sha256:6817878af76ec4e7568976772839ab2c43ddfd18fbbf2ce32b13ef549cd5a862", size = 229466 },
-]
-
-[[package]]
-name = "google-cloud-resource-manager"
-version = "1.14.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "grpc-google-iam-v1" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/ca/a4648f5038cb94af4b3942815942a03aa9398f9fb0bef55b3f1585b9940d/google_cloud_resource_manager-1.14.2.tar.gz", hash = "sha256:962e2d904c550d7bac48372607904ff7bb3277e3bb4a36d80cc9a37e28e6eb74", size = 446370 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/ea/a92631c358da377af34d3a9682c97af83185c2d66363d5939ab4a1169a7f/google_cloud_resource_manager-1.14.2-py3-none-any.whl", hash = "sha256:d0fa954dedd1d2b8e13feae9099c01b8aac515b648e612834f9942d2795a9900", size = 394344 },
-]
-
-[[package]]
-name = "google-cloud-secret-manager"
-version = "2.24.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "grpc-google-iam-v1" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/58/7a/2fa6735ec693d822fe08a76709c4d95d9b5b4c02e83e720497355039d2ee/google_cloud_secret_manager-2.24.0.tar.gz", hash = "sha256:ce573d40ffc2fb7d01719243a94ee17aa243ea642a6ae6c337501e58fbf642b5", size = 269516 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/af/db1217cae1809e69a4527ee6293b82a9af2a1fb2313ad110c775e8f3c820/google_cloud_secret_manager-2.24.0-py3-none-any.whl", hash = "sha256:9bea1254827ecc14874bc86c63b899489f8f50bfe1442bfb2517530b30b3a89b", size = 218050 },
-]
-
-[[package]]
-name = "google-cloud-speech"
-version = "2.33.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/74/9c5a556f8af19cab461058aa15e1409e7afa453ca2383473a24a12801ef7/google_cloud_speech-2.33.0.tar.gz", hash = "sha256:fd08511b5124fdaa768d71a4054e84a5d8eb02531cb6f84f311c0387ea1314ed", size = 389072 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/1d/880342b2541b4bad888ad8ab2ac77d4b5dad25b32a2a1c5f21140c14c8e3/google_cloud_speech-2.33.0-py3-none-any.whl", hash = "sha256:4ba16c8517c24a6abcde877289b0f40b719090504bf06b1adea248198ccd50a5", size = 335681 },
-]
-
-[[package]]
-name = "google-cloud-storage"
-version = "2.19.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core" },
-    { name = "google-auth" },
-    { name = "google-cloud-core" },
-    { name = "google-crc32c" },
-    { name = "google-resumable-media" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/36/76/4d965702e96bb67976e755bed9828fa50306dca003dbee08b67f41dd265e/google_cloud_storage-2.19.0.tar.gz", hash = "sha256:cd05e9e7191ba6cb68934d8eb76054d9be4562aa89dbc4236feee4d7d51342b2", size = 5535488 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/94/6db383d8ee1adf45dc6c73477152b82731fa4c4a46d9c1932cc8757e0fd4/google_cloud_storage-2.19.0-py2.py3-none-any.whl", hash = "sha256:aeb971b5c29cf8ab98445082cbfe7b161a1f48ed275822f59ed3f1524ea54fba", size = 131787 },
-]
-
-[[package]]
-name = "google-cloud-trace"
-version = "1.16.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-api-core", extra = ["grpc"] },
-    { name = "google-auth" },
-    { name = "proto-plus" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c5/ea/0e42e2196fb2bc8c7b25f081a0b46b5053d160b34d5322e7eac2d5f7a742/google_cloud_trace-1.16.2.tar.gz", hash = "sha256:89bef223a512465951eb49335be6d60bee0396d576602dbf56368439d303cab4", size = 97826 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/96/7a8d271e91effa9ccc2fd7cfd5cf287a2d7900080a475477c2ac0c7a331d/google_cloud_trace-1.16.2-py3-none-any.whl", hash = "sha256:40fb74607752e4ee0f3d7e5fc6b8f6eb1803982254a1507ba918172484131456", size = 103755 },
-]
-
-[[package]]
-name = "google-crc32c"
-version = "1.7.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/ae/87802e6d9f9d69adfaedfcfd599266bf386a54d0be058b532d04c794f76d/google_crc32c-1.7.1.tar.gz", hash = "sha256:2bff2305f98846f3e825dbeec9ee406f89da7962accdb29356e4eadc251bd472", size = 14495 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/69/b1b05cf415df0d86691d6a8b4b7e60ab3a6fb6efb783ee5cd3ed1382bfd3/google_crc32c-1.7.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:b07d48faf8292b4db7c3d64ab86f950c2e94e93a11fd47271c28ba458e4a0d76", size = 30467 },
-    { url = "https://files.pythonhosted.org/packages/44/3d/92f8928ecd671bd5b071756596971c79d252d09b835cdca5a44177fa87aa/google_crc32c-1.7.1-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:7cc81b3a2fbd932a4313eb53cc7d9dde424088ca3a0337160f35d91826880c1d", size = 30311 },
-    { url = "https://files.pythonhosted.org/packages/33/42/c2d15a73df79d45ed6b430b9e801d0bd8e28ac139a9012d7d58af50a385d/google_crc32c-1.7.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1c67ca0a1f5b56162951a9dae987988679a7db682d6f97ce0f6381ebf0fbea4c", size = 37889 },
-    { url = "https://files.pythonhosted.org/packages/57/ea/ac59c86a3c694afd117bb669bde32aaf17d0de4305d01d706495f09cbf19/google_crc32c-1.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc5319db92daa516b653600794d5b9f9439a9a121f3e162f94b0e1891c7933cb", size = 33028 },
-    { url = "https://files.pythonhosted.org/packages/60/44/87e77e8476767a4a93f6cf271157c6d948eacec63688c093580af13b04be/google_crc32c-1.7.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcdf5a64adb747610140572ed18d011896e3b9ae5195f2514b7ff678c80f1603", size = 38026 },
-    { url = "https://files.pythonhosted.org/packages/c8/bf/21ac7bb305cd7c1a6de9c52f71db0868e104a5b573a4977cd9d0ff830f82/google_crc32c-1.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:754561c6c66e89d55754106739e22fdaa93fafa8da7221b29c8b8e8270c6ec8a", size = 33476 },
-    { url = "https://files.pythonhosted.org/packages/f7/94/220139ea87822b6fdfdab4fb9ba81b3fff7ea2c82e2af34adc726085bffc/google_crc32c-1.7.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:6fbab4b935989e2c3610371963ba1b86afb09537fd0c633049be82afe153ac06", size = 30468 },
-    { url = "https://files.pythonhosted.org/packages/94/97/789b23bdeeb9d15dc2904660463ad539d0318286d7633fe2760c10ed0c1c/google_crc32c-1.7.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:ed66cbe1ed9cbaaad9392b5259b3eba4a9e565420d734e6238813c428c3336c9", size = 30313 },
-    { url = "https://files.pythonhosted.org/packages/81/b8/976a2b843610c211e7ccb3e248996a61e87dbb2c09b1499847e295080aec/google_crc32c-1.7.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee6547b657621b6cbed3562ea7826c3e11cab01cd33b74e1f677690652883e77", size = 33048 },
-    { url = "https://files.pythonhosted.org/packages/c9/16/a3842c2cf591093b111d4a5e2bfb478ac6692d02f1b386d2a33283a19dc9/google_crc32c-1.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d68e17bad8f7dd9a49181a1f5a8f4b251c6dbc8cc96fb79f1d321dfd57d66f53", size = 32669 },
-    { url = "https://files.pythonhosted.org/packages/04/17/ed9aba495916fcf5fe4ecb2267ceb851fc5f273c4e4625ae453350cfd564/google_crc32c-1.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:6335de12921f06e1f774d0dd1fbea6bf610abe0887a1638f64d694013138be5d", size = 33476 },
-    { url = "https://files.pythonhosted.org/packages/dd/b7/787e2453cf8639c94b3d06c9d61f512234a82e1d12d13d18584bd3049904/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2d73a68a653c57281401871dd4aeebbb6af3191dcac751a76ce430df4d403194", size = 30470 },
-    { url = "https://files.pythonhosted.org/packages/ed/b4/6042c2b0cbac3ec3a69bb4c49b28d2f517b7a0f4a0232603c42c58e22b44/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:22beacf83baaf59f9d3ab2bbb4db0fb018da8e5aebdce07ef9f09fce8220285e", size = 30315 },
-    { url = "https://files.pythonhosted.org/packages/29/ad/01e7a61a5d059bc57b702d9ff6a18b2585ad97f720bd0a0dbe215df1ab0e/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19eafa0e4af11b0a4eb3974483d55d2d77ad1911e6cf6f832e1574f6781fd337", size = 33180 },
-    { url = "https://files.pythonhosted.org/packages/3b/a5/7279055cf004561894ed3a7bfdf5bf90a53f28fadd01af7cd166e88ddf16/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6d86616faaea68101195c6bdc40c494e4d76f41e07a37ffdef270879c15fb65", size = 32794 },
-    { url = "https://files.pythonhosted.org/packages/0f/d6/77060dbd140c624e42ae3ece3df53b9d811000729a5c821b9fd671ceaac6/google_crc32c-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:b7491bdc0c7564fcf48c0179d2048ab2f7c7ba36b84ccd3a3e1c3f7a72d3bba6", size = 33477 },
-    { url = "https://files.pythonhosted.org/packages/8b/72/b8d785e9184ba6297a8620c8a37cf6e39b81a8ca01bb0796d7cbb28b3386/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:df8b38bdaf1629d62d51be8bdd04888f37c451564c2042d36e5812da9eff3c35", size = 30467 },
-    { url = "https://files.pythonhosted.org/packages/34/25/5f18076968212067c4e8ea95bf3b69669f9fc698476e5f5eb97d5b37999f/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:e42e20a83a29aa2709a0cf271c7f8aefaa23b7ab52e53b322585297bb94d4638", size = 30309 },
-    { url = "https://files.pythonhosted.org/packages/92/83/9228fe65bf70e93e419f38bdf6c5ca5083fc6d32886ee79b450ceefd1dbd/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:905a385140bf492ac300026717af339790921f411c0dfd9aa5a9e69a08ed32eb", size = 33133 },
-    { url = "https://files.pythonhosted.org/packages/c3/ca/1ea2fd13ff9f8955b85e7956872fdb7050c4ace8a2306a6d177edb9cf7fe/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b211ddaf20f7ebeec5c333448582c224a7c90a9d98826fbab82c0ddc11348e6", size = 32773 },
-    { url = "https://files.pythonhosted.org/packages/89/32/a22a281806e3ef21b72db16f948cad22ec68e4bdd384139291e00ff82fe2/google_crc32c-1.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:0f99eaa09a9a7e642a61e06742856eec8b19fc0037832e03f941fe7cf0c8e4db", size = 33475 },
-    { url = "https://files.pythonhosted.org/packages/b8/c5/002975aff514e57fc084ba155697a049b3f9b52225ec3bc0f542871dd524/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32d1da0d74ec5634a05f53ef7df18fc646666a25efaaca9fc7dcfd4caf1d98c3", size = 33243 },
-    { url = "https://files.pythonhosted.org/packages/61/cb/c585282a03a0cea70fcaa1bf55d5d702d0f2351094d663ec3be1c6c67c52/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e10554d4abc5238823112c2ad7e4560f96c7bf3820b202660373d769d9e6e4c9", size = 32870 },
-    { url = "https://files.pythonhosted.org/packages/0b/43/31e57ce04530794917dfe25243860ec141de9fadf4aa9783dffe7dac7c39/google_crc32c-1.7.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8e9afc74168b0b2232fb32dd202c93e46b7d5e4bf03e66ba5dc273bb3559589", size = 28242 },
-    { url = "https://files.pythonhosted.org/packages/eb/f3/8b84cd4e0ad111e63e30eb89453f8dd308e3ad36f42305cf8c202461cdf0/google_crc32c-1.7.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa8136cc14dd27f34a3221c0f16fd42d8a40e4778273e61a3c19aedaa44daf6b", size = 28049 },
-    { url = "https://files.pythonhosted.org/packages/16/1b/1693372bf423ada422f80fd88260dbfd140754adb15cbc4d7e9a68b1cb8e/google_crc32c-1.7.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85fef7fae11494e747c9fd1359a527e5970fc9603c90764843caabd3a16a0a48", size = 28241 },
-    { url = "https://files.pythonhosted.org/packages/fd/3c/2a19a60a473de48717b4efb19398c3f914795b64a96cf3fbe82588044f78/google_crc32c-1.7.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6efb97eb4369d52593ad6f75e7e10d053cf00c48983f7a973105bc70b0ac4d82", size = 28048 },
-]
-
-[[package]]
-name = "google-genai"
-version = "1.20.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "google-auth" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "typing-extensions" },
-    { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/19/12/ad9f08be2ca85122ca50ac69ae70454f18a3c7d840bcc4ed43f517ab47be/google_genai-1.20.0.tar.gz", hash = "sha256:dccca78f765233844b1bd4f1f7a2237d9a76fe6038cf9aa72c0cd991e3c107b5", size = 201550 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b4/08f3ea414060a7e7d4436c08bb22d03dabef74cc05ef13ef8cd846156d5b/google_genai-1.20.0-py3-none-any.whl", hash = "sha256:ccd61d6ebcb14f5c778b817b8010e3955ae4f6ddfeaabf65f42f6d5e3e5a8125", size = 203039 },
-]
-
-[[package]]
-name = "google-resumable-media"
-version = "2.7.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-crc32c" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/58/5a/0efdc02665dca14e0837b62c8a1a93132c264bd02054a15abb2218afe0ae/google_resumable_media-2.7.2.tar.gz", hash = "sha256:5280aed4629f2b60b847b0d42f9857fd4935c11af266744df33d8074cae92fe0", size = 2163099 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/35/b8d3baf8c46695858cb9d8835a53baa1eeb9906ddaf2f728a5f5b640fd1e/google_resumable_media-2.7.2-py2.py3-none-any.whl", hash = "sha256:3ce7551e9fe6d99e9a126101d2536612bb73486721951e9562fee0f90c6ababa", size = 81251 },
-]
-
-[[package]]
-name = "googleapis-common-protos"
-version = "1.70.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530 },
-]
-
-[package.optional-dependencies]
-grpc = [
-    { name = "grpcio" },
-]
-
-[[package]]
-name = "graphviz"
-version = "0.21"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300 },
-]
-
-[[package]]
-name = "greenlet"
-version = "3.2.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c9/92/bb85bd6e80148a4d2e0c59f7c0c2891029f8fd510183afc7d8d2feeed9b6/greenlet-3.2.3.tar.gz", hash = "sha256:8b0dd8ae4c0d6f5e54ee55ba935eeb3d735a9b58a8a1e5b5cbab64e01a39f365", size = 185752 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/db/b4c12cff13ebac2786f4f217f06588bccd8b53d260453404ef22b121fc3a/greenlet-3.2.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:1afd685acd5597349ee6d7a88a8bec83ce13c106ac78c196ee9dde7c04fe87be", size = 268977 },
-    { url = "https://files.pythonhosted.org/packages/52/61/75b4abd8147f13f70986df2801bf93735c1bd87ea780d70e3b3ecda8c165/greenlet-3.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:761917cac215c61e9dc7324b2606107b3b292a8349bdebb31503ab4de3f559ac", size = 627351 },
-    { url = "https://files.pythonhosted.org/packages/35/aa/6894ae299d059d26254779a5088632874b80ee8cf89a88bca00b0709d22f/greenlet-3.2.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:a433dbc54e4a37e4fff90ef34f25a8c00aed99b06856f0119dcf09fbafa16392", size = 638599 },
-    { url = "https://files.pythonhosted.org/packages/30/64/e01a8261d13c47f3c082519a5e9dbf9e143cc0498ed20c911d04e54d526c/greenlet-3.2.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:72e77ed69312bab0434d7292316d5afd6896192ac4327d44f3d613ecb85b037c", size = 634482 },
-    { url = "https://files.pythonhosted.org/packages/47/48/ff9ca8ba9772d083a4f5221f7b4f0ebe8978131a9ae0909cf202f94cd879/greenlet-3.2.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:68671180e3849b963649254a882cd544a3c75bfcd2c527346ad8bb53494444db", size = 633284 },
-    { url = "https://files.pythonhosted.org/packages/e9/45/626e974948713bc15775b696adb3eb0bd708bec267d6d2d5c47bb47a6119/greenlet-3.2.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49c8cfb18fb419b3d08e011228ef8a25882397f3a859b9fe1436946140b6756b", size = 582206 },
-    { url = "https://files.pythonhosted.org/packages/b1/8e/8b6f42c67d5df7db35b8c55c9a850ea045219741bb14416255616808c690/greenlet-3.2.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:efc6dc8a792243c31f2f5674b670b3a95d46fa1c6a912b8e310d6f542e7b0712", size = 1111412 },
-    { url = "https://files.pythonhosted.org/packages/05/46/ab58828217349500a7ebb81159d52ca357da747ff1797c29c6023d79d798/greenlet-3.2.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:731e154aba8e757aedd0781d4b240f1225b075b4409f1bb83b05ff410582cf00", size = 1135054 },
-    { url = "https://files.pythonhosted.org/packages/68/7f/d1b537be5080721c0f0089a8447d4ef72839039cdb743bdd8ffd23046e9a/greenlet-3.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:96c20252c2f792defe9a115d3287e14811036d51e78b3aaddbee23b69b216302", size = 296573 },
-    { url = "https://files.pythonhosted.org/packages/fc/2e/d4fcb2978f826358b673f779f78fa8a32ee37df11920dc2bb5589cbeecef/greenlet-3.2.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:784ae58bba89fa1fa5733d170d42486580cab9decda3484779f4759345b29822", size = 270219 },
-    { url = "https://files.pythonhosted.org/packages/16/24/929f853e0202130e4fe163bc1d05a671ce8dcd604f790e14896adac43a52/greenlet-3.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0921ac4ea42a5315d3446120ad48f90c3a6b9bb93dd9b3cf4e4d84a66e42de83", size = 630383 },
-    { url = "https://files.pythonhosted.org/packages/d1/b2/0320715eb61ae70c25ceca2f1d5ae620477d246692d9cc284c13242ec31c/greenlet-3.2.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:d2971d93bb99e05f8c2c0c2f4aa9484a18d98c4c3bd3c62b65b7e6ae33dfcfaf", size = 642422 },
-    { url = "https://files.pythonhosted.org/packages/bd/49/445fd1a210f4747fedf77615d941444349c6a3a4a1135bba9701337cd966/greenlet-3.2.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c667c0bf9d406b77a15c924ef3285e1e05250948001220368e039b6aa5b5034b", size = 638375 },
-    { url = "https://files.pythonhosted.org/packages/7e/c8/ca19760cf6eae75fa8dc32b487e963d863b3ee04a7637da77b616703bc37/greenlet-3.2.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:592c12fb1165be74592f5de0d70f82bc5ba552ac44800d632214b76089945147", size = 637627 },
-    { url = "https://files.pythonhosted.org/packages/65/89/77acf9e3da38e9bcfca881e43b02ed467c1dedc387021fc4d9bd9928afb8/greenlet-3.2.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29e184536ba333003540790ba29829ac14bb645514fbd7e32af331e8202a62a5", size = 585502 },
-    { url = "https://files.pythonhosted.org/packages/97/c6/ae244d7c95b23b7130136e07a9cc5aadd60d59b5951180dc7dc7e8edaba7/greenlet-3.2.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:93c0bb79844a367782ec4f429d07589417052e621aa39a5ac1fb99c5aa308edc", size = 1114498 },
-    { url = "https://files.pythonhosted.org/packages/89/5f/b16dec0cbfd3070658e0d744487919740c6d45eb90946f6787689a7efbce/greenlet-3.2.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:751261fc5ad7b6705f5f76726567375bb2104a059454e0226e1eef6c756748ba", size = 1139977 },
-    { url = "https://files.pythonhosted.org/packages/66/77/d48fb441b5a71125bcac042fc5b1494c806ccb9a1432ecaa421e72157f77/greenlet-3.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:83a8761c75312361aa2b5b903b79da97f13f556164a7dd2d5448655425bd4c34", size = 297017 },
-    { url = "https://files.pythonhosted.org/packages/f3/94/ad0d435f7c48debe960c53b8f60fb41c2026b1d0fa4a99a1cb17c3461e09/greenlet-3.2.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:25ad29caed5783d4bd7a85c9251c651696164622494c00802a139c00d639242d", size = 271992 },
-    { url = "https://files.pythonhosted.org/packages/93/5d/7c27cf4d003d6e77749d299c7c8f5fd50b4f251647b5c2e97e1f20da0ab5/greenlet-3.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88cd97bf37fe24a6710ec6a3a7799f3f81d9cd33317dcf565ff9950c83f55e0b", size = 638820 },
-    { url = "https://files.pythonhosted.org/packages/c6/7e/807e1e9be07a125bb4c169144937910bf59b9d2f6d931578e57f0bce0ae2/greenlet-3.2.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:baeedccca94880d2f5666b4fa16fc20ef50ba1ee353ee2d7092b383a243b0b0d", size = 653046 },
-    { url = "https://files.pythonhosted.org/packages/9d/ab/158c1a4ea1068bdbc78dba5a3de57e4c7aeb4e7fa034320ea94c688bfb61/greenlet-3.2.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:be52af4b6292baecfa0f397f3edb3c6092ce071b499dd6fe292c9ac9f2c8f264", size = 647701 },
-    { url = "https://files.pythonhosted.org/packages/cc/0d/93729068259b550d6a0288da4ff72b86ed05626eaf1eb7c0d3466a2571de/greenlet-3.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0cc73378150b8b78b0c9fe2ce56e166695e67478550769536a6742dca3651688", size = 649747 },
-    { url = "https://files.pythonhosted.org/packages/f6/f6/c82ac1851c60851302d8581680573245c8fc300253fc1ff741ae74a6c24d/greenlet-3.2.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:706d016a03e78df129f68c4c9b4c4f963f7d73534e48a24f5f5a7101ed13dbbb", size = 605461 },
-    { url = "https://files.pythonhosted.org/packages/98/82/d022cf25ca39cf1200650fc58c52af32c90f80479c25d1cbf57980ec3065/greenlet-3.2.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:419e60f80709510c343c57b4bb5a339d8767bf9aef9b8ce43f4f143240f88b7c", size = 1121190 },
-    { url = "https://files.pythonhosted.org/packages/f5/e1/25297f70717abe8104c20ecf7af0a5b82d2f5a980eb1ac79f65654799f9f/greenlet-3.2.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:93d48533fade144203816783373f27a97e4193177ebaaf0fc396db19e5d61163", size = 1149055 },
-    { url = "https://files.pythonhosted.org/packages/1f/8f/8f9e56c5e82eb2c26e8cde787962e66494312dc8cb261c460e1f3a9c88bc/greenlet-3.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:7454d37c740bb27bdeddfc3f358f26956a07d5220818ceb467a483197d84f849", size = 297817 },
-    { url = "https://files.pythonhosted.org/packages/b1/cf/f5c0b23309070ae93de75c90d29300751a5aacefc0a3ed1b1d8edb28f08b/greenlet-3.2.3-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:500b8689aa9dd1ab26872a34084503aeddefcb438e2e7317b89b11eaea1901ad", size = 270732 },
-    { url = "https://files.pythonhosted.org/packages/48/ae/91a957ba60482d3fecf9be49bc3948f341d706b52ddb9d83a70d42abd498/greenlet-3.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a07d3472c2a93117af3b0136f246b2833fdc0b542d4a9799ae5f41c28323faef", size = 639033 },
-    { url = "https://files.pythonhosted.org/packages/6f/df/20ffa66dd5a7a7beffa6451bdb7400d66251374ab40b99981478c69a67a8/greenlet-3.2.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:8704b3768d2f51150626962f4b9a9e4a17d2e37c8a8d9867bbd9fa4eb938d3b3", size = 652999 },
-    { url = "https://files.pythonhosted.org/packages/51/b4/ebb2c8cb41e521f1d72bf0465f2f9a2fd803f674a88db228887e6847077e/greenlet-3.2.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5035d77a27b7c62db6cf41cf786cfe2242644a7a337a0e155c80960598baab95", size = 647368 },
-    { url = "https://files.pythonhosted.org/packages/8e/6a/1e1b5aa10dced4ae876a322155705257748108b7fd2e4fae3f2a091fe81a/greenlet-3.2.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2d8aa5423cd4a396792f6d4580f88bdc6efcb9205891c9d40d20f6e670992efb", size = 650037 },
-    { url = "https://files.pythonhosted.org/packages/26/f2/ad51331a157c7015c675702e2d5230c243695c788f8f75feba1af32b3617/greenlet-3.2.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c724620a101f8170065d7dded3f962a2aea7a7dae133a009cada42847e04a7b", size = 608402 },
-    { url = "https://files.pythonhosted.org/packages/26/bc/862bd2083e6b3aff23300900a956f4ea9a4059de337f5c8734346b9b34fc/greenlet-3.2.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:873abe55f134c48e1f2a6f53f7d1419192a3d1a4e873bace00499a4e45ea6af0", size = 1119577 },
-    { url = "https://files.pythonhosted.org/packages/86/94/1fc0cc068cfde885170e01de40a619b00eaa8f2916bf3541744730ffb4c3/greenlet-3.2.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:024571bbce5f2c1cfff08bf3fbaa43bbc7444f580ae13b0099e95d0e6e67ed36", size = 1147121 },
-    { url = "https://files.pythonhosted.org/packages/27/1a/199f9587e8cb08a0658f9c30f3799244307614148ffe8b1e3aa22f324dea/greenlet-3.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:5195fb1e75e592dd04ce79881c8a22becdfa3e6f500e7feb059b1e6fdd54d3e3", size = 297603 },
-    { url = "https://files.pythonhosted.org/packages/d8/ca/accd7aa5280eb92b70ed9e8f7fd79dc50a2c21d8c73b9a0856f5b564e222/greenlet-3.2.3-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:3d04332dddb10b4a211b68111dabaee2e1a073663d117dc10247b5b1642bac86", size = 271479 },
-    { url = "https://files.pythonhosted.org/packages/55/71/01ed9895d9eb49223280ecc98a557585edfa56b3d0e965b9fa9f7f06b6d9/greenlet-3.2.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8186162dffde068a465deab08fc72c767196895c39db26ab1c17c0b77a6d8b97", size = 683952 },
-    { url = "https://files.pythonhosted.org/packages/ea/61/638c4bdf460c3c678a0a1ef4c200f347dff80719597e53b5edb2fb27ab54/greenlet-3.2.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f4bfbaa6096b1b7a200024784217defedf46a07c2eee1a498e94a1b5f8ec5728", size = 696917 },
-    { url = "https://files.pythonhosted.org/packages/22/cc/0bd1a7eb759d1f3e3cc2d1bc0f0b487ad3cc9f34d74da4b80f226fde4ec3/greenlet-3.2.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:ed6cfa9200484d234d8394c70f5492f144b20d4533f69262d530a1a082f6ee9a", size = 692443 },
-    { url = "https://files.pythonhosted.org/packages/67/10/b2a4b63d3f08362662e89c103f7fe28894a51ae0bc890fabf37d1d780e52/greenlet-3.2.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:02b0df6f63cd15012bed5401b47829cfd2e97052dc89da3cfaf2c779124eb892", size = 692995 },
-    { url = "https://files.pythonhosted.org/packages/5a/c6/ad82f148a4e3ce9564056453a71529732baf5448ad53fc323e37efe34f66/greenlet-3.2.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86c2d68e87107c1792e2e8d5399acec2487a4e993ab76c792408e59394d52141", size = 655320 },
-    { url = "https://files.pythonhosted.org/packages/5c/4f/aab73ecaa6b3086a4c89863d94cf26fa84cbff63f52ce9bc4342b3087a06/greenlet-3.2.3-cp314-cp314-win_amd64.whl", hash = "sha256:8c47aae8fbbfcf82cc13327ae802ba13c9c36753b67e760023fd116bc124a62a", size = 301236 },
-]
-
-[[package]]
-name = "grpc-google-iam-v1"
-version = "0.14.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos", extra = ["grpc"] },
-    { name = "grpcio" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/4e/8d0ca3b035e41fe0b3f31ebbb638356af720335e5a11154c330169b40777/grpc_google_iam_v1-0.14.2.tar.gz", hash = "sha256:b3e1fc387a1a329e41672197d0ace9de22c78dd7d215048c4c78712073f7bd20", size = 16259 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/6f/dd9b178aee7835b96c2e63715aba6516a9d50f6bebbd1cc1d32c82a2a6c3/grpc_google_iam_v1-0.14.2-py3-none-any.whl", hash = "sha256:a3171468459770907926d56a440b2bb643eec1d7ba215f48f3ecece42b4d8351", size = 19242 },
-]
-
-[[package]]
-name = "grpcio"
-version = "1.73.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/79/e8/b43b851537da2e2f03fa8be1aef207e5cbfb1a2e014fbb6b40d24c177cd3/grpcio-1.73.1.tar.gz", hash = "sha256:7fce2cd1c0c1116cf3850564ebfc3264fba75d3c74a7414373f1238ea365ef87", size = 12730355 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/51/a5748ab2773d893d099b92653039672f7e26dd35741020972b84d604066f/grpcio-1.73.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:2d70f4ddd0a823436c2624640570ed6097e40935c9194482475fe8e3d9754d55", size = 5365087 },
-    { url = "https://files.pythonhosted.org/packages/ae/12/c5ee1a5dfe93dbc2eaa42a219e2bf887250b52e2e2ee5c036c4695f2769c/grpcio-1.73.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:3841a8a5a66830261ab6a3c2a3dc539ed84e4ab019165f77b3eeb9f0ba621f26", size = 10608921 },
-    { url = "https://files.pythonhosted.org/packages/c4/6d/b0c6a8120f02b7d15c5accda6bfc43bc92be70ada3af3ba6d8e077c00374/grpcio-1.73.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:628c30f8e77e0258ab788750ec92059fc3d6628590fb4b7cea8c102503623ed7", size = 5803221 },
-    { url = "https://files.pythonhosted.org/packages/a6/7a/3c886d9f1c1e416ae81f7f9c7d1995ae72cd64712d29dab74a6bafacb2d2/grpcio-1.73.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:67a0468256c9db6d5ecb1fde4bf409d016f42cef649323f0a08a72f352d1358b", size = 6444603 },
-    { url = "https://files.pythonhosted.org/packages/42/07/f143a2ff534982c9caa1febcad1c1073cdec732f6ac7545d85555a900a7e/grpcio-1.73.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68b84d65bbdebd5926eb5c53b0b9ec3b3f83408a30e4c20c373c5337b4219ec5", size = 6040969 },
-    { url = "https://files.pythonhosted.org/packages/fb/0f/523131b7c9196d0718e7b2dac0310eb307b4117bdbfef62382e760f7e8bb/grpcio-1.73.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:c54796ca22b8349cc594d18b01099e39f2b7ffb586ad83217655781a350ce4da", size = 6132201 },
-    { url = "https://files.pythonhosted.org/packages/ad/18/010a055410eef1d3a7a1e477ec9d93b091ac664ad93e9c5f56d6cc04bdee/grpcio-1.73.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:75fc8e543962ece2f7ecd32ada2d44c0c8570ae73ec92869f9af8b944863116d", size = 6774718 },
-    { url = "https://files.pythonhosted.org/packages/16/11/452bfc1ab39d8ee748837ab8ee56beeae0290861052948785c2c445fb44b/grpcio-1.73.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6a6037891cd2b1dd1406b388660522e1565ed340b1fea2955b0234bdd941a862", size = 6304362 },
-    { url = "https://files.pythonhosted.org/packages/1e/1c/c75ceee626465721e5cb040cf4b271eff817aa97388948660884cb7adffa/grpcio-1.73.1-cp310-cp310-win32.whl", hash = "sha256:cce7265b9617168c2d08ae570fcc2af4eaf72e84f8c710ca657cc546115263af", size = 3679036 },
-    { url = "https://files.pythonhosted.org/packages/62/2e/42cb31b6cbd671a7b3dbd97ef33f59088cf60e3cf2141368282e26fafe79/grpcio-1.73.1-cp310-cp310-win_amd64.whl", hash = "sha256:6a2b372e65fad38842050943f42ce8fee00c6f2e8ea4f7754ba7478d26a356ee", size = 4340208 },
-    { url = "https://files.pythonhosted.org/packages/e4/41/921565815e871d84043e73e2c0e748f0318dab6fa9be872cd042778f14a9/grpcio-1.73.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:ba2cea9f7ae4bc21f42015f0ec98f69ae4179848ad744b210e7685112fa507a1", size = 5363853 },
-    { url = "https://files.pythonhosted.org/packages/b0/cc/9c51109c71d068e4d474becf5f5d43c9d63038cec1b74112978000fa72f4/grpcio-1.73.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:d74c3f4f37b79e746271aa6cdb3a1d7e4432aea38735542b23adcabaaee0c097", size = 10621476 },
-    { url = "https://files.pythonhosted.org/packages/8f/d3/33d738a06f6dbd4943f4d377468f8299941a7c8c6ac8a385e4cef4dd3c93/grpcio-1.73.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:5b9b1805a7d61c9e90541cbe8dfe0a593dfc8c5c3a43fe623701b6a01b01d710", size = 5807903 },
-    { url = "https://files.pythonhosted.org/packages/5d/47/36deacd3c967b74e0265f4c608983e897d8bb3254b920f8eafdf60e4ad7e/grpcio-1.73.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3215f69a0670a8cfa2ab53236d9e8026bfb7ead5d4baabe7d7dc11d30fda967", size = 6448172 },
-    { url = "https://files.pythonhosted.org/packages/0e/64/12d6dc446021684ee1428ea56a3f3712048a18beeadbdefa06e6f8814a6e/grpcio-1.73.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc5eccfd9577a5dc7d5612b2ba90cca4ad14c6d949216c68585fdec9848befb1", size = 6044226 },
-    { url = "https://files.pythonhosted.org/packages/72/4b/6bae2d88a006000f1152d2c9c10ffd41d0131ca1198e0b661101c2e30ab9/grpcio-1.73.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:dc7d7fd520614fce2e6455ba89791458020a39716951c7c07694f9dbae28e9c0", size = 6135690 },
-    { url = "https://files.pythonhosted.org/packages/38/64/02c83b5076510784d1305025e93e0d78f53bb6a0213c8c84cfe8a00c5c48/grpcio-1.73.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:105492124828911f85127e4825d1c1234b032cb9d238567876b5515d01151379", size = 6775867 },
-    { url = "https://files.pythonhosted.org/packages/42/72/a13ff7ba6c68ccffa35dacdc06373a76c0008fd75777cba84d7491956620/grpcio-1.73.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:610e19b04f452ba6f402ac9aa94eb3d21fbc94553368008af634812c4a85a99e", size = 6308380 },
-    { url = "https://files.pythonhosted.org/packages/65/ae/d29d948021faa0070ec33245c1ae354e2aefabd97e6a9a7b6dcf0fb8ef6b/grpcio-1.73.1-cp311-cp311-win32.whl", hash = "sha256:d60588ab6ba0ac753761ee0e5b30a29398306401bfbceffe7d68ebb21193f9d4", size = 3679139 },
-    { url = "https://files.pythonhosted.org/packages/af/66/e1bbb0c95ea222947f0829b3db7692c59b59bcc531df84442e413fa983d9/grpcio-1.73.1-cp311-cp311-win_amd64.whl", hash = "sha256:6957025a4608bb0a5ff42abd75bfbb2ed99eda29d5992ef31d691ab54b753643", size = 4342558 },
-    { url = "https://files.pythonhosted.org/packages/b8/41/456caf570c55d5ac26f4c1f2db1f2ac1467d5bf3bcd660cba3e0a25b195f/grpcio-1.73.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:921b25618b084e75d424a9f8e6403bfeb7abef074bb6c3174701e0f2542debcf", size = 5334621 },
-    { url = "https://files.pythonhosted.org/packages/2a/c2/9a15e179e49f235bb5e63b01590658c03747a43c9775e20c4e13ca04f4c4/grpcio-1.73.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:277b426a0ed341e8447fbf6c1d6b68c952adddf585ea4685aa563de0f03df887", size = 10601131 },
-    { url = "https://files.pythonhosted.org/packages/0c/1d/1d39e90ef6348a0964caa7c5c4d05f3bae2c51ab429eb7d2e21198ac9b6d/grpcio-1.73.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:96c112333309493c10e118d92f04594f9055774757f5d101b39f8150f8c25582", size = 5759268 },
-    { url = "https://files.pythonhosted.org/packages/8a/2b/2dfe9ae43de75616177bc576df4c36d6401e0959833b2e5b2d58d50c1f6b/grpcio-1.73.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f48e862aed925ae987eb7084409a80985de75243389dc9d9c271dd711e589918", size = 6409791 },
-    { url = "https://files.pythonhosted.org/packages/6e/66/e8fe779b23b5a26d1b6949e5c70bc0a5fd08f61a6ec5ac7760d589229511/grpcio-1.73.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83a6c2cce218e28f5040429835fa34a29319071079e3169f9543c3fbeff166d2", size = 6003728 },
-    { url = "https://files.pythonhosted.org/packages/a9/39/57a18fcef567784108c4fc3f5441cb9938ae5a51378505aafe81e8e15ecc/grpcio-1.73.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:65b0458a10b100d815a8426b1442bd17001fdb77ea13665b2f7dc9e8587fdc6b", size = 6103364 },
-    { url = "https://files.pythonhosted.org/packages/c5/46/28919d2aa038712fc399d02fa83e998abd8c1f46c2680c5689deca06d1b2/grpcio-1.73.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:0a9f3ea8dce9eae9d7cb36827200133a72b37a63896e0e61a9d5ec7d61a59ab1", size = 6749194 },
-    { url = "https://files.pythonhosted.org/packages/3d/56/3898526f1fad588c5d19a29ea0a3a4996fb4fa7d7c02dc1be0c9fd188b62/grpcio-1.73.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:de18769aea47f18e782bf6819a37c1c528914bfd5683b8782b9da356506190c8", size = 6283902 },
-    { url = "https://files.pythonhosted.org/packages/dc/64/18b77b89c5870d8ea91818feb0c3ffb5b31b48d1b0ee3e0f0d539730fea3/grpcio-1.73.1-cp312-cp312-win32.whl", hash = "sha256:24e06a5319e33041e322d32c62b1e728f18ab8c9dbc91729a3d9f9e3ed336642", size = 3668687 },
-    { url = "https://files.pythonhosted.org/packages/3c/52/302448ca6e52f2a77166b2e2ed75f5d08feca4f2145faf75cb768cccb25b/grpcio-1.73.1-cp312-cp312-win_amd64.whl", hash = "sha256:303c8135d8ab176f8038c14cc10d698ae1db9c480f2b2823f7a987aa2a4c5646", size = 4334887 },
-    { url = "https://files.pythonhosted.org/packages/37/bf/4ca20d1acbefabcaba633ab17f4244cbbe8eca877df01517207bd6655914/grpcio-1.73.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:b310824ab5092cf74750ebd8a8a8981c1810cb2b363210e70d06ef37ad80d4f9", size = 5335615 },
-    { url = "https://files.pythonhosted.org/packages/75/ed/45c345f284abec5d4f6d77cbca9c52c39b554397eb7de7d2fcf440bcd049/grpcio-1.73.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:8f5a6df3fba31a3485096ac85b2e34b9666ffb0590df0cd044f58694e6a1f6b5", size = 10595497 },
-    { url = "https://files.pythonhosted.org/packages/a4/75/bff2c2728018f546d812b755455014bc718f8cdcbf5c84f1f6e5494443a8/grpcio-1.73.1-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:052e28fe9c41357da42250a91926a3e2f74c046575c070b69659467ca5aa976b", size = 5765321 },
-    { url = "https://files.pythonhosted.org/packages/70/3b/14e43158d3b81a38251b1d231dfb45a9b492d872102a919fbf7ba4ac20cd/grpcio-1.73.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c0bf15f629b1497436596b1cbddddfa3234273490229ca29561209778ebe182", size = 6415436 },
-    { url = "https://files.pythonhosted.org/packages/e5/3f/81d9650ca40b54338336fd360f36773be8cb6c07c036e751d8996eb96598/grpcio-1.73.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ab860d5bfa788c5a021fba264802e2593688cd965d1374d31d2b1a34cacd854", size = 6007012 },
-    { url = "https://files.pythonhosted.org/packages/55/f4/59edf5af68d684d0f4f7ad9462a418ac517201c238551529098c9aa28cb0/grpcio-1.73.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:ad1d958c31cc91ab050bd8a91355480b8e0683e21176522bacea225ce51163f2", size = 6105209 },
-    { url = "https://files.pythonhosted.org/packages/e4/a8/700d034d5d0786a5ba14bfa9ce974ed4c976936c2748c2bd87aa50f69b36/grpcio-1.73.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:f43ffb3bd415c57224c7427bfb9e6c46a0b6e998754bfa0d00f408e1873dcbb5", size = 6753655 },
-    { url = "https://files.pythonhosted.org/packages/1f/29/efbd4ac837c23bc48e34bbaf32bd429f0dc9ad7f80721cdb4622144c118c/grpcio-1.73.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:686231cdd03a8a8055f798b2b54b19428cdf18fa1549bee92249b43607c42668", size = 6287288 },
-    { url = "https://files.pythonhosted.org/packages/d8/61/c6045d2ce16624bbe18b5d169c1a5ce4d6c3a47bc9d0e5c4fa6a50ed1239/grpcio-1.73.1-cp313-cp313-win32.whl", hash = "sha256:89018866a096e2ce21e05eabed1567479713ebe57b1db7cbb0f1e3b896793ba4", size = 3668151 },
-    { url = "https://files.pythonhosted.org/packages/c2/d7/77ac689216daee10de318db5aa1b88d159432dc76a130948a56b3aa671a2/grpcio-1.73.1-cp313-cp313-win_amd64.whl", hash = "sha256:4a68f8c9966b94dff693670a5cf2b54888a48a5011c5d9ce2295a1a1465ee84f", size = 4335747 },
-]
-
-[[package]]
-name = "grpcio-status"
-version = "1.73.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos" },
-    { name = "grpcio" },
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/59/9350a13804f2e407d76b3962c548e023639fc1545056e342c6bad0d4fd30/grpcio_status-1.73.1.tar.gz", hash = "sha256:928f49ccf9688db5f20cd9e45c4578a1d01ccca29aeaabf066f2ac76aa886668", size = 13664 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/50/ee32e6073e2c3a4457be168e2bbf84d02ad9d2c18c4a578a641480c293d4/grpcio_status-1.73.1-py3-none-any.whl", hash = "sha256:538595c32a6c819c32b46a621a51e9ae4ffcd7e7e1bce35f728ef3447e9809b6", size = 14422 },
-]
-
-[[package]]
-name = "h11"
-version = "0.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
-]
-
-[[package]]
-name = "httplib2"
-version = "0.22.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyparsing" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/ad/2371116b22d616c194aa25ec410c9c6c37f23599dcd590502b74db197584/httplib2-0.22.0.tar.gz", hash = "sha256:d7a10bc5ef5ab08322488bde8c726eeee5c8618723fdb399597ec58f3d82df81", size = 351116 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/6c/d2fbdaaa5959339d53ba38e94c123e4e84b8fbc4b84beb0e70d7c1608486/httplib2-0.22.0-py3-none-any.whl", hash = "sha256:14ae0a53c1ba8f3d37e9e27cf37eabb0fb9980f435ba405d546948b009dd64dc", size = 96854 },
-]
-
-[[package]]
-name = "httpx"
-version = "0.28.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "certifi" },
-    { name = "httpcore" },
-    { name = "idna" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
-]
-
-[[package]]
-name = "httpx-sse"
-version = "0.4.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6e/fa/66bd985dd0b7c109a3bcb89272ee0bfb7e2b4d06309ad7b38ff866734b2a/httpx_sse-0.4.1.tar.gz", hash = "sha256:8f44d34414bc7b21bf3602713005c5df4917884f76072479b21f68befa4ea26e", size = 12998 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/0a/6269e3473b09aed2dab8aa1a600c70f31f00ae1349bee30658f7e358a159/httpx_sse-0.4.1-py3-none-any.whl", hash = "sha256:cba42174344c3a5b06f255ce65b350880f962d99ead85e776f23c6618a377a37", size = 8054 },
-]
-
-[[package]]
-name = "idna"
-version = "3.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
-]
-
-[[package]]
-name = "importlib-metadata"
-version = "8.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 },
-]
-
-[[package]]
-name = "isodate"
-version = "0.7.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320 },
-]
-
-[[package]]
-name = "jsonschema"
-version = "4.24.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "jsonschema-specifications" },
-    { name = "referencing" },
-    { name = "rpds-py" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/d3/1cf5326b923a53515d8f3a2cd442e6d7e94fcc444716e879ea70a0ce3177/jsonschema-4.24.0.tar.gz", hash = "sha256:0b4e8069eb12aedfa881333004bccaec24ecef5a8a6a4b6df142b2cc9599d196", size = 353480 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/3d/023389198f69c722d039351050738d6755376c8fd343e91dc493ea485905/jsonschema-4.24.0-py3-none-any.whl", hash = "sha256:a462455f19f5faf404a7902952b6f0e3ce868f3ee09a359b05eca6673bd8412d", size = 88709 },
-]
-
-[[package]]
-name = "jsonschema-specifications"
-version = "2025.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "referencing" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/ce/46fbd9c8119cfc3581ee5643ea49464d168028cfb5caff5fc0596d0cf914/jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608", size = 15513 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/0e/b27cdbaccf30b890c40ed1da9fd4a3593a5cf94dae54fb34f8a4b74fcd3f/jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af", size = 18437 },
-]
-
-[[package]]
-name = "markdown-it-py"
-version = "3.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
-]
-
-[[package]]
-name = "mcp"
-version = "1.11.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
-    { name = "jsonschema" },
-    { name = "pydantic" },
-    { name = "pydantic-settings" },
-    { name = "python-multipart" },
-    { name = "pywin32", marker = "sys_platform == 'win32'" },
-    { name = "sse-starlette" },
-    { name = "starlette" },
-    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/f5/9506eb5578d5bbe9819ee8ba3198d0ad0e2fbe3bab8b257e4131ceb7dfb6/mcp-1.11.0.tar.gz", hash = "sha256:49a213df56bb9472ff83b3132a4825f5c8f5b120a90246f08b0dac6bedac44c8", size = 406907 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/9c/c9ca79f9c512e4113a5d07043013110bb3369fc7770040c61378c7fbcf70/mcp-1.11.0-py3-none-any.whl", hash = "sha256:58deac37f7483e4b338524b98bc949b7c2b7c33d978f5fafab5bde041c5e2595", size = 155880 },
-]
-
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
-]
-
-[[package]]
-name = "msal"
-version = "1.32.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cryptography" },
-    { name = "pyjwt", extra = ["crypto"] },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3f/90/81dcc50f0be11a8c4dcbae1a9f761a26e5f905231330a7cacc9f04ec4c61/msal-1.32.3.tar.gz", hash = "sha256:5eea038689c78a5a70ca8ecbe1245458b55a857bd096efb6989c69ba15985d35", size = 151449 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/bf/81516b9aac7fd867709984d08eb4db1d2e3fe1df795c8e442cde9b568962/msal-1.32.3-py3-none-any.whl", hash = "sha256:b2798db57760b1961b142f027ffb7c8169536bf77316e99a0df5c4aaebb11569", size = 115358 },
-]
-
-[[package]]
-name = "msal-extensions"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "msal" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/99/5d239b6156eddf761a636bded1118414d161bd6b7b37a9335549ed159396/msal_extensions-1.3.1.tar.gz", hash = "sha256:c5b0fd10f65ef62b5f1d62f4251d51cbcaf003fcedae8c91b040a488614be1a4", size = 23315 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/75/bd9b7bb966668920f06b200e84454c8f3566b102183bc55c5473d96cb2b9/msal_extensions-1.3.1-py3-none-any.whl", hash = "sha256:96d3de4d034504e969ac5e85bae8106c8373b5c6568e4c8fa7af2eca9dbe6bca", size = 20583 },
-]
-
-[[package]]
-name = "msrest"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "certifi" },
-    { name = "isodate" },
-    { name = "requests" },
-    { name = "requests-oauthlib" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/68/77/8397c8fb8fc257d8ea0fa66f8068e073278c65f05acb17dcb22a02bfdc42/msrest-0.7.1.zip", hash = "sha256:6e7661f46f3afd88b75667b7187a92829924446c7ea1d169be8c4bb7eeb788b9", size = 175332 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/cf/f2966a2638144491f8696c27320d5219f48a072715075d168b31d3237720/msrest-0.7.1-py3-none-any.whl", hash = "sha256:21120a810e1233e5e6cc7fe40b474eeb4ec6f757a15d7cf86702c369f9567c32", size = 85384 },
-]
-
-[[package]]
-name = "numpy"
-version = "2.2.6"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version < '3.11'",
-]
-sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245 },
-    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048 },
-    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542 },
-    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301 },
-    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320 },
-    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050 },
-    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034 },
-    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185 },
-    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149 },
-    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620 },
-    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963 },
-    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743 },
-    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616 },
-    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579 },
-    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005 },
-    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570 },
-    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548 },
-    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521 },
-    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866 },
-    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455 },
-    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348 },
-    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362 },
-    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103 },
-    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382 },
-    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462 },
-    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618 },
-    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511 },
-    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783 },
-    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506 },
-    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190 },
-    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828 },
-    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006 },
-    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765 },
-    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736 },
-    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719 },
-    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072 },
-    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213 },
-    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632 },
-    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532 },
-    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885 },
-    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467 },
-    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144 },
-    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217 },
-    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014 },
-    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935 },
-    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122 },
-    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143 },
-    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260 },
-    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225 },
-    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374 },
-    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391 },
-    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754 },
-    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476 },
-    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666 },
-]
-
-[[package]]
-name = "numpy"
-version = "2.3.1"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version >= '3.13'",
-    "python_full_version >= '3.11' and python_full_version < '3.13'",
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/19/d7c972dfe90a353dbd3efbbe1d14a5951de80c99c9dc1b93cd998d51dc0f/numpy-2.3.1.tar.gz", hash = "sha256:1ec9ae20a4226da374362cca3c62cd753faf2f951440b0e3b98e93c235441d2b", size = 20390372 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/c7/87c64d7ab426156530676000c94784ef55676df2f13b2796f97722464124/numpy-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ea9e48336a402551f52cd8f593343699003d2353daa4b72ce8d34f66b722070", size = 21199346 },
-    { url = "https://files.pythonhosted.org/packages/58/0e/0966c2f44beeac12af8d836e5b5f826a407cf34c45cb73ddcdfce9f5960b/numpy-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ccb7336eaf0e77c1635b232c141846493a588ec9ea777a7c24d7166bb8533ae", size = 14361143 },
-    { url = "https://files.pythonhosted.org/packages/7d/31/6e35a247acb1bfc19226791dfc7d4c30002cd4e620e11e58b0ddf836fe52/numpy-2.3.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0bb3a4a61e1d327e035275d2a993c96fa786e4913aa089843e6a2d9dd205c66a", size = 5378989 },
-    { url = "https://files.pythonhosted.org/packages/b0/25/93b621219bb6f5a2d4e713a824522c69ab1f06a57cd571cda70e2e31af44/numpy-2.3.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:e344eb79dab01f1e838ebb67aab09965fb271d6da6b00adda26328ac27d4a66e", size = 6912890 },
-    { url = "https://files.pythonhosted.org/packages/ef/60/6b06ed98d11fb32e27fb59468b42383f3877146d3ee639f733776b6ac596/numpy-2.3.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:467db865b392168ceb1ef1ffa6f5a86e62468c43e0cfb4ab6da667ede10e58db", size = 14569032 },
-    { url = "https://files.pythonhosted.org/packages/75/c9/9bec03675192077467a9c7c2bdd1f2e922bd01d3a69b15c3a0fdcd8548f6/numpy-2.3.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:afed2ce4a84f6b0fc6c1ce734ff368cbf5a5e24e8954a338f3bdffa0718adffb", size = 16930354 },
-    { url = "https://files.pythonhosted.org/packages/6a/e2/5756a00cabcf50a3f527a0c968b2b4881c62b1379223931853114fa04cda/numpy-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0025048b3c1557a20bc80d06fdeb8cc7fc193721484cca82b2cfa072fec71a93", size = 15879605 },
-    { url = "https://files.pythonhosted.org/packages/ff/86/a471f65f0a86f1ca62dcc90b9fa46174dd48f50214e5446bc16a775646c5/numpy-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5ee121b60aa509679b682819c602579e1df14a5b07fe95671c8849aad8f2115", size = 18666994 },
-    { url = "https://files.pythonhosted.org/packages/43/a6/482a53e469b32be6500aaf61cfafd1de7a0b0d484babf679209c3298852e/numpy-2.3.1-cp311-cp311-win32.whl", hash = "sha256:a8b740f5579ae4585831b3cf0e3b0425c667274f82a484866d2adf9570539369", size = 6603672 },
-    { url = "https://files.pythonhosted.org/packages/6b/fb/bb613f4122c310a13ec67585c70e14b03bfc7ebabd24f4d5138b97371d7c/numpy-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4580adadc53311b163444f877e0789f1c8861e2698f6b2a4ca852fda154f3ff", size = 13024015 },
-    { url = "https://files.pythonhosted.org/packages/51/58/2d842825af9a0c041aca246dc92eb725e1bc5e1c9ac89712625db0c4e11c/numpy-2.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:ec0bdafa906f95adc9a0c6f26a4871fa753f25caaa0e032578a30457bff0af6a", size = 10456989 },
-    { url = "https://files.pythonhosted.org/packages/c6/56/71ad5022e2f63cfe0ca93559403d0edef14aea70a841d640bd13cdba578e/numpy-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2959d8f268f3d8ee402b04a9ec4bb7604555aeacf78b360dc4ec27f1d508177d", size = 20896664 },
-    { url = "https://files.pythonhosted.org/packages/25/65/2db52ba049813670f7f987cc5db6dac9be7cd95e923cc6832b3d32d87cef/numpy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:762e0c0c6b56bdedfef9a8e1d4538556438288c4276901ea008ae44091954e29", size = 14131078 },
-    { url = "https://files.pythonhosted.org/packages/57/dd/28fa3c17b0e751047ac928c1e1b6990238faad76e9b147e585b573d9d1bd/numpy-2.3.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:867ef172a0976aaa1f1d1b63cf2090de8b636a7674607d514505fb7276ab08fc", size = 5112554 },
-    { url = "https://files.pythonhosted.org/packages/c9/fc/84ea0cba8e760c4644b708b6819d91784c290288c27aca916115e3311d17/numpy-2.3.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:4e602e1b8682c2b833af89ba641ad4176053aaa50f5cacda1a27004352dde943", size = 6646560 },
-    { url = "https://files.pythonhosted.org/packages/61/b2/512b0c2ddec985ad1e496b0bd853eeb572315c0f07cd6997473ced8f15e2/numpy-2.3.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8e333040d069eba1652fb08962ec5b76af7f2c7bce1df7e1418c8055cf776f25", size = 14260638 },
-    { url = "https://files.pythonhosted.org/packages/6e/45/c51cb248e679a6c6ab14b7a8e3ead3f4a3fe7425fc7a6f98b3f147bec532/numpy-2.3.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e7cbf5a5eafd8d230a3ce356d892512185230e4781a361229bd902ff403bc660", size = 16632729 },
-    { url = "https://files.pythonhosted.org/packages/e4/ff/feb4be2e5c09a3da161b412019caf47183099cbea1132fd98061808c2df2/numpy-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1b8f26d1086835f442286c1d9b64bb3974b0b1e41bb105358fd07d20872952", size = 15565330 },
-    { url = "https://files.pythonhosted.org/packages/bc/6d/ceafe87587101e9ab0d370e4f6e5f3f3a85b9a697f2318738e5e7e176ce3/numpy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ee8340cb48c9b7a5899d1149eece41ca535513a9698098edbade2a8e7a84da77", size = 18361734 },
-    { url = "https://files.pythonhosted.org/packages/2b/19/0fb49a3ea088be691f040c9bf1817e4669a339d6e98579f91859b902c636/numpy-2.3.1-cp312-cp312-win32.whl", hash = "sha256:e772dda20a6002ef7061713dc1e2585bc1b534e7909b2030b5a46dae8ff077ab", size = 6320411 },
-    { url = "https://files.pythonhosted.org/packages/b1/3e/e28f4c1dd9e042eb57a3eb652f200225e311b608632bc727ae378623d4f8/numpy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfecc7822543abdea6de08758091da655ea2210b8ffa1faf116b940693d3df76", size = 12734973 },
-    { url = "https://files.pythonhosted.org/packages/04/a8/8a5e9079dc722acf53522b8f8842e79541ea81835e9b5483388701421073/numpy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:7be91b2239af2658653c5bb6f1b8bccafaf08226a258caf78ce44710a0160d30", size = 10191491 },
-    { url = "https://files.pythonhosted.org/packages/d4/bd/35ad97006d8abff8631293f8ea6adf07b0108ce6fec68da3c3fcca1197f2/numpy-2.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25a1992b0a3fdcdaec9f552ef10d8103186f5397ab45e2d25f8ac51b1a6b97e8", size = 20889381 },
-    { url = "https://files.pythonhosted.org/packages/f1/4f/df5923874d8095b6062495b39729178eef4a922119cee32a12ee1bd4664c/numpy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7dea630156d39b02a63c18f508f85010230409db5b2927ba59c8ba4ab3e8272e", size = 14152726 },
-    { url = "https://files.pythonhosted.org/packages/8c/0f/a1f269b125806212a876f7efb049b06c6f8772cf0121139f97774cd95626/numpy-2.3.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bada6058dd886061f10ea15f230ccf7dfff40572e99fef440a4a857c8728c9c0", size = 5105145 },
-    { url = "https://files.pythonhosted.org/packages/6d/63/a7f7fd5f375b0361682f6ffbf686787e82b7bbd561268e4f30afad2bb3c0/numpy-2.3.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:a894f3816eb17b29e4783e5873f92faf55b710c2519e5c351767c51f79d8526d", size = 6639409 },
-    { url = "https://files.pythonhosted.org/packages/bf/0d/1854a4121af895aab383f4aa233748f1df4671ef331d898e32426756a8a6/numpy-2.3.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:18703df6c4a4fee55fd3d6e5a253d01c5d33a295409b03fda0c86b3ca2ff41a1", size = 14257630 },
-    { url = "https://files.pythonhosted.org/packages/50/30/af1b277b443f2fb08acf1c55ce9d68ee540043f158630d62cef012750f9f/numpy-2.3.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5902660491bd7a48b2ec16c23ccb9124b8abfd9583c5fdfa123fe6b421e03de1", size = 16627546 },
-    { url = "https://files.pythonhosted.org/packages/6e/ec/3b68220c277e463095342d254c61be8144c31208db18d3fd8ef02712bcd6/numpy-2.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:36890eb9e9d2081137bd78d29050ba63b8dab95dff7912eadf1185e80074b2a0", size = 15562538 },
-    { url = "https://files.pythonhosted.org/packages/77/2b/4014f2bcc4404484021c74d4c5ee8eb3de7e3f7ac75f06672f8dcf85140a/numpy-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a780033466159c2270531e2b8ac063704592a0bc62ec4a1b991c7c40705eb0e8", size = 18360327 },
-    { url = "https://files.pythonhosted.org/packages/40/8d/2ddd6c9b30fcf920837b8672f6c65590c7d92e43084c25fc65edc22e93ca/numpy-2.3.1-cp313-cp313-win32.whl", hash = "sha256:39bff12c076812595c3a306f22bfe49919c5513aa1e0e70fac756a0be7c2a2b8", size = 6312330 },
-    { url = "https://files.pythonhosted.org/packages/dd/c8/beaba449925988d415efccb45bf977ff8327a02f655090627318f6398c7b/numpy-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d5ee6eec45f08ce507a6570e06f2f879b374a552087a4179ea7838edbcbfa42", size = 12731565 },
-    { url = "https://files.pythonhosted.org/packages/0b/c3/5c0c575d7ec78c1126998071f58facfc124006635da75b090805e642c62e/numpy-2.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c4d9e0a8368db90f93bd192bfa771ace63137c3488d198ee21dfb8e7771916e", size = 10190262 },
-    { url = "https://files.pythonhosted.org/packages/ea/19/a029cd335cf72f79d2644dcfc22d90f09caa86265cbbde3b5702ccef6890/numpy-2.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b0b5397374f32ec0649dd98c652a1798192042e715df918c20672c62fb52d4b8", size = 20987593 },
-    { url = "https://files.pythonhosted.org/packages/25/91/8ea8894406209107d9ce19b66314194675d31761fe2cb3c84fe2eeae2f37/numpy-2.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c5bdf2015ccfcee8253fb8be695516ac4457c743473a43290fd36eba6a1777eb", size = 14300523 },
-    { url = "https://files.pythonhosted.org/packages/a6/7f/06187b0066eefc9e7ce77d5f2ddb4e314a55220ad62dd0bfc9f2c44bac14/numpy-2.3.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d70f20df7f08b90a2062c1f07737dd340adccf2068d0f1b9b3d56e2038979fee", size = 5227993 },
-    { url = "https://files.pythonhosted.org/packages/e8/ec/a926c293c605fa75e9cfb09f1e4840098ed46d2edaa6e2152ee35dc01ed3/numpy-2.3.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:2fb86b7e58f9ac50e1e9dd1290154107e47d1eef23a0ae9145ded06ea606f992", size = 6736652 },
-    { url = "https://files.pythonhosted.org/packages/e3/62/d68e52fb6fde5586650d4c0ce0b05ff3a48ad4df4ffd1b8866479d1d671d/numpy-2.3.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:23ab05b2d241f76cb883ce8b9a93a680752fbfcbd51c50eff0b88b979e471d8c", size = 14331561 },
-    { url = "https://files.pythonhosted.org/packages/fc/ec/b74d3f2430960044bdad6900d9f5edc2dc0fb8bf5a0be0f65287bf2cbe27/numpy-2.3.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ce2ce9e5de4703a673e705183f64fd5da5bf36e7beddcb63a25ee2286e71ca48", size = 16693349 },
-    { url = "https://files.pythonhosted.org/packages/0d/15/def96774b9d7eb198ddadfcbd20281b20ebb510580419197e225f5c55c3e/numpy-2.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c4913079974eeb5c16ccfd2b1f09354b8fed7e0d6f2cab933104a09a6419b1ee", size = 15642053 },
-    { url = "https://files.pythonhosted.org/packages/2b/57/c3203974762a759540c6ae71d0ea2341c1fa41d84e4971a8e76d7141678a/numpy-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:010ce9b4f00d5c036053ca684c77441f2f2c934fd23bee058b4d6f196efd8280", size = 18434184 },
-    { url = "https://files.pythonhosted.org/packages/22/8a/ccdf201457ed8ac6245187850aff4ca56a79edbea4829f4e9f14d46fa9a5/numpy-2.3.1-cp313-cp313t-win32.whl", hash = "sha256:6269b9edfe32912584ec496d91b00b6d34282ca1d07eb10e82dfc780907d6c2e", size = 6440678 },
-    { url = "https://files.pythonhosted.org/packages/f1/7e/7f431d8bd8eb7e03d79294aed238b1b0b174b3148570d03a8a8a8f6a0da9/numpy-2.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2a809637460e88a113e186e87f228d74ae2852a2e0c44de275263376f17b5bdc", size = 12870697 },
-    { url = "https://files.pythonhosted.org/packages/d4/ca/af82bf0fad4c3e573c6930ed743b5308492ff19917c7caaf2f9b6f9e2e98/numpy-2.3.1-cp313-cp313t-win_arm64.whl", hash = "sha256:eccb9a159db9aed60800187bc47a6d3451553f0e1b08b068d8b277ddfbb9b244", size = 10260376 },
-    { url = "https://files.pythonhosted.org/packages/e8/34/facc13b9b42ddca30498fc51f7f73c3d0f2be179943a4b4da8686e259740/numpy-2.3.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad506d4b09e684394c42c966ec1527f6ebc25da7f4da4b1b056606ffe446b8a3", size = 21070637 },
-    { url = "https://files.pythonhosted.org/packages/65/b6/41b705d9dbae04649b529fc9bd3387664c3281c7cd78b404a4efe73dcc45/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ebb8603d45bc86bbd5edb0d63e52c5fd9e7945d3a503b77e486bd88dde67a19b", size = 5304087 },
-    { url = "https://files.pythonhosted.org/packages/7a/b4/fe3ac1902bff7a4934a22d49e1c9d71a623204d654d4cc43c6e8fe337fcb/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:15aa4c392ac396e2ad3d0a2680c0f0dee420f9fed14eef09bdb9450ee6dcb7b7", size = 6817588 },
-    { url = "https://files.pythonhosted.org/packages/ae/ee/89bedf69c36ace1ac8f59e97811c1f5031e179a37e4821c3a230bf750142/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c6e0bf9d1a2f50d2b65a7cf56db37c095af17b59f6c132396f7c6d5dd76484df", size = 14399010 },
-    { url = "https://files.pythonhosted.org/packages/15/08/e00e7070ede29b2b176165eba18d6f9784d5349be3c0c1218338e79c27fd/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eabd7e8740d494ce2b4ea0ff05afa1b7b291e978c0ae075487c51e8bd93c0c68", size = 16752042 },
-    { url = "https://files.pythonhosted.org/packages/48/6b/1c6b515a83d5564b1698a61efa245727c8feecf308f4091f565988519d20/numpy-2.3.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e610832418a2bc09d974cc9fecebfa51e9532d6190223bc5ef6a7402ebf3b5cb", size = 12927246 },
-]
-
-[[package]]
-name = "oauthlib"
-version = "3.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065 },
-]
-
-[[package]]
-name = "opentelemetry-api"
-version = "1.31.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "deprecated" },
-    { name = "importlib-metadata" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8a/cf/db26ab9d748bf50d6edf524fb863aa4da616ba1ce46c57a7dff1112b73fb/opentelemetry_api-1.31.1.tar.gz", hash = "sha256:137ad4b64215f02b3000a0292e077641c8611aab636414632a9b9068593b7e91", size = 64059 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/c8/86557ff0da32f3817bc4face57ea35cfdc2f9d3bcefd42311ef860dcefb7/opentelemetry_api-1.31.1-py3-none-any.whl", hash = "sha256:1511a3f470c9c8a32eeea68d4ea37835880c0eed09dd1a0187acc8b1301da0a1", size = 65197 },
-]
-
-[[package]]
-name = "opentelemetry-exporter-gcp-trace"
-version = "1.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "google-cloud-trace" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-resourcedetector-gcp" },
-    { name = "opentelemetry-sdk" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/15/7556d54b01fb894497f69a98d57faa9caa45ffa59896e0bba6847a7f0d15/opentelemetry_exporter_gcp_trace-1.9.0.tar.gz", hash = "sha256:c3fc090342f6ee32a0cc41a5716a6bb716b4422d19facefcb22dc4c6b683ece8", size = 18568 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/cd/6d7fbad05771eb3c2bace20f6360ce5dac5ca751c6f2122853e43830c32e/opentelemetry_exporter_gcp_trace-1.9.0-py3-none-any.whl", hash = "sha256:0a8396e8b39f636eeddc3f0ae08ddb40c40f288bc8c5544727c3581545e77254", size = 13973 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "packaging" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/49/c9/c52d444576b0776dbee71d2a4485be276cf46bec0123a5ba2f43f0cf7cde/opentelemetry_instrumentation-0.52b1.tar.gz", hash = "sha256:739f3bfadbbeec04dd59297479e15660a53df93c131d907bb61052e3d3c1406f", size = 28406 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/dd/a2b35078170941990e7a5194b9600fa75868958a9a2196a752da0e7b97a0/opentelemetry_instrumentation-0.52b1-py3-none-any.whl", hash = "sha256:8c0059c4379d77bbd8015c8d8476020efe873c123047ec069bb335e4b8717477", size = 31036 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-asgi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "asgiref" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bc/db/79bdc2344b38e60fecc7e99159a3f5b4c0e1acec8de305fba0a713cc3692/opentelemetry_instrumentation_asgi-0.52b1.tar.gz", hash = "sha256:a6dbce9cb5b2c2f45ce4817ad21f44c67fd328358ad3ab911eb46f0be67f82ec", size = 24203 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/de/39ec078ae94a365d2f434b7e25886c267864aca5695b48fa5b60f80fbfb3/opentelemetry_instrumentation_asgi-0.52b1-py3-none-any.whl", hash = "sha256:f7179f477ed665ba21871972f979f21e8534edb971232e11920c8a22f4759236", size = 16338 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-dbapi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a4/4b/c73327bc53671a773ec530ab7ee3f6ecf8686e2c76246d108e30b35a221e/opentelemetry_instrumentation_dbapi-0.52b1.tar.gz", hash = "sha256:62a6c37b659f6aa5476f12fb76c78f4ad27c49fb71a8a2c11609afcbb84f1e1c", size = 13864 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/76/2f1e9f1e1e8d99d8cc1386313d84a6be6f9caf8babdbbc2836f6ca28139b/opentelemetry_instrumentation_dbapi-0.52b1-py3-none-any.whl", hash = "sha256:47e54d26ad39f3951c7f3b4d4fb685a3c75445cfd57fcff2e92c416575c568ab", size = 12374 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-django"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/29/b2/3cbf0edad8bd59a2760a04e5897cff664e128be52c073f8124bed57bd944/opentelemetry_instrumentation_django-0.52b1.tar.gz", hash = "sha256:2541819564dae5edb0afd023de25d35761d8943aa88e6344b1e52f4fe036ccb6", size = 24613 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/65/79/1838524d736308f50ab03dd3cea097d8193bfe4bd0e886e7c806064b53a2/opentelemetry_instrumentation_django-0.52b1-py3-none-any.whl", hash = "sha256:895dcc551fa9c38c62e23d6b66ef250b20ff0afd7a39f8822ec61a2929dfc7c7", size = 19472 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-fastapi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-asgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/30/01/d159829077f2795c716445df6f8edfdd33391e82d712ba4613fb62b99dc5/opentelemetry_instrumentation_fastapi-0.52b1.tar.gz", hash = "sha256:d26ab15dc49e041301d5c2571605b8f5c3a6ee4a85b60940338f56c120221e98", size = 19247 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/89/acef7f625b218523873e32584dc5243d95ffa4facba737fd8b854c049c58/opentelemetry_instrumentation_fastapi-0.52b1-py3-none-any.whl", hash = "sha256:73c8804f053c5eb2fd2c948218bff9561f1ef65e89db326a6ab0b5bf829969f4", size = 12114 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-flask"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/00/55/83d3a859a10696d8e57f39497843b2522ca493ec1f1166ee94838c1158db/opentelemetry_instrumentation_flask-0.52b1.tar.gz", hash = "sha256:c8bc64da425ccbadb4a2ee5e8d99045e2282bfbf63bc9be07c386675839d00be", size = 19192 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/4c/c52dacd39c90d490eb4f9408f31014c370020e0ce2b9455958a2970e07c2/opentelemetry_instrumentation_flask-0.52b1-py3-none-any.whl", hash = "sha256:3c8b83147838bef24aac0182f0d49865321efba4cb1f96629f460330d21d0fa9", size = 14593 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-psycopg2"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-dbapi" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/84/d7/622e732f1914e4dedaa20a56af1edc9b7f7456d710bda471546b49d48874/opentelemetry_instrumentation_psycopg2-0.52b1.tar.gz", hash = "sha256:5bbdb2a2973aae9402946c995e277b1f76e467faebc40ac0f8da51c701918bb4", size = 9748 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/bd/58c72d6fd03810aa87375911d4e3b4029b9e36c05df4ae9735bc62b6574b/opentelemetry_instrumentation_psycopg2-0.52b1-py3-none-any.whl", hash = "sha256:51ac9f3d0b83889a1df2fc1342d86887142c2b70d8532043bc49b36fe95ea9d8", size = 10709 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-requests"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/56/d7/27588187a7092dc64129bc4c8808277460d353fc52299f3e0b9d9d09ce79/opentelemetry_instrumentation_requests-0.52b1.tar.gz", hash = "sha256:711a2ef90e32a0ffd4650b21376b8e102473845ba9121efca0d94314d529b501", size = 14377 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/c5/a1d78cb4beb9e7889799bf6d1c759d7b08f800cc068c94e94386678a7fe0/opentelemetry_instrumentation_requests-0.52b1-py3-none-any.whl", hash = "sha256:58ae3c415543d8ba2b0091b81ac13b65f2993adef0a4b9a5d3d7ebbe0023986a", size = 12746 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d2/39/7cb4380a3b86eb740c5781f55951231aea5c7f09ee0abc0609d4cb9035dd/opentelemetry_instrumentation_urllib-0.52b1.tar.gz", hash = "sha256:1364c742eaec56e11bab8723aecde378e438f86f753d93fcbf5ca8f6e1073a5c", size = 13790 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/1d/4da275bd8057f470589268dccf69ab60d2d9aa2c7a928338f9f5e6af18cb/opentelemetry_instrumentation_urllib-0.52b1-py3-none-any.whl", hash = "sha256:559ee1228194cf025c22b2515bdb855aefd9cec19596a7b30df5f092fbc72e56", size = 12625 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib3"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/97/4b/f0c0f7ee7c06a7068a7016de2f212e03f4a8e9ff17ea1b887b444a20cb62/opentelemetry_instrumentation_urllib3-0.52b1.tar.gz", hash = "sha256:b607aefd2c02ff7fbf6eea4b863f63348e64b29592ffa90dcc970a5bbcbe3c6b", size = 15697 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/01/f5cab7bbe73635e9ab351d6d4add625407dbb4aec4b3b6946101776ceb54/opentelemetry_instrumentation_urllib3-0.52b1-py3-none-any.whl", hash = "sha256:4011bac1639a6336c443252d93709eff17e316523f335ddee4ddb47bf464305e", size = 13124 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-wsgi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/db/e4/20540e7739a8beaf5cdbc20999475c61b9c5240ccc48164f1034917fb639/opentelemetry_instrumentation_wsgi-0.52b1.tar.gz", hash = "sha256:2c0534cacae594ef8c749edf3d1a8bce78e959a1b40efbc36f1b59d1f7977089", size = 18243 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/6d/4bccc2f324a75613a1cf7cd95642809424d5b7b5b7987e59a1fd7fb96f05/opentelemetry_instrumentation_wsgi-0.52b1-py3-none-any.whl", hash = "sha256:13d19958bb63df0dc32df23a047e94fe5db66151d29b17c01b1d751dd84029f8", size = 14377 },
-]
-
-[[package]]
-name = "opentelemetry-resource-detector-azure"
-version = "0.1.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-sdk" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/67/e4/0d359d48d03d447225b30c3dd889d5d454e3b413763ff721f9b0e4ac2e59/opentelemetry_resource_detector_azure-0.1.5.tar.gz", hash = "sha256:e0ba658a87c69eebc806e75398cd0e9f68a8898ea62de99bc1b7083136403710", size = 11503 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/c26d8da88ba2e438e9653a408b0c2ad6f17267801250a8f3cc6405a93a72/opentelemetry_resource_detector_azure-0.1.5-py3-none-any.whl", hash = "sha256:4dcc5d54ab5c3b11226af39509bc98979a8b9e0f8a24c1b888783755d3bf00eb", size = 14252 },
-]
-
-[[package]]
-name = "opentelemetry-resourcedetector-gcp"
-version = "1.9.0a0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-sdk" },
-    { name = "requests" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/86/f0693998817779802525a5bcc885a3cdb68d05b636bc6faae5c9ade4bee4/opentelemetry_resourcedetector_gcp-1.9.0a0.tar.gz", hash = "sha256:6860a6649d1e3b9b7b7f09f3918cc16b72aa0c0c590d2a72ea6e42b67c9a42e7", size = 20730 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/04/7e33228c88422a5518e1774a836c9ec68f10f51bde0f1d5dd5f3054e612a/opentelemetry_resourcedetector_gcp-1.9.0a0-py3-none-any.whl", hash = "sha256:4e5a0822b0f0d7647b7ceb282d7aa921dd7f45466540bd0a24f954f90db8fde8", size = 20378 },
-]
-
-[[package]]
-name = "opentelemetry-sdk"
-version = "1.31.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/63/d9/4fe159908a63661e9e635e66edc0d0d816ed20cebcce886132b19ae87761/opentelemetry_sdk-1.31.1.tar.gz", hash = "sha256:c95f61e74b60769f8ff01ec6ffd3d29684743404603df34b20aa16a49dc8d903", size = 159523 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bc/36/758e5d3746bc86a2af20aa5e2236a7c5aa4264b501dc0e9f40efd9078ef0/opentelemetry_sdk-1.31.1-py3-none-any.whl", hash = "sha256:882d021321f223e37afaca7b4e06c1d8bbc013f9e17ff48a7aa017460a8e7dae", size = 118866 },
-]
-
-[[package]]
-name = "opentelemetry-semantic-conventions"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "deprecated" },
-    { name = "opentelemetry-api" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/8c/599f9f27cff097ec4d76fbe9fe6d1a74577ceec52efe1a999511e3c42ef5/opentelemetry_semantic_conventions-0.52b1.tar.gz", hash = "sha256:7b3d226ecf7523c27499758a58b542b48a0ac8d12be03c0488ff8ec60c5bae5d", size = 111275 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/be/d4ba300cfc1d4980886efbc9b48ee75242b9fcf940d9c4ccdc9ef413a7cf/opentelemetry_semantic_conventions-0.52b1-py3-none-any.whl", hash = "sha256:72b42db327e29ca8bb1b91e8082514ddf3bbf33f32ec088feb09526ade4bc77e", size = 183409 },
-]
-
-[[package]]
-name = "opentelemetry-util-http"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/23/3f/16a4225a953bbaae7d800140ed99813f092ea3071ba7780683299a87049b/opentelemetry_util_http-0.52b1.tar.gz", hash = "sha256:c03c8c23f1b75fadf548faece7ead3aecd50761c5593a2b2831b48730eee5b31", size = 8044 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/00/1591b397c9efc0e4215d223553a1cb9090c8499888a4447f842443077d31/opentelemetry_util_http-0.52b1-py3-none-any.whl", hash = "sha256:6a6ab6bfa23fef96f4995233e874f67602adf9d224895981b4ab9d4dde23de78", size = 7305 },
-]
-
-[[package]]
-name = "packaging"
-version = "25.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469 },
-]
-
-[[package]]
-name = "pathlib"
-version = "1.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363 },
-]
-
-[[package]]
-name = "proto-plus"
-version = "1.26.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/ac/87285f15f7cce6d4a008f33f1757fb5a13611ea8914eb58c3d0d26243468/proto_plus-1.26.1.tar.gz", hash = "sha256:21a515a4c4c0088a773899e23c7bbade3d18f9c66c73edd4c7ee3816bc96a012", size = 56142 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/6d/280c4c2ce28b1593a19ad5239c8b826871fc6ec275c21afc8e1820108039/proto_plus-1.26.1-py3-none-any.whl", hash = "sha256:13285478c2dcf2abb829db158e1047e2f1e8d63a077d94263c2b88b043c75a66", size = 50163 },
-]
-
-[[package]]
-name = "protobuf"
-version = "6.31.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/52/f3/b9655a711b32c19720253f6f06326faf90580834e2e83f840472d752bc8b/protobuf-6.31.1.tar.gz", hash = "sha256:d8cac4c982f0b957a4dc73a80e2ea24fab08e679c0de9deb835f4a12d69aca9a", size = 441797 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/6f/6ab8e4bf962fd5570d3deaa2d5c38f0a363f57b4501047b5ebeb83ab1125/protobuf-6.31.1-cp310-abi3-win32.whl", hash = "sha256:7fa17d5a29c2e04b7d90e5e32388b8bfd0e7107cd8e616feef7ed3fa6bdab5c9", size = 423603 },
-    { url = "https://files.pythonhosted.org/packages/44/3a/b15c4347dd4bf3a1b0ee882f384623e2063bb5cf9fa9d57990a4f7df2fb6/protobuf-6.31.1-cp310-abi3-win_amd64.whl", hash = "sha256:426f59d2964864a1a366254fa703b8632dcec0790d8862d30034d8245e1cd447", size = 435283 },
-    { url = "https://files.pythonhosted.org/packages/6a/c9/b9689a2a250264a84e66c46d8862ba788ee7a641cdca39bccf64f59284b7/protobuf-6.31.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:6f1227473dc43d44ed644425268eb7c2e488ae245d51c6866d19fe158e207402", size = 425604 },
-    { url = "https://files.pythonhosted.org/packages/76/a1/7a5a94032c83375e4fe7e7f56e3976ea6ac90c5e85fac8576409e25c39c3/protobuf-6.31.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:a40fc12b84c154884d7d4c4ebd675d5b3b5283e155f324049ae396b95ddebc39", size = 322115 },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/b59d405d64d31999244643d88c45c8241c58f17cc887e73bcb90602327f8/protobuf-6.31.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:4ee898bf66f7a8b0bd21bce523814e6fbd8c6add948045ce958b73af7e8878c6", size = 321070 },
-    { url = "https://files.pythonhosted.org/packages/f7/af/ab3c51ab7507a7325e98ffe691d9495ee3d3aa5f589afad65ec920d39821/protobuf-6.31.1-py3-none-any.whl", hash = "sha256:720a6c7e6b77288b85063569baae8536671b39f15cc22037ec7045658d80489e", size = 168724 },
-]
-
-[[package]]
-name = "psutil"
-version = "7.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 },
-    { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 },
-    { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 },
-    { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 },
-    { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 },
-    { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 },
-    { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 },
-]
-
-[[package]]
-name = "pyasn1"
-version = "0.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135 },
-]
-
-[[package]]
-name = "pyasn1-modules"
-version = "0.4.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259 },
-]
-
-[[package]]
-name = "pycparser"
-version = "2.22"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
-]
-
-[[package]]
-name = "pydantic"
-version = "2.11.7"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782 },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.33.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817 },
-    { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357 },
-    { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011 },
-    { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730 },
-    { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178 },
-    { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462 },
-    { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652 },
-    { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306 },
-    { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720 },
-    { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915 },
-    { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884 },
-    { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496 },
-    { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019 },
-    { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584 },
-    { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071 },
-    { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823 },
-    { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792 },
-    { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338 },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998 },
-    { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200 },
-    { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890 },
-    { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359 },
-    { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883 },
-    { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074 },
-    { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538 },
-    { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909 },
-    { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786 },
-    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000 },
-    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996 },
-    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957 },
-    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199 },
-    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296 },
-    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109 },
-    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028 },
-    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044 },
-    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881 },
-    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034 },
-    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187 },
-    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628 },
-    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866 },
-    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894 },
-    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688 },
-    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808 },
-    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580 },
-    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859 },
-    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810 },
-    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498 },
-    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611 },
-    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924 },
-    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196 },
-    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389 },
-    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223 },
-    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473 },
-    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269 },
-    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921 },
-    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162 },
-    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560 },
-    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777 },
-    { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982 },
-    { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412 },
-    { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749 },
-    { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527 },
-    { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225 },
-    { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490 },
-    { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525 },
-    { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446 },
-    { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678 },
-    { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200 },
-    { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123 },
-    { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852 },
-    { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484 },
-    { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896 },
-    { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475 },
-    { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013 },
-    { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715 },
-    { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757 },
-]
-
-[[package]]
-name = "pydantic-settings"
-version = "2.10.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235 },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 },
-]
-
-[[package]]
-name = "pyjwt"
-version = "2.10.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997 },
-]
-
-[package.optional-dependencies]
-crypto = [
-    { name = "cryptography" },
-]
-
-[[package]]
-name = "pyparsing"
-version = "3.2.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120 },
-]
-
-[[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
-]
-
-[[package]]
-name = "python-dotenv"
-version = "1.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556 },
-]
-
-[[package]]
-name = "python-multipart"
-version = "0.0.20"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 },
-]
-
-[[package]]
-name = "pywin32"
-version = "311"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/40/44efbb0dfbd33aca6a6483191dae0716070ed99e2ecb0c53683f400a0b4f/pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3", size = 8760432 },
-    { url = "https://files.pythonhosted.org/packages/5e/bf/360243b1e953bd254a82f12653974be395ba880e7ec23e3731d9f73921cc/pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b", size = 9590103 },
-    { url = "https://files.pythonhosted.org/packages/57/38/d290720e6f138086fb3d5ffe0b6caa019a791dd57866940c82e4eeaf2012/pywin32-311-cp310-cp310-win_arm64.whl", hash = "sha256:0502d1facf1fed4839a9a51ccbcc63d952cf318f78ffc00a7e78528ac27d7a2b", size = 8778557 },
-    { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031 },
-    { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308 },
-    { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930 },
-    { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543 },
-    { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040 },
-    { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102 },
-    { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700 },
-    { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700 },
-    { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318 },
-    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714 },
-    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800 },
-    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540 },
-]
-
-[[package]]
-name = "pyyaml"
-version = "6.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 },
-    { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 },
-    { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 },
-    { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 },
-    { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 },
-    { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 },
-    { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 },
-    { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 },
-    { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 },
-    { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 },
-    { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 },
-    { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 },
-    { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 },
-    { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 },
-    { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 },
-    { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 },
-    { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 },
-    { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 },
-    { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 },
-    { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 },
-    { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 },
-    { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 },
-    { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 },
-    { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 },
-    { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 },
-    { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 },
-    { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 },
-    { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 },
-    { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 },
-    { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 },
-    { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 },
-    { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 },
-    { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 },
-    { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 },
-    { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 },
-    { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 },
-]
-
-[[package]]
-name = "referencing"
-version = "0.36.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "rpds-py" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 },
-]
-
-[[package]]
-name = "requests"
-version = "2.32.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "charset-normalizer" },
-    { name = "idna" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847 },
-]
-
-[[package]]
-name = "requests-oauthlib"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "oauthlib" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179 },
-]
-
-[[package]]
-name = "rich"
-version = "14.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown-it-py" },
-    { name = "pygments" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229 },
-]
-
-[[package]]
-name = "rpds-py"
-version = "0.26.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a5/aa/4456d84bbb54adc6a916fb10c9b374f78ac840337644e4a5eda229c81275/rpds_py-0.26.0.tar.gz", hash = "sha256:20dae58a859b0906f0685642e591056f1e787f3a8b39c8e8749a45dc7d26bdb0", size = 27385 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/31/1459645f036c3dfeacef89e8e5825e430c77dde8489f3b99eaafcd4a60f5/rpds_py-0.26.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:4c70c70f9169692b36307a95f3d8c0a9fcd79f7b4a383aad5eaa0e9718b79b37", size = 372466 },
-    { url = "https://files.pythonhosted.org/packages/dd/ff/3d0727f35836cc8773d3eeb9a46c40cc405854e36a8d2e951f3a8391c976/rpds_py-0.26.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:777c62479d12395bfb932944e61e915741e364c843afc3196b694db3d669fcd0", size = 357825 },
-    { url = "https://files.pythonhosted.org/packages/bf/ce/badc5e06120a54099ae287fa96d82cbb650a5f85cf247ffe19c7b157fd1f/rpds_py-0.26.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec671691e72dff75817386aa02d81e708b5a7ec0dec6669ec05213ff6b77e1bd", size = 381530 },
-    { url = "https://files.pythonhosted.org/packages/1e/a5/fa5d96a66c95d06c62d7a30707b6a4cfec696ab8ae280ee7be14e961e118/rpds_py-0.26.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6a1cb5d6ce81379401bbb7f6dbe3d56de537fb8235979843f0d53bc2e9815a79", size = 396933 },
-    { url = "https://files.pythonhosted.org/packages/00/a7/7049d66750f18605c591a9db47d4a059e112a0c9ff8de8daf8fa0f446bba/rpds_py-0.26.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4f789e32fa1fb6a7bf890e0124e7b42d1e60d28ebff57fe806719abb75f0e9a3", size = 513973 },
-    { url = "https://files.pythonhosted.org/packages/0e/f1/528d02c7d6b29d29fac8fd784b354d3571cc2153f33f842599ef0cf20dd2/rpds_py-0.26.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c55b0a669976cf258afd718de3d9ad1b7d1fe0a91cd1ab36f38b03d4d4aeaaf", size = 402293 },
-    { url = "https://files.pythonhosted.org/packages/15/93/fde36cd6e4685df2cd08508f6c45a841e82f5bb98c8d5ecf05649522acb5/rpds_py-0.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c70d9ec912802ecfd6cd390dadb34a9578b04f9bcb8e863d0a7598ba5e9e7ccc", size = 383787 },
-    { url = "https://files.pythonhosted.org/packages/69/f2/5007553aaba1dcae5d663143683c3dfd03d9395289f495f0aebc93e90f24/rpds_py-0.26.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3021933c2cb7def39d927b9862292e0f4c75a13d7de70eb0ab06efed4c508c19", size = 416312 },
-    { url = "https://files.pythonhosted.org/packages/8f/a7/ce52c75c1e624a79e48a69e611f1c08844564e44c85db2b6f711d76d10ce/rpds_py-0.26.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8a7898b6ca3b7d6659e55cdac825a2e58c638cbf335cde41f4619e290dd0ad11", size = 558403 },
-    { url = "https://files.pythonhosted.org/packages/79/d5/e119db99341cc75b538bf4cb80504129fa22ce216672fb2c28e4a101f4d9/rpds_py-0.26.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:12bff2ad9447188377f1b2794772f91fe68bb4bbfa5a39d7941fbebdbf8c500f", size = 588323 },
-    { url = "https://files.pythonhosted.org/packages/93/94/d28272a0b02f5fe24c78c20e13bbcb95f03dc1451b68e7830ca040c60bd6/rpds_py-0.26.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:191aa858f7d4902e975d4cf2f2d9243816c91e9605070aeb09c0a800d187e323", size = 554541 },
-    { url = "https://files.pythonhosted.org/packages/93/e0/8c41166602f1b791da892d976057eba30685486d2e2c061ce234679c922b/rpds_py-0.26.0-cp310-cp310-win32.whl", hash = "sha256:b37a04d9f52cb76b6b78f35109b513f6519efb481d8ca4c321f6a3b9580b3f45", size = 220442 },
-    { url = "https://files.pythonhosted.org/packages/87/f0/509736bb752a7ab50fb0270c2a4134d671a7b3038030837e5536c3de0e0b/rpds_py-0.26.0-cp310-cp310-win_amd64.whl", hash = "sha256:38721d4c9edd3eb6670437d8d5e2070063f305bfa2d5aa4278c51cedcd508a84", size = 231314 },
-    { url = "https://files.pythonhosted.org/packages/09/4c/4ee8f7e512030ff79fda1df3243c88d70fc874634e2dbe5df13ba4210078/rpds_py-0.26.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9e8cb77286025bdb21be2941d64ac6ca016130bfdcd228739e8ab137eb4406ed", size = 372610 },
-    { url = "https://files.pythonhosted.org/packages/fa/9d/3dc16be00f14fc1f03c71b1d67c8df98263ab2710a2fbd65a6193214a527/rpds_py-0.26.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5e09330b21d98adc8ccb2dbb9fc6cb434e8908d4c119aeaa772cb1caab5440a0", size = 358032 },
-    { url = "https://files.pythonhosted.org/packages/e7/5a/7f1bf8f045da2866324a08ae80af63e64e7bfaf83bd31f865a7b91a58601/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9c1b92b774b2e68d11193dc39620d62fd8ab33f0a3c77ecdabe19c179cdbc1", size = 381525 },
-    { url = "https://files.pythonhosted.org/packages/45/8a/04479398c755a066ace10e3d158866beb600867cacae194c50ffa783abd0/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:824e6d3503ab990d7090768e4dfd9e840837bae057f212ff9f4f05ec6d1975e7", size = 397089 },
-    { url = "https://files.pythonhosted.org/packages/72/88/9203f47268db488a1b6d469d69c12201ede776bb728b9d9f29dbfd7df406/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ad7fd2258228bf288f2331f0a6148ad0186b2e3643055ed0db30990e59817a6", size = 514255 },
-    { url = "https://files.pythonhosted.org/packages/f5/b4/01ce5d1e853ddf81fbbd4311ab1eff0b3cf162d559288d10fd127e2588b5/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0dc23bbb3e06ec1ea72d515fb572c1fea59695aefbffb106501138762e1e915e", size = 402283 },
-    { url = "https://files.pythonhosted.org/packages/34/a2/004c99936997bfc644d590a9defd9e9c93f8286568f9c16cdaf3e14429a7/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d80bf832ac7b1920ee29a426cdca335f96a2b5caa839811803e999b41ba9030d", size = 383881 },
-    { url = "https://files.pythonhosted.org/packages/05/1b/ef5fba4a8f81ce04c427bfd96223f92f05e6cd72291ce9d7523db3b03a6c/rpds_py-0.26.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0919f38f5542c0a87e7b4afcafab6fd2c15386632d249e9a087498571250abe3", size = 415822 },
-    { url = "https://files.pythonhosted.org/packages/16/80/5c54195aec456b292f7bd8aa61741c8232964063fd8a75fdde9c1e982328/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d422b945683e409000c888e384546dbab9009bb92f7c0b456e217988cf316107", size = 558347 },
-    { url = "https://files.pythonhosted.org/packages/f2/1c/1845c1b1fd6d827187c43afe1841d91678d7241cbdb5420a4c6de180a538/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:77a7711fa562ba2da1aa757e11024ad6d93bad6ad7ede5afb9af144623e5f76a", size = 587956 },
-    { url = "https://files.pythonhosted.org/packages/2e/ff/9e979329dd131aa73a438c077252ddabd7df6d1a7ad7b9aacf6261f10faa/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238e8c8610cb7c29460e37184f6799547f7e09e6a9bdbdab4e8edb90986a2318", size = 554363 },
-    { url = "https://files.pythonhosted.org/packages/00/8b/d78cfe034b71ffbe72873a136e71acc7a831a03e37771cfe59f33f6de8a2/rpds_py-0.26.0-cp311-cp311-win32.whl", hash = "sha256:893b022bfbdf26d7bedb083efeea624e8550ca6eb98bf7fea30211ce95b9201a", size = 220123 },
-    { url = "https://files.pythonhosted.org/packages/94/c1/3c8c94c7dd3905dbfde768381ce98778500a80db9924731d87ddcdb117e9/rpds_py-0.26.0-cp311-cp311-win_amd64.whl", hash = "sha256:87a5531de9f71aceb8af041d72fc4cab4943648d91875ed56d2e629bef6d4c03", size = 231732 },
-    { url = "https://files.pythonhosted.org/packages/67/93/e936fbed1b734eabf36ccb5d93c6a2e9246fbb13c1da011624b7286fae3e/rpds_py-0.26.0-cp311-cp311-win_arm64.whl", hash = "sha256:de2713f48c1ad57f89ac25b3cb7daed2156d8e822cf0eca9b96a6f990718cc41", size = 221917 },
-    { url = "https://files.pythonhosted.org/packages/ea/86/90eb87c6f87085868bd077c7a9938006eb1ce19ed4d06944a90d3560fce2/rpds_py-0.26.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:894514d47e012e794f1350f076c427d2347ebf82f9b958d554d12819849a369d", size = 363933 },
-    { url = "https://files.pythonhosted.org/packages/63/78/4469f24d34636242c924626082b9586f064ada0b5dbb1e9d096ee7a8e0c6/rpds_py-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc921b96fa95a097add244da36a1d9e4f3039160d1d30f1b35837bf108c21136", size = 350447 },
-    { url = "https://files.pythonhosted.org/packages/ad/91/c448ed45efdfdade82348d5e7995e15612754826ea640afc20915119734f/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e1157659470aa42a75448b6e943c895be8c70531c43cb78b9ba990778955582", size = 384711 },
-    { url = "https://files.pythonhosted.org/packages/ec/43/e5c86fef4be7f49828bdd4ecc8931f0287b1152c0bb0163049b3218740e7/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:521ccf56f45bb3a791182dc6b88ae5f8fa079dd705ee42138c76deb1238e554e", size = 400865 },
-    { url = "https://files.pythonhosted.org/packages/55/34/e00f726a4d44f22d5c5fe2e5ddd3ac3d7fd3f74a175607781fbdd06fe375/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9def736773fd56b305c0eef698be5192c77bfa30d55a0e5885f80126c4831a15", size = 517763 },
-    { url = "https://files.pythonhosted.org/packages/52/1c/52dc20c31b147af724b16104500fba13e60123ea0334beba7b40e33354b4/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdad4ea3b4513b475e027be79e5a0ceac8ee1c113a1a11e5edc3c30c29f964d8", size = 406651 },
-    { url = "https://files.pythonhosted.org/packages/2e/77/87d7bfabfc4e821caa35481a2ff6ae0b73e6a391bb6b343db2c91c2b9844/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82b165b07f416bdccf5c84546a484cc8f15137ca38325403864bfdf2b5b72f6a", size = 386079 },
-    { url = "https://files.pythonhosted.org/packages/e3/d4/7f2200c2d3ee145b65b3cddc4310d51f7da6a26634f3ac87125fd789152a/rpds_py-0.26.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d04cab0a54b9dba4d278fe955a1390da3cf71f57feb78ddc7cb67cbe0bd30323", size = 421379 },
-    { url = "https://files.pythonhosted.org/packages/ae/13/9fdd428b9c820869924ab62236b8688b122baa22d23efdd1c566938a39ba/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:79061ba1a11b6a12743a2b0f72a46aa2758613d454aa6ba4f5a265cc48850158", size = 562033 },
-    { url = "https://files.pythonhosted.org/packages/f3/e1/b69686c3bcbe775abac3a4c1c30a164a2076d28df7926041f6c0eb5e8d28/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f405c93675d8d4c5ac87364bb38d06c988e11028a64b52a47158a355079661f3", size = 591639 },
-    { url = "https://files.pythonhosted.org/packages/5c/c9/1e3d8c8863c84a90197ac577bbc3d796a92502124c27092413426f670990/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dafd4c44b74aa4bed4b250f1aed165b8ef5de743bcca3b88fc9619b6087093d2", size = 557105 },
-    { url = "https://files.pythonhosted.org/packages/9f/c5/90c569649057622959f6dcc40f7b516539608a414dfd54b8d77e3b201ac0/rpds_py-0.26.0-cp312-cp312-win32.whl", hash = "sha256:3da5852aad63fa0c6f836f3359647870e21ea96cf433eb393ffa45263a170d44", size = 223272 },
-    { url = "https://files.pythonhosted.org/packages/7d/16/19f5d9f2a556cfed454eebe4d354c38d51c20f3db69e7b4ce6cff904905d/rpds_py-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:cf47cfdabc2194a669dcf7a8dbba62e37a04c5041d2125fae0233b720da6f05c", size = 234995 },
-    { url = "https://files.pythonhosted.org/packages/83/f0/7935e40b529c0e752dfaa7880224771b51175fce08b41ab4a92eb2fbdc7f/rpds_py-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:20ab1ae4fa534f73647aad289003f1104092890849e0266271351922ed5574f8", size = 223198 },
-    { url = "https://files.pythonhosted.org/packages/6a/67/bb62d0109493b12b1c6ab00de7a5566aa84c0e44217c2d94bee1bd370da9/rpds_py-0.26.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:696764a5be111b036256c0b18cd29783fab22154690fc698062fc1b0084b511d", size = 363917 },
-    { url = "https://files.pythonhosted.org/packages/4b/f3/34e6ae1925a5706c0f002a8d2d7f172373b855768149796af87bd65dcdb9/rpds_py-0.26.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e6c15d2080a63aaed876e228efe4f814bc7889c63b1e112ad46fdc8b368b9e1", size = 350073 },
-    { url = "https://files.pythonhosted.org/packages/75/83/1953a9d4f4e4de7fd0533733e041c28135f3c21485faaef56a8aadbd96b5/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:390e3170babf42462739a93321e657444f0862c6d722a291accc46f9d21ed04e", size = 384214 },
-    { url = "https://files.pythonhosted.org/packages/48/0e/983ed1b792b3322ea1d065e67f4b230f3b96025f5ce3878cc40af09b7533/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7da84c2c74c0f5bc97d853d9e17bb83e2dcafcff0dc48286916001cc114379a1", size = 400113 },
-    { url = "https://files.pythonhosted.org/packages/69/7f/36c0925fff6f660a80be259c5b4f5e53a16851f946eb080351d057698528/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c5fe114a6dd480a510b6d3661d09d67d1622c4bf20660a474507aaee7eeeee9", size = 515189 },
-    { url = "https://files.pythonhosted.org/packages/13/45/cbf07fc03ba7a9b54662c9badb58294ecfb24f828b9732970bd1a431ed5c/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3100b3090269f3a7ea727b06a6080d4eb7439dca4c0e91a07c5d133bb1727ea7", size = 406998 },
-    { url = "https://files.pythonhosted.org/packages/6c/b0/8fa5e36e58657997873fd6a1cf621285ca822ca75b4b3434ead047daa307/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c03c9b0c64afd0320ae57de4c982801271c0c211aa2d37f3003ff5feb75bb04", size = 385903 },
-    { url = "https://files.pythonhosted.org/packages/4b/f7/b25437772f9f57d7a9fbd73ed86d0dcd76b4c7c6998348c070d90f23e315/rpds_py-0.26.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5963b72ccd199ade6ee493723d18a3f21ba7d5b957017607f815788cef50eaf1", size = 419785 },
-    { url = "https://files.pythonhosted.org/packages/a7/6b/63ffa55743dfcb4baf2e9e77a0b11f7f97ed96a54558fcb5717a4b2cd732/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9da4e873860ad5bab3291438525cae80169daecbfafe5657f7f5fb4d6b3f96b9", size = 561329 },
-    { url = "https://files.pythonhosted.org/packages/2f/07/1f4f5e2886c480a2346b1e6759c00278b8a69e697ae952d82ae2e6ee5db0/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5afaddaa8e8c7f1f7b4c5c725c0070b6eed0228f705b90a1732a48e84350f4e9", size = 590875 },
-    { url = "https://files.pythonhosted.org/packages/cc/bc/e6639f1b91c3a55f8c41b47d73e6307051b6e246254a827ede730624c0f8/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4916dc96489616a6f9667e7526af8fa693c0fdb4f3acb0e5d9f4400eb06a47ba", size = 556636 },
-    { url = "https://files.pythonhosted.org/packages/05/4c/b3917c45566f9f9a209d38d9b54a1833f2bb1032a3e04c66f75726f28876/rpds_py-0.26.0-cp313-cp313-win32.whl", hash = "sha256:2a343f91b17097c546b93f7999976fd6c9d5900617aa848c81d794e062ab302b", size = 222663 },
-    { url = "https://files.pythonhosted.org/packages/e0/0b/0851bdd6025775aaa2365bb8de0697ee2558184c800bfef8d7aef5ccde58/rpds_py-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:0a0b60701f2300c81b2ac88a5fb893ccfa408e1c4a555a77f908a2596eb875a5", size = 234428 },
-    { url = "https://files.pythonhosted.org/packages/ed/e8/a47c64ed53149c75fb581e14a237b7b7cd18217e969c30d474d335105622/rpds_py-0.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:257d011919f133a4746958257f2c75238e3ff54255acd5e3e11f3ff41fd14256", size = 222571 },
-    { url = "https://files.pythonhosted.org/packages/89/bf/3d970ba2e2bcd17d2912cb42874107390f72873e38e79267224110de5e61/rpds_py-0.26.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:529c8156d7506fba5740e05da8795688f87119cce330c244519cf706a4a3d618", size = 360475 },
-    { url = "https://files.pythonhosted.org/packages/82/9f/283e7e2979fc4ec2d8ecee506d5a3675fce5ed9b4b7cb387ea5d37c2f18d/rpds_py-0.26.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f53ec51f9d24e9638a40cabb95078ade8c99251945dad8d57bf4aabe86ecee35", size = 346692 },
-    { url = "https://files.pythonhosted.org/packages/e3/03/7e50423c04d78daf391da3cc4330bdb97042fc192a58b186f2d5deb7befd/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab504c4d654e4a29558eaa5bb8cea5fdc1703ea60a8099ffd9c758472cf913f", size = 379415 },
-    { url = "https://files.pythonhosted.org/packages/57/00/d11ee60d4d3b16808432417951c63df803afb0e0fc672b5e8d07e9edaaae/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd0641abca296bc1a00183fe44f7fced8807ed49d501f188faa642d0e4975b83", size = 391783 },
-    { url = "https://files.pythonhosted.org/packages/08/b3/1069c394d9c0d6d23c5b522e1f6546b65793a22950f6e0210adcc6f97c3e/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b312fecc1d017b5327afa81d4da1480f51c68810963a7336d92203dbb3d4f1", size = 512844 },
-    { url = "https://files.pythonhosted.org/packages/08/3b/c4fbf0926800ed70b2c245ceca99c49f066456755f5d6eb8863c2c51e6d0/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c741107203954f6fc34d3066d213d0a0c40f7bb5aafd698fb39888af277c70d8", size = 402105 },
-    { url = "https://files.pythonhosted.org/packages/1c/b0/db69b52ca07413e568dae9dc674627a22297abb144c4d6022c6d78f1e5cc/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc3e55a7db08dc9a6ed5fb7103019d2c1a38a349ac41901f9f66d7f95750942f", size = 383440 },
-    { url = "https://files.pythonhosted.org/packages/4c/e1/c65255ad5b63903e56b3bb3ff9dcc3f4f5c3badde5d08c741ee03903e951/rpds_py-0.26.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9e851920caab2dbcae311fd28f4313c6953993893eb5c1bb367ec69d9a39e7ed", size = 412759 },
-    { url = "https://files.pythonhosted.org/packages/e4/22/bb731077872377a93c6e93b8a9487d0406c70208985831034ccdeed39c8e/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dfbf280da5f876d0b00c81f26bedce274e72a678c28845453885a9b3c22ae632", size = 556032 },
-    { url = "https://files.pythonhosted.org/packages/e0/8b/393322ce7bac5c4530fb96fc79cc9ea2f83e968ff5f6e873f905c493e1c4/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:1cc81d14ddfa53d7f3906694d35d54d9d3f850ef8e4e99ee68bc0d1e5fed9a9c", size = 585416 },
-    { url = "https://files.pythonhosted.org/packages/49/ae/769dc372211835bf759319a7aae70525c6eb523e3371842c65b7ef41c9c6/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dca83c498b4650a91efcf7b88d669b170256bf8017a5db6f3e06c2bf031f57e0", size = 554049 },
-    { url = "https://files.pythonhosted.org/packages/6b/f9/4c43f9cc203d6ba44ce3146246cdc38619d92c7bd7bad4946a3491bd5b70/rpds_py-0.26.0-cp313-cp313t-win32.whl", hash = "sha256:4d11382bcaf12f80b51d790dee295c56a159633a8e81e6323b16e55d81ae37e9", size = 218428 },
-    { url = "https://files.pythonhosted.org/packages/7e/8b/9286b7e822036a4a977f2f1e851c7345c20528dbd56b687bb67ed68a8ede/rpds_py-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff110acded3c22c033e637dd8896e411c7d3a11289b2edf041f86663dbc791e9", size = 231524 },
-    { url = "https://files.pythonhosted.org/packages/55/07/029b7c45db910c74e182de626dfdae0ad489a949d84a468465cd0ca36355/rpds_py-0.26.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:da619979df60a940cd434084355c514c25cf8eb4cf9a508510682f6c851a4f7a", size = 364292 },
-    { url = "https://files.pythonhosted.org/packages/13/d1/9b3d3f986216b4d1f584878dca15ce4797aaf5d372d738974ba737bf68d6/rpds_py-0.26.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ea89a2458a1a75f87caabefe789c87539ea4e43b40f18cff526052e35bbb4fdf", size = 350334 },
-    { url = "https://files.pythonhosted.org/packages/18/98/16d5e7bc9ec715fa9668731d0cf97f6b032724e61696e2db3d47aeb89214/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feac1045b3327a45944e7dcbeb57530339f6b17baff154df51ef8b0da34c8c12", size = 384875 },
-    { url = "https://files.pythonhosted.org/packages/f9/13/aa5e2b1ec5ab0e86a5c464d53514c0467bec6ba2507027d35fc81818358e/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b818a592bd69bfe437ee8368603d4a2d928c34cffcdf77c2e761a759ffd17d20", size = 399993 },
-    { url = "https://files.pythonhosted.org/packages/17/03/8021810b0e97923abdbab6474c8b77c69bcb4b2c58330777df9ff69dc559/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a8b0dd8648709b62d9372fc00a57466f5fdeefed666afe3fea5a6c9539a0331", size = 516683 },
-    { url = "https://files.pythonhosted.org/packages/dc/b1/da8e61c87c2f3d836954239fdbbfb477bb7b54d74974d8f6fcb34342d166/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d3498ad0df07d81112aa6ec6c95a7e7b1ae00929fb73e7ebee0f3faaeabad2f", size = 408825 },
-    { url = "https://files.pythonhosted.org/packages/38/bc/1fc173edaaa0e52c94b02a655db20697cb5fa954ad5a8e15a2c784c5cbdd/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24a4146ccb15be237fdef10f331c568e1b0e505f8c8c9ed5d67759dac58ac246", size = 387292 },
-    { url = "https://files.pythonhosted.org/packages/7c/eb/3a9bb4bd90867d21916f253caf4f0d0be7098671b6715ad1cead9fe7bab9/rpds_py-0.26.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a9a63785467b2d73635957d32a4f6e73d5e4df497a16a6392fa066b753e87387", size = 420435 },
-    { url = "https://files.pythonhosted.org/packages/cd/16/e066dcdb56f5632713445271a3f8d3d0b426d51ae9c0cca387799df58b02/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:de4ed93a8c91debfd5a047be327b7cc8b0cc6afe32a716bbbc4aedca9e2a83af", size = 562410 },
-    { url = "https://files.pythonhosted.org/packages/60/22/ddbdec7eb82a0dc2e455be44c97c71c232983e21349836ce9f272e8a3c29/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:caf51943715b12af827696ec395bfa68f090a4c1a1d2509eb4e2cb69abbbdb33", size = 590724 },
-    { url = "https://files.pythonhosted.org/packages/2c/b4/95744085e65b7187d83f2fcb0bef70716a1ea0a9e5d8f7f39a86e5d83424/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4a59e5bc386de021f56337f757301b337d7ab58baa40174fb150accd480bc953", size = 558285 },
-    { url = "https://files.pythonhosted.org/packages/37/37/6309a75e464d1da2559446f9c811aa4d16343cebe3dbb73701e63f760caa/rpds_py-0.26.0-cp314-cp314-win32.whl", hash = "sha256:92c8db839367ef16a662478f0a2fe13e15f2227da3c1430a782ad0f6ee009ec9", size = 223459 },
-    { url = "https://files.pythonhosted.org/packages/d9/6f/8e9c11214c46098b1d1391b7e02b70bb689ab963db3b19540cba17315291/rpds_py-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:b0afb8cdd034150d4d9f53926226ed27ad15b7f465e93d7468caaf5eafae0d37", size = 236083 },
-    { url = "https://files.pythonhosted.org/packages/47/af/9c4638994dd623d51c39892edd9d08e8be8220a4b7e874fa02c2d6e91955/rpds_py-0.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:ca3f059f4ba485d90c8dc75cb5ca897e15325e4e609812ce57f896607c1c0867", size = 223291 },
-    { url = "https://files.pythonhosted.org/packages/4d/db/669a241144460474aab03e254326b32c42def83eb23458a10d163cb9b5ce/rpds_py-0.26.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5afea17ab3a126006dc2f293b14ffc7ef3c85336cf451564a0515ed7648033da", size = 361445 },
-    { url = "https://files.pythonhosted.org/packages/3b/2d/133f61cc5807c6c2fd086a46df0eb8f63a23f5df8306ff9f6d0fd168fecc/rpds_py-0.26.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:69f0c0a3df7fd3a7eec50a00396104bb9a843ea6d45fcc31c2d5243446ffd7a7", size = 347206 },
-    { url = "https://files.pythonhosted.org/packages/05/bf/0e8fb4c05f70273469eecf82f6ccf37248558526a45321644826555db31b/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:801a71f70f9813e82d2513c9a96532551fce1e278ec0c64610992c49c04c2dad", size = 380330 },
-    { url = "https://files.pythonhosted.org/packages/d4/a8/060d24185d8b24d3923322f8d0ede16df4ade226a74e747b8c7c978e3dd3/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df52098cde6d5e02fa75c1f6244f07971773adb4a26625edd5c18fee906fa84d", size = 392254 },
-    { url = "https://files.pythonhosted.org/packages/b9/7b/7c2e8a9ee3e6bc0bae26bf29f5219955ca2fbb761dca996a83f5d2f773fe/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9bc596b30f86dc6f0929499c9e574601679d0341a0108c25b9b358a042f51bca", size = 516094 },
-    { url = "https://files.pythonhosted.org/packages/75/d6/f61cafbed8ba1499b9af9f1777a2a199cd888f74a96133d8833ce5eaa9c5/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9dfbe56b299cf5875b68eb6f0ebaadc9cac520a1989cac0db0765abfb3709c19", size = 402889 },
-    { url = "https://files.pythonhosted.org/packages/92/19/c8ac0a8a8df2dd30cdec27f69298a5c13e9029500d6d76718130f5e5be10/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac64f4b2bdb4ea622175c9ab7cf09444e412e22c0e02e906978b3b488af5fde8", size = 384301 },
-    { url = "https://files.pythonhosted.org/packages/41/e1/6b1859898bc292a9ce5776016c7312b672da00e25cec74d7beced1027286/rpds_py-0.26.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:181ef9b6bbf9845a264f9aa45c31836e9f3c1f13be565d0d010e964c661d1e2b", size = 412891 },
-    { url = "https://files.pythonhosted.org/packages/ef/b9/ceb39af29913c07966a61367b3c08b4f71fad841e32c6b59a129d5974698/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:49028aa684c144ea502a8e847d23aed5e4c2ef7cadfa7d5eaafcb40864844b7a", size = 557044 },
-    { url = "https://files.pythonhosted.org/packages/2f/27/35637b98380731a521f8ec4f3fd94e477964f04f6b2f8f7af8a2d889a4af/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e5d524d68a474a9688336045bbf76cb0def88549c1b2ad9dbfec1fb7cfbe9170", size = 585774 },
-    { url = "https://files.pythonhosted.org/packages/52/d9/3f0f105420fecd18551b678c9a6ce60bd23986098b252a56d35781b3e7e9/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1851f429b822831bd2edcbe0cfd12ee9ea77868f8d3daf267b189371671c80e", size = 554886 },
-    { url = "https://files.pythonhosted.org/packages/6b/c5/347c056a90dc8dd9bc240a08c527315008e1b5042e7a4cf4ac027be9d38a/rpds_py-0.26.0-cp314-cp314t-win32.whl", hash = "sha256:7bdb17009696214c3b66bb3590c6d62e14ac5935e53e929bcdbc5a495987a84f", size = 219027 },
-    { url = "https://files.pythonhosted.org/packages/75/04/5302cea1aa26d886d34cadbf2dc77d90d7737e576c0065f357b96dc7a1a6/rpds_py-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f14440b9573a6f76b4ee4770c13f0b5921f71dde3b6fcb8dabbefd13b7fe05d7", size = 232821 },
-    { url = "https://files.pythonhosted.org/packages/ef/9a/1f033b0b31253d03d785b0cd905bc127e555ab496ea6b4c7c2e1f951f2fd/rpds_py-0.26.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3c0909c5234543ada2515c05dc08595b08d621ba919629e94427e8e03539c958", size = 373226 },
-    { url = "https://files.pythonhosted.org/packages/58/29/5f88023fd6aaaa8ca3c4a6357ebb23f6f07da6079093ccf27c99efce87db/rpds_py-0.26.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c1fb0cda2abcc0ac62f64e2ea4b4e64c57dfd6b885e693095460c61bde7bb18e", size = 359230 },
-    { url = "https://files.pythonhosted.org/packages/6c/6c/13eaebd28b439da6964dde22712b52e53fe2824af0223b8e403249d10405/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84d142d2d6cf9b31c12aa4878d82ed3b2324226270b89b676ac62ccd7df52d08", size = 382363 },
-    { url = "https://files.pythonhosted.org/packages/55/fc/3bb9c486b06da19448646f96147796de23c5811ef77cbfc26f17307b6a9d/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a547e21c5610b7e9093d870be50682a6a6cf180d6da0f42c47c306073bfdbbf6", size = 397146 },
-    { url = "https://files.pythonhosted.org/packages/15/18/9d1b79eb4d18e64ba8bba9e7dec6f9d6920b639f22f07ee9368ca35d4673/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:35e9a70a0f335371275cdcd08bc5b8051ac494dd58bff3bbfb421038220dc871", size = 514804 },
-    { url = "https://files.pythonhosted.org/packages/4f/5a/175ad7191bdbcd28785204621b225ad70e85cdfd1e09cc414cb554633b21/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0dfa6115c6def37905344d56fb54c03afc49104e2ca473d5dedec0f6606913b4", size = 402820 },
-    { url = "https://files.pythonhosted.org/packages/11/45/6a67ecf6d61c4d4aff4bc056e864eec4b2447787e11d1c2c9a0242c6e92a/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:313cfcd6af1a55a286a3c9a25f64af6d0e46cf60bc5798f1db152d97a216ff6f", size = 384567 },
-    { url = "https://files.pythonhosted.org/packages/a1/ba/16589da828732b46454c61858950a78fe4c931ea4bf95f17432ffe64b241/rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f7bf2496fa563c046d05e4d232d7b7fd61346e2402052064b773e5c378bf6f73", size = 416520 },
-    { url = "https://files.pythonhosted.org/packages/81/4b/00092999fc7c0c266045e984d56b7314734cc400a6c6dc4d61a35f135a9d/rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:aa81873e2c8c5aa616ab8e017a481a96742fdf9313c40f14338ca7dbf50cb55f", size = 559362 },
-    { url = "https://files.pythonhosted.org/packages/96/0c/43737053cde1f93ac4945157f7be1428724ab943e2132a0d235a7e161d4e/rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:68ffcf982715f5b5b7686bdd349ff75d422e8f22551000c24b30eaa1b7f7ae84", size = 588113 },
-    { url = "https://files.pythonhosted.org/packages/46/46/8e38f6161466e60a997ed7e9951ae5de131dedc3cf778ad35994b4af823d/rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6188de70e190847bb6db3dc3981cbadff87d27d6fe9b4f0e18726d55795cee9b", size = 555429 },
-    { url = "https://files.pythonhosted.org/packages/2c/ac/65da605e9f1dd643ebe615d5bbd11b6efa1d69644fc4bf623ea5ae385a82/rpds_py-0.26.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1c962145c7473723df9722ba4c058de12eb5ebedcb4e27e7d902920aa3831ee8", size = 231950 },
-    { url = "https://files.pythonhosted.org/packages/51/f2/b5c85b758a00c513bb0389f8fc8e61eb5423050c91c958cdd21843faa3e6/rpds_py-0.26.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f61a9326f80ca59214d1cceb0a09bb2ece5b2563d4e0cd37bfd5515c28510674", size = 373505 },
-    { url = "https://files.pythonhosted.org/packages/23/e0/25db45e391251118e915e541995bb5f5ac5691a3b98fb233020ba53afc9b/rpds_py-0.26.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:183f857a53bcf4b1b42ef0f57ca553ab56bdd170e49d8091e96c51c3d69ca696", size = 359468 },
-    { url = "https://files.pythonhosted.org/packages/0b/73/dd5ee6075bb6491be3a646b301dfd814f9486d924137a5098e61f0487e16/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:941c1cfdf4799d623cf3aa1d326a6b4fdb7a5799ee2687f3516738216d2262fb", size = 382680 },
-    { url = "https://files.pythonhosted.org/packages/2f/10/84b522ff58763a5c443f5bcedc1820240e454ce4e620e88520f04589e2ea/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72a8d9564a717ee291f554eeb4bfeafe2309d5ec0aa6c475170bdab0f9ee8e88", size = 397035 },
-    { url = "https://files.pythonhosted.org/packages/06/ea/8667604229a10a520fcbf78b30ccc278977dcc0627beb7ea2c96b3becef0/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:511d15193cbe013619dd05414c35a7dedf2088fcee93c6bbb7c77859765bd4e8", size = 514922 },
-    { url = "https://files.pythonhosted.org/packages/24/e6/9ed5b625c0661c4882fc8cdf302bf8e96c73c40de99c31e0b95ed37d508c/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aea1f9741b603a8d8fedb0ed5502c2bc0accbc51f43e2ad1337fe7259c2b77a5", size = 402822 },
-    { url = "https://files.pythonhosted.org/packages/8a/58/212c7b6fd51946047fb45d3733da27e2fa8f7384a13457c874186af691b1/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4019a9d473c708cf2f16415688ef0b4639e07abaa569d72f74745bbeffafa2c7", size = 384336 },
-    { url = "https://files.pythonhosted.org/packages/aa/f5/a40ba78748ae8ebf4934d4b88e77b98497378bc2c24ba55ebe87a4e87057/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:093d63b4b0f52d98ebae33b8c50900d3d67e0666094b1be7a12fffd7f65de74b", size = 416871 },
-    { url = "https://files.pythonhosted.org/packages/d5/a6/33b1fc0c9f7dcfcfc4a4353daa6308b3ece22496ceece348b3e7a7559a09/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2abe21d8ba64cded53a2a677e149ceb76dcf44284202d737178afe7ba540c1eb", size = 559439 },
-    { url = "https://files.pythonhosted.org/packages/71/2d/ceb3f9c12f8cfa56d34995097f6cd99da1325642c60d1b6680dd9df03ed8/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:4feb7511c29f8442cbbc28149a92093d32e815a28aa2c50d333826ad2a20fdf0", size = 588380 },
-    { url = "https://files.pythonhosted.org/packages/c8/ed/9de62c2150ca8e2e5858acf3f4f4d0d180a38feef9fdab4078bea63d8dba/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e99685fc95d386da368013e7fb4269dd39c30d99f812a8372d62f244f662709c", size = 555334 },
-]
-
-[[package]]
-name = "rsa"
-version = "4.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696 },
-]
-
-[[package]]
-name = "shapely"
-version = "2.1.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ca/3c/2da625233f4e605155926566c0e7ea8dda361877f48e8b1655e53456f252/shapely-2.1.1.tar.gz", hash = "sha256:500621967f2ffe9642454808009044c21e5b35db89ce69f8a2042c2ffd0e2772", size = 315422 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/fa/f18025c95b86116dd8f1ec58cab078bd59ab51456b448136ca27463be533/shapely-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8ccc872a632acb7bdcb69e5e78df27213f7efd195882668ffba5405497337c6", size = 1825117 },
-    { url = "https://files.pythonhosted.org/packages/c7/65/46b519555ee9fb851234288be7c78be11e6260995281071d13abf2c313d0/shapely-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f24f2ecda1e6c091da64bcbef8dd121380948074875bd1b247b3d17e99407099", size = 1628541 },
-    { url = "https://files.pythonhosted.org/packages/29/51/0b158a261df94e33505eadfe737db9531f346dfa60850945ad25fd4162f1/shapely-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45112a5be0b745b49e50f8829ce490eb67fefb0cea8d4f8ac5764bfedaa83d2d", size = 2948453 },
-    { url = "https://files.pythonhosted.org/packages/a9/4f/6c9bb4bd7b1a14d7051641b9b479ad2a643d5cbc382bcf5bd52fd0896974/shapely-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c10ce6f11904d65e9bbb3e41e774903c944e20b3f0b282559885302f52f224a", size = 3057029 },
-    { url = "https://files.pythonhosted.org/packages/89/0b/ad1b0af491d753a83ea93138eee12a4597f763ae12727968d05934fe7c78/shapely-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:61168010dfe4e45f956ffbbaf080c88afce199ea81eb1f0ac43230065df320bd", size = 3894342 },
-    { url = "https://files.pythonhosted.org/packages/7d/96/73232c5de0b9fdf0ec7ddfc95c43aaf928740e87d9f168bff0e928d78c6d/shapely-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cacf067cdff741cd5c56a21c52f54ece4e4dad9d311130493a791997da4a886b", size = 4056766 },
-    { url = "https://files.pythonhosted.org/packages/43/cc/eec3c01f754f5b3e0c47574b198f9deb70465579ad0dad0e1cef2ce9e103/shapely-2.1.1-cp310-cp310-win32.whl", hash = "sha256:23b8772c3b815e7790fb2eab75a0b3951f435bc0fce7bb146cb064f17d35ab4f", size = 1523744 },
-    { url = "https://files.pythonhosted.org/packages/50/fc/a7187e6dadb10b91e66a9e715d28105cde6489e1017cce476876185a43da/shapely-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:2c7b2b6143abf4fa77851cef8ef690e03feade9a0d48acd6dc41d9e0e78d7ca6", size = 1703061 },
-    { url = "https://files.pythonhosted.org/packages/19/97/2df985b1e03f90c503796ad5ecd3d9ed305123b64d4ccb54616b30295b29/shapely-2.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:587a1aa72bc858fab9b8c20427b5f6027b7cbc92743b8e2c73b9de55aa71c7a7", size = 1819368 },
-    { url = "https://files.pythonhosted.org/packages/56/17/504518860370f0a28908b18864f43d72f03581e2b6680540ca668f07aa42/shapely-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9fa5c53b0791a4b998f9ad84aad456c988600757a96b0a05e14bba10cebaaaea", size = 1625362 },
-    { url = "https://files.pythonhosted.org/packages/36/a1/9677337d729b79fce1ef3296aac6b8ef4743419086f669e8a8070eff8f40/shapely-2.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aabecd038841ab5310d23495253f01c2a82a3aedae5ab9ca489be214aa458aa7", size = 2999005 },
-    { url = "https://files.pythonhosted.org/packages/a2/17/e09357274699c6e012bbb5a8ea14765a4d5860bb658df1931c9f90d53bd3/shapely-2.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:586f6aee1edec04e16227517a866df3e9a2e43c1f635efc32978bb3dc9c63753", size = 3108489 },
-    { url = "https://files.pythonhosted.org/packages/17/5d/93a6c37c4b4e9955ad40834f42b17260ca74ecf36df2e81bb14d12221b90/shapely-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b9878b9e37ad26c72aada8de0c9cfe418d9e2ff36992a1693b7f65a075b28647", size = 3945727 },
-    { url = "https://files.pythonhosted.org/packages/a3/1a/ad696648f16fd82dd6bfcca0b3b8fbafa7aacc13431c7fc4c9b49e481681/shapely-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9a531c48f289ba355e37b134e98e28c557ff13965d4653a5228d0f42a09aed0", size = 4109311 },
-    { url = "https://files.pythonhosted.org/packages/d4/38/150dd245beab179ec0d4472bf6799bf18f21b1efbef59ac87de3377dbf1c/shapely-2.1.1-cp311-cp311-win32.whl", hash = "sha256:4866de2673a971820c75c0167b1f1cd8fb76f2d641101c23d3ca021ad0449bab", size = 1522982 },
-    { url = "https://files.pythonhosted.org/packages/93/5b/842022c00fbb051083c1c85430f3bb55565b7fd2d775f4f398c0ba8052ce/shapely-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:20a9d79958b3d6c70d8a886b250047ea32ff40489d7abb47d01498c704557a93", size = 1703872 },
-    { url = "https://files.pythonhosted.org/packages/fb/64/9544dc07dfe80a2d489060791300827c941c451e2910f7364b19607ea352/shapely-2.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2827365b58bf98efb60affc94a8e01c56dd1995a80aabe4b701465d86dcbba43", size = 1833021 },
-    { url = "https://files.pythonhosted.org/packages/07/aa/fb5f545e72e89b6a0f04a0effda144f5be956c9c312c7d4e00dfddbddbcf/shapely-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9c551f7fa7f1e917af2347fe983f21f212863f1d04f08eece01e9c275903fad", size = 1643018 },
-    { url = "https://files.pythonhosted.org/packages/03/46/61e03edba81de729f09d880ce7ae5c1af873a0814206bbfb4402ab5c3388/shapely-2.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78dec4d4fbe7b1db8dc36de3031767e7ece5911fb7782bc9e95c5cdec58fb1e9", size = 2986417 },
-    { url = "https://files.pythonhosted.org/packages/1f/1e/83ec268ab8254a446b4178b45616ab5822d7b9d2b7eb6e27cf0b82f45601/shapely-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:872d3c0a7b8b37da0e23d80496ec5973c4692920b90de9f502b5beb994bbaaef", size = 3098224 },
-    { url = "https://files.pythonhosted.org/packages/f1/44/0c21e7717c243e067c9ef8fa9126de24239f8345a5bba9280f7bb9935959/shapely-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e2b9125ebfbc28ecf5353511de62f75a8515ae9470521c9a693e4bb9fbe0cf1", size = 3925982 },
-    { url = "https://files.pythonhosted.org/packages/15/50/d3b4e15fefc103a0eb13d83bad5f65cd6e07a5d8b2ae920e767932a247d1/shapely-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4b96cea171b3d7f6786976a0520f178c42792897653ecca0c5422fb1e6946e6d", size = 4089122 },
-    { url = "https://files.pythonhosted.org/packages/bd/05/9a68f27fc6110baeedeeebc14fd86e73fa38738c5b741302408fb6355577/shapely-2.1.1-cp312-cp312-win32.whl", hash = "sha256:39dca52201e02996df02e447f729da97cfb6ff41a03cb50f5547f19d02905af8", size = 1522437 },
-    { url = "https://files.pythonhosted.org/packages/bc/e9/a4560e12b9338842a1f82c9016d2543eaa084fce30a1ca11991143086b57/shapely-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:13d643256f81d55a50013eff6321142781cf777eb6a9e207c2c9e6315ba6044a", size = 1703479 },
-    { url = "https://files.pythonhosted.org/packages/71/8e/2bc836437f4b84d62efc1faddce0d4e023a5d990bbddd3c78b2004ebc246/shapely-2.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3004a644d9e89e26c20286d5fdc10f41b1744c48ce910bd1867fdff963fe6c48", size = 1832107 },
-    { url = "https://files.pythonhosted.org/packages/12/a2/12c7cae5b62d5d851c2db836eadd0986f63918a91976495861f7c492f4a9/shapely-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1415146fa12d80a47d13cfad5310b3c8b9c2aa8c14a0c845c9d3d75e77cb54f6", size = 1642355 },
-    { url = "https://files.pythonhosted.org/packages/5b/7e/6d28b43d53fea56de69c744e34c2b999ed4042f7a811dc1bceb876071c95/shapely-2.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21fcab88b7520820ec16d09d6bea68652ca13993c84dffc6129dc3607c95594c", size = 2968871 },
-    { url = "https://files.pythonhosted.org/packages/dd/87/1017c31e52370b2b79e4d29e07cbb590ab9e5e58cf7e2bdfe363765d6251/shapely-2.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5ce6a5cc52c974b291237a96c08c5592e50f066871704fb5b12be2639d9026a", size = 3080830 },
-    { url = "https://files.pythonhosted.org/packages/1d/fe/f4a03d81abd96a6ce31c49cd8aaba970eaaa98e191bd1e4d43041e57ae5a/shapely-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:04e4c12a45a1d70aeb266618d8cf81a2de9c4df511b63e105b90bfdfb52146de", size = 3908961 },
-    { url = "https://files.pythonhosted.org/packages/ef/59/7605289a95a6844056a2017ab36d9b0cb9d6a3c3b5317c1f968c193031c9/shapely-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6ca74d851ca5264aae16c2b47e96735579686cb69fa93c4078070a0ec845b8d8", size = 4079623 },
-    { url = "https://files.pythonhosted.org/packages/bc/4d/9fea036eff2ef4059d30247128b2d67aaa5f0b25e9fc27e1d15cc1b84704/shapely-2.1.1-cp313-cp313-win32.whl", hash = "sha256:fd9130501bf42ffb7e0695b9ea17a27ae8ce68d50b56b6941c7f9b3d3453bc52", size = 1521916 },
-    { url = "https://files.pythonhosted.org/packages/12/d9/6d13b8957a17c95794f0c4dfb65ecd0957e6c7131a56ce18d135c1107a52/shapely-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:ab8d878687b438a2f4c138ed1a80941c6ab0029e0f4c785ecfe114413b498a97", size = 1702746 },
-    { url = "https://files.pythonhosted.org/packages/60/36/b1452e3e7f35f5f6454d96f3be6e2bb87082720ff6c9437ecc215fa79be0/shapely-2.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c062384316a47f776305ed2fa22182717508ffdeb4a56d0ff4087a77b2a0f6d", size = 1833482 },
-    { url = "https://files.pythonhosted.org/packages/ce/ca/8e6f59be0718893eb3e478141285796a923636dc8f086f83e5b0ec0036d0/shapely-2.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4ecf6c196b896e8f1360cc219ed4eee1c1e5f5883e505d449f263bd053fb8c05", size = 1642256 },
-    { url = "https://files.pythonhosted.org/packages/ab/78/0053aea449bb1d4503999525fec6232f049abcdc8df60d290416110de943/shapely-2.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb00070b4c4860f6743c600285109c273cca5241e970ad56bb87bef0be1ea3a0", size = 3016614 },
-    { url = "https://files.pythonhosted.org/packages/ee/53/36f1b1de1dfafd1b457dcbafa785b298ce1b8a3e7026b79619e708a245d5/shapely-2.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d14a9afa5fa980fbe7bf63706fdfb8ff588f638f145a1d9dbc18374b5b7de913", size = 3093542 },
-    { url = "https://files.pythonhosted.org/packages/b9/bf/0619f37ceec6b924d84427c88835b61f27f43560239936ff88915c37da19/shapely-2.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b640e390dabde790e3fb947198b466e63223e0a9ccd787da5f07bcb14756c28d", size = 3945961 },
-    { url = "https://files.pythonhosted.org/packages/93/c9/20ca4afeb572763b07a7997f00854cb9499df6af85929e93012b189d8917/shapely-2.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:69e08bf9697c1b73ec6aa70437db922bafcea7baca131c90c26d59491a9760f9", size = 4089514 },
-    { url = "https://files.pythonhosted.org/packages/33/6a/27036a5a560b80012a544366bceafd491e8abb94a8db14047b5346b5a749/shapely-2.1.1-cp313-cp313t-win32.whl", hash = "sha256:ef2d09d5a964cc90c2c18b03566cf918a61c248596998a0301d5b632beadb9db", size = 1540607 },
-    { url = "https://files.pythonhosted.org/packages/ea/f1/5e9b3ba5c7aa7ebfaf269657e728067d16a7c99401c7973ddf5f0cf121bd/shapely-2.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8cb8f17c377260452e9d7720eeaf59082c5f8ea48cf104524d953e5d36d4bdb7", size = 1723061 },
-]
-
-[[package]]
-name = "six"
-version = "1.17.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
-]
-
-[[package]]
-name = "sniffio"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
-]
-
-[[package]]
-name = "sqlalchemy"
-version = "2.0.41"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "greenlet", marker = "(python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64')" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/63/66/45b165c595ec89aa7dcc2c1cd222ab269bc753f1fc7a1e68f8481bd957bf/sqlalchemy-2.0.41.tar.gz", hash = "sha256:edba70118c4be3c2b1f90754d308d0b79c6fe2c0fdc52d8ddf603916f83f4db9", size = 9689424 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/12/d7c445b1940276a828efce7331cb0cb09d6e5f049651db22f4ebb0922b77/sqlalchemy-2.0.41-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b1f09b6821406ea1f94053f346f28f8215e293344209129a9c0fcc3578598d7b", size = 2117967 },
-    { url = "https://files.pythonhosted.org/packages/6f/b8/cb90f23157e28946b27eb01ef401af80a1fab7553762e87df51507eaed61/sqlalchemy-2.0.41-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1936af879e3db023601196a1684d28e12f19ccf93af01bf3280a3262c4b6b4e5", size = 2107583 },
-    { url = "https://files.pythonhosted.org/packages/9e/c2/eef84283a1c8164a207d898e063edf193d36a24fb6a5bb3ce0634b92a1e8/sqlalchemy-2.0.41-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2ac41acfc8d965fb0c464eb8f44995770239668956dc4cdf502d1b1ffe0d747", size = 3186025 },
-    { url = "https://files.pythonhosted.org/packages/bd/72/49d52bd3c5e63a1d458fd6d289a1523a8015adedbddf2c07408ff556e772/sqlalchemy-2.0.41-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81c24e0c0fde47a9723c81d5806569cddef103aebbf79dbc9fcbb617153dea30", size = 3186259 },
-    { url = "https://files.pythonhosted.org/packages/4f/9e/e3ffc37d29a3679a50b6bbbba94b115f90e565a2b4545abb17924b94c52d/sqlalchemy-2.0.41-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23a8825495d8b195c4aa9ff1c430c28f2c821e8c5e2d98089228af887e5d7e29", size = 3126803 },
-    { url = "https://files.pythonhosted.org/packages/8a/76/56b21e363f6039978ae0b72690237b38383e4657281285a09456f313dd77/sqlalchemy-2.0.41-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:60c578c45c949f909a4026b7807044e7e564adf793537fc762b2489d522f3d11", size = 3148566 },
-    { url = "https://files.pythonhosted.org/packages/3b/92/11b8e1b69bf191bc69e300a99badbbb5f2f1102f2b08b39d9eee2e21f565/sqlalchemy-2.0.41-cp310-cp310-win32.whl", hash = "sha256:118c16cd3f1b00c76d69343e38602006c9cfb9998fa4f798606d28d63f23beda", size = 2086696 },
-    { url = "https://files.pythonhosted.org/packages/5c/88/2d706c9cc4502654860f4576cd54f7db70487b66c3b619ba98e0be1a4642/sqlalchemy-2.0.41-cp310-cp310-win_amd64.whl", hash = "sha256:7492967c3386df69f80cf67efd665c0f667cee67032090fe01d7d74b0e19bb08", size = 2110200 },
-    { url = "https://files.pythonhosted.org/packages/37/4e/b00e3ffae32b74b5180e15d2ab4040531ee1bef4c19755fe7926622dc958/sqlalchemy-2.0.41-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6375cd674fe82d7aa9816d1cb96ec592bac1726c11e0cafbf40eeee9a4516b5f", size = 2121232 },
-    { url = "https://files.pythonhosted.org/packages/ef/30/6547ebb10875302074a37e1970a5dce7985240665778cfdee2323709f749/sqlalchemy-2.0.41-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9f8c9fdd15a55d9465e590a402f42082705d66b05afc3ffd2d2eb3c6ba919560", size = 2110897 },
-    { url = "https://files.pythonhosted.org/packages/9e/21/59df2b41b0f6c62da55cd64798232d7349a9378befa7f1bb18cf1dfd510a/sqlalchemy-2.0.41-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32f9dc8c44acdee06c8fc6440db9eae8b4af8b01e4b1aee7bdd7241c22edff4f", size = 3273313 },
-    { url = "https://files.pythonhosted.org/packages/62/e4/b9a7a0e5c6f79d49bcd6efb6e90d7536dc604dab64582a9dec220dab54b6/sqlalchemy-2.0.41-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90c11ceb9a1f482c752a71f203a81858625d8df5746d787a4786bca4ffdf71c6", size = 3273807 },
-    { url = "https://files.pythonhosted.org/packages/39/d8/79f2427251b44ddee18676c04eab038d043cff0e764d2d8bb08261d6135d/sqlalchemy-2.0.41-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:911cc493ebd60de5f285bcae0491a60b4f2a9f0f5c270edd1c4dbaef7a38fc04", size = 3209632 },
-    { url = "https://files.pythonhosted.org/packages/d4/16/730a82dda30765f63e0454918c982fb7193f6b398b31d63c7c3bd3652ae5/sqlalchemy-2.0.41-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03968a349db483936c249f4d9cd14ff2c296adfa1290b660ba6516f973139582", size = 3233642 },
-    { url = "https://files.pythonhosted.org/packages/04/61/c0d4607f7799efa8b8ea3c49b4621e861c8f5c41fd4b5b636c534fcb7d73/sqlalchemy-2.0.41-cp311-cp311-win32.whl", hash = "sha256:293cd444d82b18da48c9f71cd7005844dbbd06ca19be1ccf6779154439eec0b8", size = 2086475 },
-    { url = "https://files.pythonhosted.org/packages/9d/8e/8344f8ae1cb6a479d0741c02cd4f666925b2bf02e2468ddaf5ce44111f30/sqlalchemy-2.0.41-cp311-cp311-win_amd64.whl", hash = "sha256:3d3549fc3e40667ec7199033a4e40a2f669898a00a7b18a931d3efb4c7900504", size = 2110903 },
-    { url = "https://files.pythonhosted.org/packages/3e/2a/f1f4e068b371154740dd10fb81afb5240d5af4aa0087b88d8b308b5429c2/sqlalchemy-2.0.41-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:81f413674d85cfd0dfcd6512e10e0f33c19c21860342a4890c3a2b59479929f9", size = 2119645 },
-    { url = "https://files.pythonhosted.org/packages/9b/e8/c664a7e73d36fbfc4730f8cf2bf930444ea87270f2825efbe17bf808b998/sqlalchemy-2.0.41-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:598d9ebc1e796431bbd068e41e4de4dc34312b7aa3292571bb3674a0cb415dd1", size = 2107399 },
-    { url = "https://files.pythonhosted.org/packages/5c/78/8a9cf6c5e7135540cb682128d091d6afa1b9e48bd049b0d691bf54114f70/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a104c5694dfd2d864a6f91b0956eb5d5883234119cb40010115fd45a16da5e70", size = 3293269 },
-    { url = "https://files.pythonhosted.org/packages/3c/35/f74add3978c20de6323fb11cb5162702670cc7a9420033befb43d8d5b7a4/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6145afea51ff0af7f2564a05fa95eb46f542919e6523729663a5d285ecb3cf5e", size = 3303364 },
-    { url = "https://files.pythonhosted.org/packages/6a/d4/c990f37f52c3f7748ebe98883e2a0f7d038108c2c5a82468d1ff3eec50b7/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b46fa6eae1cd1c20e6e6f44e19984d438b6b2d8616d21d783d150df714f44078", size = 3229072 },
-    { url = "https://files.pythonhosted.org/packages/15/69/cab11fecc7eb64bc561011be2bd03d065b762d87add52a4ca0aca2e12904/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41836fe661cc98abfae476e14ba1906220f92c4e528771a8a3ae6a151242d2ae", size = 3268074 },
-    { url = "https://files.pythonhosted.org/packages/5c/ca/0c19ec16858585d37767b167fc9602593f98998a68a798450558239fb04a/sqlalchemy-2.0.41-cp312-cp312-win32.whl", hash = "sha256:a8808d5cf866c781150d36a3c8eb3adccfa41a8105d031bf27e92c251e3969d6", size = 2084514 },
-    { url = "https://files.pythonhosted.org/packages/7f/23/4c2833d78ff3010a4e17f984c734f52b531a8c9060a50429c9d4b0211be6/sqlalchemy-2.0.41-cp312-cp312-win_amd64.whl", hash = "sha256:5b14e97886199c1f52c14629c11d90c11fbb09e9334fa7bb5f6d068d9ced0ce0", size = 2111557 },
-    { url = "https://files.pythonhosted.org/packages/d3/ad/2e1c6d4f235a97eeef52d0200d8ddda16f6c4dd70ae5ad88c46963440480/sqlalchemy-2.0.41-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4eeb195cdedaf17aab6b247894ff2734dcead6c08f748e617bfe05bd5a218443", size = 2115491 },
-    { url = "https://files.pythonhosted.org/packages/cf/8d/be490e5db8400dacc89056f78a52d44b04fbf75e8439569d5b879623a53b/sqlalchemy-2.0.41-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d4ae769b9c1c7757e4ccce94b0641bc203bbdf43ba7a2413ab2523d8d047d8dc", size = 2102827 },
-    { url = "https://files.pythonhosted.org/packages/a0/72/c97ad430f0b0e78efaf2791342e13ffeafcbb3c06242f01a3bb8fe44f65d/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a62448526dd9ed3e3beedc93df9bb6b55a436ed1474db31a2af13b313a70a7e1", size = 3225224 },
-    { url = "https://files.pythonhosted.org/packages/5e/51/5ba9ea3246ea068630acf35a6ba0d181e99f1af1afd17e159eac7e8bc2b8/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc56c9788617b8964ad02e8fcfeed4001c1f8ba91a9e1f31483c0dffb207002a", size = 3230045 },
-    { url = "https://files.pythonhosted.org/packages/78/2f/8c14443b2acea700c62f9b4a8bad9e49fc1b65cfb260edead71fd38e9f19/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c153265408d18de4cc5ded1941dcd8315894572cddd3c58df5d5b5705b3fa28d", size = 3159357 },
-    { url = "https://files.pythonhosted.org/packages/fc/b2/43eacbf6ccc5276d76cea18cb7c3d73e294d6fb21f9ff8b4eef9b42bbfd5/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f67766965996e63bb46cfbf2ce5355fc32d9dd3b8ad7e536a920ff9ee422e23", size = 3197511 },
-    { url = "https://files.pythonhosted.org/packages/fa/2e/677c17c5d6a004c3c45334ab1dbe7b7deb834430b282b8a0f75ae220c8eb/sqlalchemy-2.0.41-cp313-cp313-win32.whl", hash = "sha256:bfc9064f6658a3d1cadeaa0ba07570b83ce6801a1314985bf98ec9b95d74e15f", size = 2082420 },
-    { url = "https://files.pythonhosted.org/packages/e9/61/e8c1b9b6307c57157d328dd8b8348ddc4c47ffdf1279365a13b2b98b8049/sqlalchemy-2.0.41-cp313-cp313-win_amd64.whl", hash = "sha256:82ca366a844eb551daff9d2e6e7a9e5e76d2612c8564f58db6c19a726869c1df", size = 2108329 },
-    { url = "https://files.pythonhosted.org/packages/1c/fc/9ba22f01b5cdacc8f5ed0d22304718d2c758fce3fd49a5372b886a86f37c/sqlalchemy-2.0.41-py3-none-any.whl", hash = "sha256:57df5dc6fdb5ed1a88a1ed2195fd31927e705cad62dedd86b46972752a80f576", size = 1911224 },
-]
-
-[[package]]
-name = "sse-starlette"
-version = "2.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/07/3e/eae74d8d33e3262bae0a7e023bb43d8bdd27980aa3557333f4632611151f/sse_starlette-2.4.1.tar.gz", hash = "sha256:7c8a800a1ca343e9165fc06bbda45c78e4c6166320707ae30b416c42da070926", size = 18635 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/f1/6c7eaa8187ba789a6dd6d74430307478d2a91c23a5452ab339b6fbe15a08/sse_starlette-2.4.1-py3-none-any.whl", hash = "sha256:08b77ea898ab1a13a428b2b6f73cfe6d0e607a7b4e15b9bb23e4a37b087fd39a", size = 10824 },
-]
-
-[[package]]
-name = "starlette"
-version = "0.47.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0a/69/662169fdb92fb96ec3eaee218cf540a629d629c86d7993d9651226a6789b/starlette-0.47.1.tar.gz", hash = "sha256:aef012dd2b6be325ffa16698f9dc533614fb1cebd593a906b90dc1025529a79b", size = 2583072 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/95/38ef0cd7fa11eaba6a99b3c4f5ac948d8bc6ff199aabd327a29cc000840c/starlette-0.47.1-py3-none-any.whl", hash = "sha256:5e11c9f5c7c3f24959edbf2dffdc01bba860228acf657129467d8a7468591527", size = 72747 },
-]
-
-[[package]]
-name = "tenacity"
-version = "9.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248 },
-]
-
-[[package]]
-name = "tomli"
-version = "2.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 },
-    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 },
-    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 },
-    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 },
-    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 },
-    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 },
-    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 },
-    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 },
-    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 },
-    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 },
-    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 },
-    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 },
-    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 },
-    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 },
-    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 },
-    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 },
-    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 },
-    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 },
-    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 },
-    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 },
-    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 },
-    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 },
-    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 },
-    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 },
-    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 },
-    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 },
-    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 },
-    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 },
-    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 },
-    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 },
-    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 },
-]
-
-[[package]]
-name = "truststore"
-version = "0.10.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0f/a7/b7a43228762966a13598a404f3dfb4803ea29a906f449d8b0e73ed0bcd30/truststore-0.10.1.tar.gz", hash = "sha256:eda021616b59021812e800fa0a071e51b266721bef3ce092db8a699e21c63539", size = 26101 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bc/df/8ad635bdcfa8214c399e5614f7c2121dced47defb755a85ea1fa702ffb1c/truststore-0.10.1-py3-none-any.whl", hash = "sha256:b64e6025a409a43ebdd2807b0c41c8bff49ea7ae6550b5087ac6df6619352d4c", size = 18496 },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.14.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906 },
-]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552 },
-]
-
-[[package]]
-name = "tzdata"
-version = "2025.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 },
-]
-
-[[package]]
-name = "tzlocal"
-version = "5.3.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "tzdata", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026 },
-]
-
-[[package]]
-name = "uipath"
-version = "2.0.78"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-monitor-opentelemetry" },
-    { name = "click" },
-    { name = "httpx" },
-    { name = "opentelemetry-sdk" },
-    { name = "pathlib" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "rich" },
-    { name = "tenacity" },
-    { name = "tomli" },
-    { name = "truststore" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/27/7d/b3d25cc9e2094cc4b5a9182aa5b03dfc0c9ee092b590d2e2404057916d47/uipath-2.0.78.tar.gz", hash = "sha256:d8c120bbdea0350050a55ffc61350ee75756136411c70a534ef50b77eb4fa862", size = 1842395 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/96/496dd5d4f1946eefb51e9c915f20955a104588c87058bf8e7b519b9b4703/uipath-2.0.78-py3-none-any.whl", hash = "sha256:c6328afa36d6a41e21040adbf80457c01f038f435933aedffec7a6986cb82501", size = 133859 },
-]
-
-[[package]]
-name = "uritemplate"
-version = "4.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/60/f174043244c5306c9988380d2cb10009f91563fc4b31293d27e17201af56/uritemplate-4.2.0.tar.gz", hash = "sha256:480c2ed180878955863323eea31b0ede668795de182617fef9c6ca09e6ec9d0e", size = 33267 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a9/99/3ae339466c9183ea5b8ae87b34c0b897eda475d2aec2307cae60e5cd4f29/uritemplate-4.2.0-py3-none-any.whl", hash = "sha256:962201ba1c4edcab02e60f9a0d3821e82dfc5d2d6662a21abd533879bdb8a686", size = 11488 },
-]
-
-[[package]]
-name = "urllib3"
-version = "2.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 },
-]
-
-[[package]]
-name = "uvicorn"
-version = "0.35.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "h11" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406 },
-]
-
-[[package]]
-name = "websockets"
-version = "15.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423 },
-    { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080 },
-    { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329 },
-    { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312 },
-    { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319 },
-    { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631 },
-    { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016 },
-    { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426 },
-    { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360 },
-    { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388 },
-    { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830 },
-    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423 },
-    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082 },
-    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330 },
-    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878 },
-    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883 },
-    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252 },
-    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521 },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958 },
-    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918 },
-    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388 },
-    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828 },
-    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437 },
-    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096 },
-    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332 },
-    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152 },
-    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096 },
-    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523 },
-    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790 },
-    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165 },
-    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160 },
-    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395 },
-    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841 },
-    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440 },
-    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098 },
-    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329 },
-    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111 },
-    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054 },
-    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496 },
-    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829 },
-    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217 },
-    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195 },
-    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393 },
-    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837 },
-    { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109 },
-    { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343 },
-    { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599 },
-    { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207 },
-    { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155 },
-    { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884 },
-    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743 },
-]
-
-[[package]]
-name = "wrapt"
-version = "1.17.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/d1/1daec934997e8b160040c78d7b31789f19b122110a75eca3d4e8da0049e1/wrapt-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3d57c572081fed831ad2d26fd430d565b76aa277ed1d30ff4d40670b1c0dd984", size = 53307 },
-    { url = "https://files.pythonhosted.org/packages/1b/7b/13369d42651b809389c1a7153baa01d9700430576c81a2f5c5e460df0ed9/wrapt-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5e251054542ae57ac7f3fba5d10bfff615b6c2fb09abeb37d2f1463f841ae22", size = 38486 },
-    { url = "https://files.pythonhosted.org/packages/62/bf/e0105016f907c30b4bd9e377867c48c34dc9c6c0c104556c9c9126bd89ed/wrapt-1.17.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:80dd7db6a7cb57ffbc279c4394246414ec99537ae81ffd702443335a61dbf3a7", size = 38777 },
-    { url = "https://files.pythonhosted.org/packages/27/70/0f6e0679845cbf8b165e027d43402a55494779295c4b08414097b258ac87/wrapt-1.17.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a6e821770cf99cc586d33833b2ff32faebdbe886bd6322395606cf55153246c", size = 83314 },
-    { url = "https://files.pythonhosted.org/packages/0f/77/0576d841bf84af8579124a93d216f55d6f74374e4445264cb378a6ed33eb/wrapt-1.17.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b60fb58b90c6d63779cb0c0c54eeb38941bae3ecf7a73c764c52c88c2dcb9d72", size = 74947 },
-    { url = "https://files.pythonhosted.org/packages/90/ec/00759565518f268ed707dcc40f7eeec38637d46b098a1f5143bff488fe97/wrapt-1.17.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b870b5df5b71d8c3359d21be8f0d6c485fa0ebdb6477dda51a1ea54a9b558061", size = 82778 },
-    { url = "https://files.pythonhosted.org/packages/f8/5a/7cffd26b1c607b0b0c8a9ca9d75757ad7620c9c0a9b4a25d3f8a1480fafc/wrapt-1.17.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4011d137b9955791f9084749cba9a367c68d50ab8d11d64c50ba1688c9b457f2", size = 81716 },
-    { url = "https://files.pythonhosted.org/packages/7e/09/dccf68fa98e862df7e6a60a61d43d644b7d095a5fc36dbb591bbd4a1c7b2/wrapt-1.17.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1473400e5b2733e58b396a04eb7f35f541e1fb976d0c0724d0223dd607e0f74c", size = 74548 },
-    { url = "https://files.pythonhosted.org/packages/b7/8e/067021fa3c8814952c5e228d916963c1115b983e21393289de15128e867e/wrapt-1.17.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3cedbfa9c940fdad3e6e941db7138e26ce8aad38ab5fe9dcfadfed9db7a54e62", size = 81334 },
-    { url = "https://files.pythonhosted.org/packages/4b/0d/9d4b5219ae4393f718699ca1c05f5ebc0c40d076f7e65fd48f5f693294fb/wrapt-1.17.2-cp310-cp310-win32.whl", hash = "sha256:582530701bff1dec6779efa00c516496968edd851fba224fbd86e46cc6b73563", size = 36427 },
-    { url = "https://files.pythonhosted.org/packages/72/6a/c5a83e8f61aec1e1aeef939807602fb880e5872371e95df2137142f5c58e/wrapt-1.17.2-cp310-cp310-win_amd64.whl", hash = "sha256:58705da316756681ad3c9c73fd15499aa4d8c69f9fd38dc8a35e06c12468582f", size = 38774 },
-    { url = "https://files.pythonhosted.org/packages/cd/f7/a2aab2cbc7a665efab072344a8949a71081eed1d2f451f7f7d2b966594a2/wrapt-1.17.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ff04ef6eec3eee8a5efef2401495967a916feaa353643defcc03fc74fe213b58", size = 53308 },
-    { url = "https://files.pythonhosted.org/packages/50/ff/149aba8365fdacef52b31a258c4dc1c57c79759c335eff0b3316a2664a64/wrapt-1.17.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db983e7bca53819efdbd64590ee96c9213894272c776966ca6306b73e4affda", size = 38488 },
-    { url = "https://files.pythonhosted.org/packages/65/46/5a917ce85b5c3b490d35c02bf71aedaa9f2f63f2d15d9949cc4ba56e8ba9/wrapt-1.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9abc77a4ce4c6f2a3168ff34b1da9b0f311a8f1cfd694ec96b0603dff1c79438", size = 38776 },
-    { url = "https://files.pythonhosted.org/packages/ca/74/336c918d2915a4943501c77566db41d1bd6e9f4dbc317f356b9a244dfe83/wrapt-1.17.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b929ac182f5ace000d459c59c2c9c33047e20e935f8e39371fa6e3b85d56f4a", size = 83776 },
-    { url = "https://files.pythonhosted.org/packages/09/99/c0c844a5ccde0fe5761d4305485297f91d67cf2a1a824c5f282e661ec7ff/wrapt-1.17.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f09b286faeff3c750a879d336fb6d8713206fc97af3adc14def0cdd349df6000", size = 75420 },
-    { url = "https://files.pythonhosted.org/packages/b4/b0/9fc566b0fe08b282c850063591a756057c3247b2362b9286429ec5bf1721/wrapt-1.17.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7ed2d9d039bd41e889f6fb9364554052ca21ce823580f6a07c4ec245c1f5d6", size = 83199 },
-    { url = "https://files.pythonhosted.org/packages/9d/4b/71996e62d543b0a0bd95dda485219856def3347e3e9380cc0d6cf10cfb2f/wrapt-1.17.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:129a150f5c445165ff941fc02ee27df65940fcb8a22a61828b1853c98763a64b", size = 82307 },
-    { url = "https://files.pythonhosted.org/packages/39/35/0282c0d8789c0dc9bcc738911776c762a701f95cfe113fb8f0b40e45c2b9/wrapt-1.17.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1fb5699e4464afe5c7e65fa51d4f99e0b2eadcc176e4aa33600a3df7801d6662", size = 75025 },
-    { url = "https://files.pythonhosted.org/packages/4f/6d/90c9fd2c3c6fee181feecb620d95105370198b6b98a0770cba090441a828/wrapt-1.17.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9a2bce789a5ea90e51a02dfcc39e31b7f1e662bc3317979aa7e5538e3a034f72", size = 81879 },
-    { url = "https://files.pythonhosted.org/packages/8f/fa/9fb6e594f2ce03ef03eddbdb5f4f90acb1452221a5351116c7c4708ac865/wrapt-1.17.2-cp311-cp311-win32.whl", hash = "sha256:4afd5814270fdf6380616b321fd31435a462019d834f83c8611a0ce7484c7317", size = 36419 },
-    { url = "https://files.pythonhosted.org/packages/47/f8/fb1773491a253cbc123c5d5dc15c86041f746ed30416535f2a8df1f4a392/wrapt-1.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:acc130bc0375999da18e3d19e5a86403667ac0c4042a094fefb7eec8ebac7cf3", size = 38773 },
-    { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799 },
-    { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821 },
-    { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919 },
-    { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721 },
-    { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899 },
-    { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222 },
-    { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707 },
-    { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685 },
-    { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567 },
-    { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672 },
-    { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865 },
-    { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800 },
-    { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824 },
-    { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920 },
-    { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690 },
-    { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861 },
-    { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174 },
-    { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721 },
-    { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763 },
-    { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585 },
-    { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676 },
-    { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871 },
-    { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312 },
-    { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062 },
-    { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155 },
-    { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471 },
-    { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208 },
-    { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339 },
-    { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232 },
-    { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476 },
-    { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377 },
-    { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986 },
-    { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750 },
-    { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594 },
-]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276 },
-]
diff --git a/sonar-project.properties b/sonar-project.properties
new file mode 100644
index 000000000..939a3a112
--- /dev/null
+++ b/sonar-project.properties
@@ -0,0 +1,13 @@
+sonar.projectKey=UiPath_uipath-python
+sonar.organization=ui
+sonar.host.url=https://sonarcloud.io
+
+sonar.sources=packages/uipath/src,packages/uipath-core/src,packages/uipath-platform/src
+sonar.tests=packages/uipath/tests,packages/uipath-core/tests,packages/uipath-platform/tests
+
+sonar.python.version=3.11,3.12,3.13
+sonar.python.coverage.reportPaths=packages/uipath/coverage.xml,packages/uipath-core/coverage.xml,packages/uipath-platform/coverage.xml
+
+sonar.exclusions=**/samples/**,**/testcases/**,**/template/**,**/_resources/**
+
+sonar.sourceEncoding=UTF-8
diff --git a/src/uipath/_cli/__init__.py b/src/uipath/_cli/__init__.py
deleted file mode 100644
index 5e7c93eff..000000000
--- a/src/uipath/_cli/__init__.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import importlib.metadata
-import sys
-
-import click
-
-from .cli_auth import auth as auth  # type: ignore
-from .cli_deploy import deploy as deploy  # type: ignore
-from .cli_init import init as init  # type: ignore
-from .cli_invoke import invoke as invoke  # type: ignore
-from .cli_new import new as new  # type: ignore
-from .cli_pack import pack as pack  # type: ignore
-from .cli_publish import publish as publish  # type: ignore
-from .cli_run import run as run  # type: ignore
-
-
-def _get_safe_version() -> str:
-    """Get the version of the uipath package."""
-    try:
-        version = importlib.metadata.version("uipath")
-        return version
-    except importlib.metadata.PackageNotFoundError:
-        return "unknown"
-
-
-@click.group(invoke_without_command=True)
-@click.version_option(
-    _get_safe_version(),
-    prog_name="uipath",
-    message="%(prog)s version %(version)s",
-)
-@click.option(
-    "-lv",
-    is_flag=True,
-    help="Display the current version of uipath-langchain.",
-)
-@click.option(
-    "-v",
-    is_flag=True,
-    help="Display the current version of uipath.",
-)
-def cli(lv: bool, v: bool) -> None:
-    if lv:
-        try:
-            version = importlib.metadata.version("uipath-langchain")
-            click.echo(f"uipath-langchain version {version}")
-        except importlib.metadata.PackageNotFoundError:
-            click.echo("uipath-langchain is not installed", err=True)
-            sys.exit(1)
-    if v:
-        try:
-            version = importlib.metadata.version("uipath")
-            click.echo(f"uipath version {version}")
-        except importlib.metadata.PackageNotFoundError:
-            click.echo("uipath is not installed", err=True)
-            sys.exit(1)
-
-
-cli.add_command(new)
-cli.add_command(init)
-cli.add_command(pack)
-cli.add_command(publish)
-cli.add_command(run)
-cli.add_command(deploy)
-cli.add_command(auth)
-cli.add_command(invoke)
diff --git a/src/uipath/_cli/_auth/_client_credentials.py b/src/uipath/_cli/_auth/_client_credentials.py
deleted file mode 100644
index b6042d2b3..000000000
--- a/src/uipath/_cli/_auth/_client_credentials.py
+++ /dev/null
@@ -1,146 +0,0 @@
-from typing import Optional
-from urllib.parse import urlparse
-
-import httpx
-
-from ..._utils._ssl_context import get_httpx_client_kwargs
-from .._utils._console import ConsoleLogger
-from ._models import TokenData
-from ._utils import parse_access_token, update_env_file
-
-console = ConsoleLogger()
-
-
-class ClientCredentialsService:
-    """Service for client credentials authentication flow."""
-
-    def __init__(self, domain: str):
-        self.domain = domain
-
-    def get_token_url(self) -> str:
-        """Get the token URL for the specified domain."""
-        match self.domain:
-            case "alpha":
-                return "https://alpha.uipath.com/identity_/connect/token"
-            case "staging":
-                return "https://staging.uipath.com/identity_/connect/token"
-            case _:  # cloud (default)
-                return "https://cloud.uipath.com/identity_/connect/token"
-
-    def _is_valid_domain_or_subdomain(self, hostname: str, domain: str) -> bool:
-        """Check if hostname is either an exact match or a valid subdomain of the domain.
-
-        Args:
-            hostname: The hostname to check
-            domain: The domain to validate against
-
-        Returns:
-            True if hostname is valid domain or subdomain, False otherwise
-        """
-        return hostname == domain or hostname.endswith(f".{domain}")
-
-    def extract_domain_from_base_url(self, base_url: str) -> str:
-        """Extract domain from base URL.
-
-        Args:
-            base_url: The base URL to extract domain from
-
-        Returns:
-            The domain (alpha, staging, or cloud)
-        """
-        try:
-            parsed = urlparse(base_url)
-            hostname = parsed.hostname
-
-            if hostname:
-                match hostname:
-                    case h if self._is_valid_domain_or_subdomain(h, "alpha.uipath.com"):
-                        return "alpha"
-                    case h if self._is_valid_domain_or_subdomain(
-                        h, "staging.uipath.com"
-                    ):
-                        return "staging"
-                    case h if self._is_valid_domain_or_subdomain(h, "cloud.uipath.com"):
-                        return "cloud"
-
-            # Default to cloud if we can't determine
-            return "cloud"
-        except Exception:
-            # Default to cloud if parsing fails
-            return "cloud"
-
-    def authenticate(
-        self, client_id: str, client_secret: str, scope: str = "OR.Execution"
-    ) -> Optional[TokenData]:
-        """Authenticate using client credentials flow.
-
-        Args:
-            client_id: The client ID for authentication
-            client_secret: The client secret for authentication
-            scope: The scope for the token (default: OR.Execution)
-
-        Returns:
-            Token data if successful, None otherwise
-        """
-        token_url = self.get_token_url()
-
-        data = {
-            "grant_type": "client_credentials",
-            "client_id": client_id,
-            "client_secret": client_secret,
-            "scope": scope,
-        }
-
-        try:
-            with httpx.Client(**get_httpx_client_kwargs()) as client:
-                response = client.post(token_url, data=data)
-                match response.status_code:
-                    case 200:
-                        token_data = response.json()
-                        return {
-                            "access_token": token_data["access_token"],
-                            "token_type": token_data.get("token_type", "Bearer"),
-                            "expires_in": token_data.get("expires_in", 3600),
-                            "scope": token_data.get("scope", scope),
-                            # Client credentials flow doesn't provide these, but we need them for compatibility
-                            "refresh_token": "",
-                            "id_token": "",
-                        }
-                    case 400:
-                        console.error(
-                            "Invalid client credentials or request parameters."
-                        )
-                        return None
-                    case 401:
-                        console.error("Unauthorized: Invalid client credentials.")
-                        return None
-                    case _:
-                        console.error(
-                            f"Authentication failed: {response.status_code} - {response.text}"
-                        )
-                        return None
-
-        except httpx.RequestError as e:
-            console.error(f"Network error during authentication: {e}")
-            return None
-        except Exception as e:
-            console.error(f"Unexpected error during authentication: {e}")
-            return None
-
-    def setup_environment(self, token_data: TokenData, base_url: str):
-        """Setup environment variables for client credentials authentication.
-
-        Args:
-            token_data: The token data from authentication
-            base_url: The base URL for the UiPath instance
-        """
-        parsed_access_token = parse_access_token(token_data["access_token"])
-
-        env_vars = {
-            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-            "UIPATH_URL": base_url,
-            "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
-            "UIPATH_TENANT_ID": "",
-        }
-
-        update_env_file(env_vars)
diff --git a/src/uipath/_cli/_auth/_models.py b/src/uipath/_cli/_auth/_models.py
deleted file mode 100644
index 32fc45df4..000000000
--- a/src/uipath/_cli/_auth/_models.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from typing import TypedDict
-
-
-class AuthConfig(TypedDict):
-    """TypedDict for auth_config.json structure."""
-
-    client_id: str
-    port: int
-    redirect_uri: str
-    scope: str
-
-
-class TokenData(TypedDict):
-    """TypedDict for token data structure."""
-
-    access_token: str
-    refresh_token: str
-    expires_in: int
-    token_type: str
-    scope: str
-    id_token: str
-
-
-class AccessTokenData(TypedDict):
-    """TypedDict for access token data structure."""
-
-    sub: str
-    prt_id: str
-    client_id: str
-    exp: float
-
-
-class TenantInfo(TypedDict):
-    """TypedDict for tenant info structure."""
-
-    name: str
-    id: str
-
-
-class OrganizationInfo(TypedDict):
-    """TypedDict for organization info structure."""
-
-    id: str
-    name: str
-
-
-class TenantsAndOrganizationInfoResponse(TypedDict):
-    """TypedDict for tenants and organization info response structure."""
-
-    tenants: list[TenantInfo]
-    organization: OrganizationInfo
diff --git a/src/uipath/_cli/_auth/_oidc_utils.py b/src/uipath/_cli/_auth/_oidc_utils.py
deleted file mode 100644
index 9bc047d86..000000000
--- a/src/uipath/_cli/_auth/_oidc_utils.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import base64
-import hashlib
-import json
-import os
-from urllib.parse import urlencode
-
-from ._models import AuthConfig
-
-
-def generate_code_verifier_and_challenge():
-    """Generate PKCE code verifier and challenge."""
-    code_verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
-
-    code_challenge_bytes = hashlib.sha256(code_verifier.encode("utf-8")).digest()
-    code_challenge = (
-        base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8").rstrip("=")
-    )
-
-    return code_verifier, code_challenge
-
-
-def get_state_param() -> str:
-    return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
-
-
-def get_auth_config() -> AuthConfig:
-    auth_config = {}
-    with open(os.path.join(os.path.dirname(__file__), "auth_config.json"), "r") as f:
-        auth_config = json.load(f)
-
-    port = auth_config.get("port", 8104)
-
-    redirect_uri = auth_config["redirect_uri"].replace("__PY_REPLACE_PORT__", str(port))
-
-    return AuthConfig(
-        client_id=auth_config["client_id"],
-        redirect_uri=redirect_uri,
-        scope=auth_config["scope"],
-        port=port,
-    )
-
-
-def get_auth_url(domain: str) -> tuple[str, str, str]:
-    """Get the authorization URL for OAuth2 PKCE flow.
-
-    Args:
-        domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
-
-    Returns:
-        tuple[str, str]: A tuple containing:
-            - The authorization URL with query parameters
-            - The code verifier for PKCE flow
-    """
-    code_verifier, code_challenge = generate_code_verifier_and_challenge()
-    auth_config = get_auth_config()
-    state = get_state_param()
-    query_params = {
-        "client_id": auth_config["client_id"],
-        "redirect_uri": auth_config["redirect_uri"],
-        "response_type": "code",
-        "scope": auth_config["scope"],
-        "state": state,
-        "code_challenge": code_challenge,
-        "code_challenge_method": "S256",
-    }
-
-    query_string = urlencode(query_params)
-    url = f"https://{domain}.uipath.com/identity_/connect/authorize?{query_string}"
-    return url, code_verifier, state
diff --git a/src/uipath/_cli/_auth/_portal_service.py b/src/uipath/_cli/_auth/_portal_service.py
deleted file mode 100644
index 45da670ec..000000000
--- a/src/uipath/_cli/_auth/_portal_service.py
+++ /dev/null
@@ -1,224 +0,0 @@
-import os
-import time
-from typing import Optional
-
-import click
-import httpx
-
-from ..._utils._ssl_context import get_httpx_client_kwargs
-from .._utils._console import ConsoleLogger
-from ._models import TenantsAndOrganizationInfoResponse, TokenData
-from ._oidc_utils import get_auth_config
-from ._utils import (
-    get_auth_data,
-    get_parsed_token_data,
-    update_auth_file,
-    update_env_file,
-)
-
-console = ConsoleLogger()
-
-
-class PortalService:
-    """Service for interacting with the UiPath Portal API."""
-
-    access_token: Optional[str] = None
-    prt_id: Optional[str] = None
-    domain: Optional[str] = None
-    selected_tenant: Optional[str] = None
-
-    _client: Optional[httpx.Client] = None
-
-    _tenants_and_organizations: Optional[TenantsAndOrganizationInfoResponse] = None
-
-    def __init__(
-        self,
-        domain: str,
-        access_token: Optional[str] = None,
-        prt_id: Optional[str] = None,
-    ):
-        self.domain = domain
-        self.access_token = access_token
-        self.prt_id = prt_id
-
-        self._client = httpx.Client(**get_httpx_client_kwargs())
-
-    def close(self):
-        """Explicitly close the HTTP client."""
-        if self._client:
-            self._client.close()
-            self._client = None
-
-    def __enter__(self):
-        """Enter the runtime context related to this object."""
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        """Exit the runtime context and close the HTTP client."""
-        self.close()
-
-    def update_token_data(self, token_data: TokenData):
-        self.access_token = token_data["access_token"]
-        self.prt_id = get_parsed_token_data(token_data).get("prt_id")
-
-    def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
-
-        url = f"https://{self.domain}.uipath.com/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
-        response = self._client.get(
-            url, headers={"Authorization": f"Bearer {self.access_token}"}
-        )
-        if response.status_code < 400:
-            result = response.json()
-            self._tenants_and_organizations = result
-            return result
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(
-                f"Failed to get tenants and organizations: {response.status_code} {response.text}"
-            )
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to get tenants")
-
-    def get_uipath_orchestrator_url(self) -> str:
-        if self._tenants_and_organizations is None:
-            self._tenants_and_organizations = self.get_tenants_and_organizations()
-        organization = self._tenants_and_organizations.get("organization")
-        if organization is None:
-            console.error("Organization not found.")
-            return ""
-        account_name = organization.get("name")
-        return f"https://{self.domain}.uipath.com/{account_name}/{self.selected_tenant}/orchestrator_"
-
-    def post_refresh_token_request(self, refresh_token: str) -> TokenData:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
-
-        url = f"https://{self.domain}.uipath.com/identity_/connect/token"
-        client_id = get_auth_config().get("client_id")
-
-        data = {
-            "grant_type": "refresh_token",
-            "refresh_token": refresh_token,
-            "client_id": client_id,
-        }
-
-        headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        response = self._client.post(url, data=data, headers=headers)
-        if response.status_code < 400:
-            return response.json()
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(f"Failed to refresh token: {response.status_code}")
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to refresh get token")
-
-    def ensure_valid_token(self):
-        """Ensure the access token is valid and refresh it if necessary.
-
-        This function should be called when running CLI commands to verify authentication.
-        It checks if an auth file exists and contains a valid non-expired token.
-        If the token is expired, it will attempt to refresh it.
-        If no auth file exists, it will raise an exception.
-
-        Raises:
-            Exception: If no auth file exists or token refresh fails
-        """
-        auth_data = get_auth_data()
-        claims = get_parsed_token_data(auth_data)
-        exp = claims.get("exp")
-
-        if exp is not None and float(exp) > time.time():
-            if not os.getenv("UIPATH_URL"):
-                tenants_and_organizations = self.get_tenants_and_organizations()
-                select_tenant(
-                    self.domain if self.domain else "alpha", tenants_and_organizations
-                )
-            return auth_data.get("access_token")
-
-        refresh_token = auth_data.get("refresh_token")
-        if refresh_token is None:
-            raise Exception("Refresh token not found")
-        token_data = self.post_refresh_token_request(refresh_token)
-        update_auth_file(token_data)
-
-        self.access_token = token_data["access_token"]
-        self.prt_id = claims.get("prt_id")
-
-        updated_env_contents = {
-            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-        }
-        if not os.getenv("UIPATH_URL"):
-            tenants_and_organizations = self.get_tenants_and_organizations()
-            select_tenant(
-                self.domain if self.domain else "alpha", tenants_and_organizations
-            )
-
-        update_env_file(updated_env_contents)
-
-    def post_auth(self, base_url: str) -> None:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
-
-        or_base_url = (
-            f"{base_url}/orchestrator_"
-            if base_url
-            else self.get_uipath_orchestrator_url()
-        )
-
-        url_try_enable_first_run = f"{or_base_url}/api/StudioWeb/TryEnableFirstRun"
-        url_acquire_license = f"{or_base_url}/api/StudioWeb/AcquireLicense"
-
-        try:
-            [try_enable_first_run_response, acquire_license_response] = [
-                self._client.post(
-                    url,
-                    headers={"Authorization": f"Bearer {self.access_token}"},
-                )
-                for url in [url_try_enable_first_run, url_acquire_license]
-            ]
-        except Exception:
-            pass
-
-    def has_initialized_auth(self):
-        try:
-            auth_data = get_auth_data()
-            if not auth_data or "access_token" not in auth_data:
-                return False
-            if not os.path.exists(".env"):
-                return False
-            if not os.getenv("UIPATH_ACCESS_TOKEN"):
-                return False
-
-            return True
-        except Exception:
-            return False
-
-
-def select_tenant(
-    domain: str, tenants_and_organizations: TenantsAndOrganizationInfoResponse
-):
-    tenant_names = [tenant["name"] for tenant in tenants_and_organizations["tenants"]]
-    console.display_options(tenant_names, "Select tenant:")
-    tenant_idx = (
-        0
-        if len(tenant_names) == 1
-        else console.prompt("Select tenant number", type=int)
-    )
-    tenant_name = tenant_names[tenant_idx]
-    account_name = tenants_and_organizations["organization"]["name"]
-    console.info(f"Selected tenant: {click.style(tenant_name, fg='cyan')}")
-
-    update_env_file(
-        {
-            "UIPATH_URL": f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}",
-            "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
-            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
-        }
-    )
-
-    return f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}"
diff --git a/src/uipath/_cli/_auth/auth_config.json b/src/uipath/_cli/_auth/auth_config.json
deleted file mode 100644
index d48525697..000000000
--- a/src/uipath/_cli/_auth/auth_config.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
-  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
-  "scope": "offline_access OrchestratorApiUserAccess IdentityServerApi ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
-  "port": 8104
-}
\ No newline at end of file
diff --git a/src/uipath/_cli/_auth/index.html b/src/uipath/_cli/_auth/index.html
deleted file mode 100644
index 5f773154d..000000000
--- a/src/uipath/_cli/_auth/index.html
+++ /dev/null
@@ -1,167 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>UiPath CLI Authentication</title>
-    <style>
-        button {
-            opacity: 0;
-        }
-    </style>
-</head>
-
-<body>
-    <h1>UiPath CLI Authentication</h1>
-    <button type="button" onclick="window.open('', '_self', ''); window.close();">Discard</button>
-    <pre id="log"></pre>
-    <script>
-        const baseUrl = '__PY_REPLACE_REDIRECT_URI__'.replace('/oidc/login', '');
-        const logs = [];
-        // Parse URL query parameters
-        function getQueryParams() {
-            const params = {};
-            const queryString = window.location.search;
-            const urlParams = new URLSearchParams(queryString);
-
-            for (const [key, value] of urlParams.entries()) {
-                params[key] = value;
-            }
-            return params;
-        }
-
-        // Exchange authorization code for tokens
-        async function exchangeCodeForToken(code, codeVerifier) {
-            try {
-                // Prepare form data for token request
-                const formData = new URLSearchParams();
-                formData.append('grant_type', 'authorization_code');
-                formData.append('code', code);
-                formData.append('redirect_uri', '__PY_REPLACE_REDIRECT_URI__');
-                formData.append('client_id', '__PY_REPLACE_CLIENT_ID__');
-                formData.append('code_verifier', codeVerifier);
-
-                // Make token request
-                const response = await fetch('https://__PY_REPLACE_DOMAIN__.uipath.com/identity_/connect/token', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded'
-                    },
-                    body: formData
-                });
-
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new Error(`Token request failed: ${response.status} ${response.statusText} - ${errorText}`);
-                }
-
-                const tokenData = await response.json();
-
-                return tokenData;
-            } catch (error) {
-                console.error('Error exchanging code for token:', error);
-                logs.push({
-                    timestamp: new Date().toISOString(),
-                    message: 'Error exchanging code for token:',
-                    error: error.message
-                });
-                throw error;
-            }
-        }
-
-        // Parse JWT token
-        function parseJwt(token) {
-            try {
-                const base64Url = token.split('.')[1];
-                const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
-                const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
-                    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
-                }).join(''));
-
-                return JSON.parse(jsonPayload);
-            } catch (e) {
-                console.error('Error parsing JWT:', e);
-                logs.push({
-                    timestamp: new Date().toISOString(),
-                    message: 'Error parsing JWT:',
-                    error: e.message
-                });
-                return null;
-            }
-        }
-
-        async function delay(ms) {
-            return new Promise(resolve => setTimeout(resolve, ms));
-        }
-
-        async function sendLogs(logs) {
-            await fetch(`${baseUrl}/log`, {
-                method: 'POST',
-                body: JSON.stringify(logs)
-            });
-        }
-
-        // Main function to handle the authentication flow
-        async function handleAuthentication() {
-            const params = getQueryParams();
-
-            logs.push({
-                timestamp: new Date().toISOString(),
-                message: 'Params:',
-                params: params
-            });
-
-            try {
-                // Check if we have an authorization code
-                if (params.code && params.state) {
-                    // Get code verifier from session storage
-                    const codeVerifier = "__PY_REPLACE_CODE_VERIFIER__";
-                    const state = "__PY_REPLACE_EXPECTED_STATE__";
-
-                    if (!codeVerifier) {
-                        throw new Error('Code verifier not found in session storage');
-                    }
-
-                    if (!params.state || params.state != state) {
-                        throw new Error('Invalid state parameter. Possible CSRF attack.');
-                    }
-
-                    // Exchange code for token
-                    const tokenData = await exchangeCodeForToken(params.code, codeVerifier);
-
-                    await sendLogs(logs);
-                    const setTokenResult = await fetch(`${baseUrl}/set_token`, {
-                        method: 'POST',
-                        body: JSON.stringify(tokenData)
-                    });
-                    // Show success message
-                    document.querySelector('h1').textContent = 'If this windows does not close automatically, you may close it now';
-                    setTimeout(() => {
-                        document.querySelector('button').click();
-                    }, 500);
-
-                    sessionStorage.removeItem('oidc_state');
-                    sessionStorage.removeItem('oidc_code_verifier');
-
-                    // Remove code and state from URL to prevent refresh issues
-                    window.history.replaceState({}, document.title, window.location.pathname);
-                }
-            } catch (error) {
-                console.error('Error during authentication:', error);
-                logs.push({
-                    timestamp: new Date().toISOString(),
-                    message: 'Error during authentication:',
-                    error: error.message
-                });
-                await sendLogs(logs);
-                document.querySelector('h1').textContent = 'Authentication failed. Please try again.';
-            }
-        }
-
-        // Start authentication process when page loads
-        handleAuthentication();
-    </script>
-</body>
-
-</html>
diff --git a/src/uipath/_cli/_runtime/_contracts.py b/src/uipath/_cli/_runtime/_contracts.py
deleted file mode 100644
index 24ee52af6..000000000
--- a/src/uipath/_cli/_runtime/_contracts.py
+++ /dev/null
@@ -1,452 +0,0 @@
-"""Core runtime contracts that define the interfaces between components."""
-
-import json
-import logging
-import os
-import sys
-import traceback
-from abc import ABC, abstractmethod
-from enum import Enum
-from functools import cached_property
-from typing import Any, Dict, Optional, Union
-
-from pydantic import BaseModel, Field
-
-from ._logging import LogsInterceptor
-
-logger = logging.getLogger(__name__)
-
-
-class UiPathResumeTriggerType(str, Enum):
-    """Constants representing different types of resume job triggers in the system."""
-
-    NONE = "None"
-    QUEUE_ITEM = "QueueItem"
-    JOB = "Job"
-    ACTION = "Task"
-    TIMER = "Timer"
-    INBOX = "Inbox"
-    API = "Api"
-
-
-class UiPathApiTrigger(BaseModel):
-    """API resume trigger request."""
-
-    inbox_id: Optional[str] = Field(default=None, alias="inboxId")
-    request: Any = None
-
-    model_config = {"populate_by_name": True}
-
-
-class UiPathResumeTrigger(BaseModel):
-    """Information needed to resume execution."""
-
-    trigger_type: UiPathResumeTriggerType = Field(
-        default=UiPathResumeTriggerType.API, alias="triggerType"
-    )
-    item_key: Optional[str] = Field(default=None, alias="itemKey")
-    api_resume: Optional[UiPathApiTrigger] = Field(default=None, alias="apiResume")
-    folder_path: Optional[str] = Field(default=None, alias="folderPath")
-    folder_key: Optional[str] = Field(default=None, alias="folderKey")
-    payload: Optional[Any] = Field(default=None, alias="interruptObject")
-
-    model_config = {"populate_by_name": True}
-
-
-class UiPathErrorCategory(str, Enum):
-    """Categories of runtime errors."""
-
-    DEPLOYMENT = "Deployment"  # Configuration, licensing, or permission issues
-    SYSTEM = "System"  # Unexpected internal errors or infrastructure issues
-    UNKNOWN = "Unknown"  # Default category when the error type is not specified
-    USER = "User"  # Business logic or domain-level errors
-
-
-class UiPathErrorContract(BaseModel):
-    """Standard error contract used across the runtime."""
-
-    code: str  # Human-readable code uniquely identifying this error type across the platform.
-    # Format: <Component>.<PascalCaseErrorCode> (e.g. LangGraph.InvaliGraphReference)
-    # Only use alphanumeric characters [A-Za-z0-9] and periods. No whitespace allowed.
-
-    title: str  # Short, human-readable summary of the problem that should remain consistent
-    # across occurrences.
-
-    detail: (
-        str  # Human-readable explanation specific to this occurrence of the problem.
-    )
-    # May include context, recommended actions, or technical details like call stacks
-    # for technical users.
-
-    category: UiPathErrorCategory = (
-        UiPathErrorCategory.UNKNOWN
-    )  # Classification of the error:
-    # - User: Business logic or domain-level errors
-    # - Deployment: Configuration, licensing, or permission issues
-    # - System: Unexpected internal errors or infrastructure issues
-
-    status: Optional[int] = (
-        None  # HTTP status code, if relevant (e.g., when forwarded from a web API)
-    )
-
-
-class UiPathRuntimeStatus(str, Enum):
-    """Standard status values for runtime execution."""
-
-    SUCCESSFUL = "successful"
-    FAULTED = "faulted"
-    SUSPENDED = "suspended"
-
-
-class UiPathRuntimeResult(BaseModel):
-    """Result of an execution with status and optional error information."""
-
-    output: Optional[Dict[str, Any]] = None
-    status: UiPathRuntimeStatus = UiPathRuntimeStatus.SUCCESSFUL
-    resume: Optional[UiPathResumeTrigger] = None
-    error: Optional[UiPathErrorContract] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary format for output."""
-        result = {
-            "output": self.output or {},
-            "status": self.status,
-        }
-
-        if self.resume:
-            result["resume"] = self.resume.model_dump(by_alias=True)
-
-        if self.error:
-            result["error"] = self.error.model_dump()
-
-        return result
-
-
-class UiPathTraceContext(BaseModel):
-    """Trace context information for tracing and debugging."""
-
-    trace_id: Optional[str] = None
-    parent_span_id: Optional[str] = None
-    root_span_id: Optional[str] = None
-    org_id: Optional[str] = None
-    tenant_id: Optional[str] = None
-    job_id: Optional[str] = None
-    folder_key: Optional[str] = None
-    process_key: Optional[str] = None
-    enabled: Union[bool, str] = False
-    reference_id: Optional[str] = None
-
-
-class UiPathRuntimeContext(BaseModel):
-    """Context information passed throughout the runtime execution."""
-
-    entrypoint: Optional[str] = None
-    input: Optional[str] = None
-    input_json: Optional[Any] = None
-    job_id: Optional[str] = None
-    trace_id: Optional[str] = None
-    trace_context: Optional[UiPathTraceContext] = None
-    tracing_enabled: Union[bool, str] = False
-    resume: bool = False
-    debug: bool = False
-    config_path: str = "uipath.json"
-    runtime_dir: Optional[str] = "__uipath"
-    logs_file: Optional[str] = "execution.log"
-    logs_min_level: Optional[str] = "INFO"
-    output_file: str = "output.json"
-    state_file: str = "state.db"
-    result: Optional[UiPathRuntimeResult] = None
-    execution_output_file: Optional[str] = None
-    input_file: Optional[str] = None
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    @classmethod
-    def from_config(cls, config_path=None):
-        """Load configuration from uipath.json file.
-
-        Args:
-            config_path: Path to the configuration file. If None, uses the default "uipath.json"
-
-        Returns:
-            An instance of the class with fields populated from the config file
-        """
-        import json
-        import os
-
-        path = config_path or "uipath.json"
-
-        config = {}
-
-        if os.path.exists(path):
-            with open(path, "r") as f:
-                config = json.load(f)
-
-        instance = cls()
-
-        if "runtime" in config:
-            runtime_config = config["runtime"]
-
-            mapping = {
-                "dir": "runtime_dir",
-                "outputFile": "output_file",
-                "stateFile": "state_file",
-                "logsFile": "logs_file",
-            }
-
-            for config_key, attr_name in mapping.items():
-                if config_key in runtime_config and hasattr(instance, attr_name):
-                    setattr(instance, attr_name, runtime_config[config_key])
-
-        return instance
-
-
-class UiPathRuntimeError(Exception):
-    """Base exception class for UiPath runtime errors with structured error information."""
-
-    def __init__(
-        self,
-        code: str,
-        title: str,
-        detail: str,
-        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
-        status: Optional[int] = None,
-        prefix: str = "Python",
-        include_traceback: bool = True,
-    ):
-        # Get the current traceback as a string
-        if include_traceback:
-            tb = traceback.format_exc()
-            if (
-                tb and tb.strip() != "NoneType: None"
-            ):  # Ensure there's an actual traceback
-                detail = f"{detail}\n\nTraceback:\n{tb}"
-
-        if status is None:
-            status = self._extract_http_status()
-
-        self.error_info = UiPathErrorContract(
-            code=f"{prefix}.{code}",
-            title=title,
-            detail=detail,
-            category=category,
-            status=status,
-        )
-        super().__init__(detail)
-
-    def _extract_http_status(self) -> Optional[int]:
-        """Extract HTTP status code from the exception chain if present."""
-        exc_info = sys.exc_info()
-        if not exc_info or len(exc_info) < 2 or exc_info[1] is None:
-            return None
-
-        exc: Optional[BaseException] = exc_info[1]  # Current exception being handled
-        while exc is not None:
-            if hasattr(exc, "status_code"):
-                return exc.status_code
-
-            if hasattr(exc, "response") and hasattr(exc.response, "status_code"):
-                return exc.response.status_code
-
-            # Move to the next exception in the chain
-            next_exc = getattr(exc, "__cause__", None) or getattr(
-                exc, "__context__", None
-            )
-
-            # Ensure next_exc is a BaseException or None
-            exc = (
-                next_exc
-                if isinstance(next_exc, BaseException) or next_exc is None
-                else None
-            )
-
-        return None
-
-    @property
-    def as_dict(self) -> Dict[str, Any]:
-        """Get the error information as a dictionary."""
-        return self.error_info.model_dump()
-
-
-class UiPathBaseRuntime(ABC):
-    """Base runtime class implementing the async context manager protocol.
-
-    This allows using the class with 'async with' statements.
-    """
-
-    def __init__(self, context: UiPathRuntimeContext):
-        self.context = context
-
-    @classmethod
-    def from_context(cls, context: UiPathRuntimeContext):
-        """Factory method to create a runtime instance from a context.
-
-        Args:
-            context: The runtime context with configuration
-
-        Returns:
-            An initialized Runtime instance
-        """
-        runtime = cls(context)
-        return runtime
-
-    async def __aenter__(self):
-        """Async enter method called when entering the 'async with' block.
-
-        Initializes and prepares the runtime environment.
-
-        Returns:
-            The runtime instance
-        """
-        # Read the input from file if provided
-        if self.context.input_file:
-            _, file_extension = os.path.splitext(self.context.input_file)
-            if file_extension != ".json":
-                raise UiPathRuntimeError(
-                    code="INVALID_INPUT_FILE_EXTENSION",
-                    title="Invalid Input File Extension",
-                    detail="The provided input file must be in JSON format.",
-                )
-            with open(self.context.input_file) as f:
-                self.context.input = f.read()
-
-        # Intercept all stdout/stderr/logs and write them to a file (runtime), stdout (debug)
-        self.logs_interceptor = LogsInterceptor(
-            min_level=self.context.logs_min_level,
-            dir=self.context.runtime_dir,
-            file=self.context.logs_file,
-            job_id=self.context.job_id,
-        )
-        self.logs_interceptor.setup()
-
-        logger.debug(f"Starting runtime with job id: {self.context.job_id}")
-
-        return self
-
-    @abstractmethod
-    async def execute(self) -> Optional[UiPathRuntimeResult]:
-        """Execute with the provided context.
-
-        Returns:
-            Dictionary with execution results
-
-        Raises:
-            RuntimeError: If execution fails
-        """
-        pass
-
-    @abstractmethod
-    async def validate(self):
-        """Validate runtime inputs."""
-        pass
-
-    @abstractmethod
-    async def cleanup(self):
-        """Cleaup runtime resources."""
-        pass
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async exit method called when exiting the 'async with' block.
-
-        Cleans up resources and handles any exceptions.
-
-        Always writes output file regardless of whether execution was successful,
-        suspended, or encountered an error.
-        """
-        try:
-            logger.debug(f"Shutting down runtime with job id: {self.context.job_id}")
-
-            if self.context.result is None:
-                execution_result = UiPathRuntimeResult()
-            else:
-                execution_result = self.context.result
-
-            if exc_type:
-                # Create error info from exception
-                if isinstance(exc_val, UiPathRuntimeError):
-                    error_info = exc_val.error_info
-                else:
-                    # Generic error
-                    error_info = UiPathErrorContract(
-                        code=f"ERROR_{exc_type.__name__}",
-                        title=f"Runtime error: {exc_type.__name__}",
-                        detail=str(exc_val),
-                        category=UiPathErrorCategory.UNKNOWN,
-                    )
-
-                execution_result.status = UiPathRuntimeStatus.FAULTED
-                execution_result.error = error_info
-
-            content = execution_result.to_dict()
-            logger.debug(content)
-
-            # Always write output file at runtime
-            if self.context.job_id:
-                with open(self.output_file_path, "w") as f:
-                    json.dump(content, f, indent=2, default=str)
-
-            # Write the execution output to file if requested
-            if self.context.execution_output_file:
-                with open(self.context.execution_output_file, "w") as f:
-                    json.dump(execution_result.output or {}, f, indent=2, default=str)
-
-            # Don't suppress exceptions
-            return False
-
-        except Exception as e:
-            logger.error(f"Error during runtime shutdown: {str(e)}")
-
-            # Create a fallback error result if we fail during cleanup
-            if not isinstance(e, UiPathRuntimeError):
-                error_info = UiPathErrorContract(
-                    code="RUNTIME_SHUTDOWN_ERROR",
-                    title="Runtime shutdown failed",
-                    detail=f"Error: {str(e)}",
-                    category=UiPathErrorCategory.SYSTEM,
-                )
-            else:
-                error_info = e.error_info
-
-            # Last-ditch effort to write error output
-            try:
-                error_result = UiPathRuntimeResult(
-                    status=UiPathRuntimeStatus.FAULTED, error=error_info
-                )
-                error_result_content = error_result.to_dict()
-                logger.debug(error_result_content)
-                if self.context.job_id:
-                    with open(self.output_file_path, "w") as f:
-                        json.dump(error_result_content, f, indent=2, default=str)
-            except Exception as write_error:
-                logger.error(f"Failed to write error output file: {str(write_error)}")
-                raise
-
-            # Re-raise as RuntimeError if it's not already a UiPathRuntimeError
-            if not isinstance(e, UiPathRuntimeError):
-                raise RuntimeError(
-                    error_info.code,
-                    error_info.title,
-                    error_info.detail,
-                    error_info.category,
-                ) from e
-            raise
-        finally:
-            # Restore original logging
-            if self.logs_interceptor:
-                self.logs_interceptor.teardown()
-
-            await self.cleanup()
-
-    @cached_property
-    def output_file_path(self) -> str:
-        if self.context.runtime_dir and self.context.output_file:
-            os.makedirs(self.context.runtime_dir, exist_ok=True)
-            return os.path.join(self.context.runtime_dir, self.context.output_file)
-        return os.path.join("__uipath", "output.json")
-
-    @cached_property
-    def state_file_path(self) -> str:
-        if self.context.runtime_dir and self.context.state_file:
-            os.makedirs(self.context.runtime_dir, exist_ok=True)
-            return os.path.join(self.context.runtime_dir, self.context.state_file)
-        return os.path.join("__uipath", "state.db")
diff --git a/src/uipath/_cli/_runtime/_escalation.py b/src/uipath/_cli/_runtime/_escalation.py
deleted file mode 100644
index 9c58e1e90..000000000
--- a/src/uipath/_cli/_runtime/_escalation.py
+++ /dev/null
@@ -1,235 +0,0 @@
-import json
-import logging
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-from uipath import UiPath
-from uipath.models.actions import Action
-
-logger = logging.getLogger(__name__)
-
-
-class Escalation:
-    """Class to handle default escalation."""
-
-    def __init__(self, config_path: Union[str, Path] = "uipath.json"):
-        """Initialize the escalation with a config file path.
-
-        Args:
-            config_path: Path to the configuration file (string or Path object)
-        """
-        self.config_path = Path(config_path)
-        self._config = None
-        self._enabled = False
-        self._load_config()
-
-    def _load_config(self) -> None:
-        """Load and validate the default escalation from the config file.
-
-        If the 'defaultEscalation' section exists, validates required fields.
-        Raises error if required fields are missing.
-        """
-        try:
-            config_data = json.loads(self.config_path.read_text(encoding="utf-8"))
-            escalation_config = config_data.get("defaultEscalation")
-
-            if escalation_config:
-                required_fields = {"request", "title"}
-                missing_fields = [
-                    field for field in required_fields if field not in escalation_config
-                ]
-
-                if not any(key in escalation_config for key in ("appName", "appKey")):
-                    missing_fields.append("appName or appKey")
-
-                if missing_fields:
-                    raise ValueError(
-                        f"Missing required fields in configuration: {', '.join(missing_fields)}"
-                    )
-
-                self._config = escalation_config
-                self._enabled = True
-                logger.debug("Escalation configuration loaded successfully")
-            else:
-                self._enabled = False
-
-        except FileNotFoundError:
-            logger.debug(f"Config file not found: {self.config_path}")
-            self._enabled = False
-
-        except json.JSONDecodeError:
-            logger.warning(
-                f"Failed to parse config file {self.config_path}: Invalid JSON"
-            )
-            self._enabled = False
-
-        except ValueError as e:
-            logger.error(str(e))
-            raise
-
-        except Exception as e:
-            logger.error(f"Unexpected error loading config {self.config_path}: {e}")
-            self._enabled = False
-
-    @property
-    def enabled(self) -> bool:
-        """Check if escalation is enabled.
-
-        Returns:
-            True if configuration is valid and loaded
-        """
-        return self._enabled
-
-    def prepare_data(self, value: Any) -> Dict[str, Any]:
-        """Prepare action data by replacing $VALUE placeholders with the provided value.
-
-        Args:
-            value: The value to substitute into the template
-
-        Returns:
-            Prepared data dictionary with substitutions applied
-        """
-        if not self.enabled or not self._config:
-            return {}
-
-        template = self._config.get("request", {})
-
-        if isinstance(value, str):
-            try:
-                value_obj = json.loads(value)
-            except json.JSONDecodeError:
-                value_obj = value
-        else:
-            value_obj = value
-
-        return self._substitute_values(template, value_obj)
-
-    def _substitute_values(
-        self, template: Dict[str, Any], value: Any
-    ) -> Dict[str, Any]:
-        """Replace template placeholders with actual values.
-
-        Args:
-            template: Template dictionary containing placeholders
-            value: Values to substitute into the template
-
-        Returns:
-            Template with values substituted
-        """
-
-        def process_value(template_value):
-            if isinstance(template_value, dict):
-                return {k: process_value(v) for k, v in template_value.items()}
-            elif isinstance(template_value, list):
-                return [process_value(item) for item in template_value]
-            elif isinstance(template_value, str):
-                if template_value == "$VALUE":
-                    return value
-                elif template_value.startswith("$VALUE."):
-                    return self._resolve_value_path(template_value, value)
-
-            return template_value
-
-        return process_value(template)
-
-    def _resolve_value_path(self, path_expr: str, value: Any) -> Any:
-        """Resolve a dot-notation path expression against a value.
-
-        Args:
-            path_expr: Path expression (e.g. "$VALUE.user.name")
-            value: Value object to extract data from
-
-        Returns:
-            Extracted value or None if path doesn't exist
-        """
-        path_parts = path_expr.replace("$VALUE.", "").split(".")
-        current = value
-
-        for part in path_parts:
-            if not isinstance(current, dict) or part not in current:
-                return None
-            current = current.get(part)
-
-        return current
-
-    def extract_response_value(self, action_data: Dict[str, Any]) -> Any:
-        if not self._config:
-            return ""
-
-        response_template = self._config.get("response")
-        if not response_template:
-            return ""
-
-        for key, template_value in response_template.items():
-            if key in action_data:
-                extracted_value = None
-
-                if template_value == "$VALUE":
-                    extracted_value = action_data[key]
-                elif isinstance(template_value, str) and template_value.startswith(
-                    "$VALUE."
-                ):
-                    path_parts = template_value.replace("$VALUE.", "").split(".")
-                    current = action_data[key]
-
-                    valid_path = True
-                    for part in path_parts:
-                        if not isinstance(current, dict) or part not in current:
-                            valid_path = False
-                            break
-                        current = current.get(part)
-
-                    if valid_path:
-                        extracted_value = current
-
-                if extracted_value is not None:
-                    if isinstance(extracted_value, str):
-                        if extracted_value.lower() == "true":
-                            return True
-                        elif extracted_value.lower() == "false":
-                            return False
-
-                        try:
-                            if "." in extracted_value:
-                                return float(extracted_value)
-                            else:
-                                return int(extracted_value)
-                        except ValueError:
-                            pass
-
-                    return extracted_value
-
-        return action_data
-
-    async def create(self, value: Any) -> Optional[Action]:
-        """Create an escalation Action with the prepared data.
-
-        Args:
-            value: The dynamic value to be substituted into the template
-
-        Returns:
-            The created Action object or None if creation fails
-        """
-        if not self.enabled or not self._config:
-            return None
-
-        action_data = self.prepare_data(value)
-
-        if not action_data:
-            logger.warning("Action creation skipped: empty data after preparation")
-            return None
-
-        try:
-            uipath = UiPath()
-            action = uipath.actions.create(
-                title=self._config.get("title", "Default escalation"),
-                app_name=self._config.get("appName"),
-                app_key=self._config.get("appKey"),
-                app_version=self._config.get("appVersion", 1),
-                data=action_data,
-            )
-            logger.info(f"Action created successfully: {action.key}")
-            return action
-        except Exception as e:
-            logger.error(f"Error creating action: {e}")
-            return None
diff --git a/src/uipath/_cli/_runtime/_hitl.py b/src/uipath/_cli/_runtime/_hitl.py
deleted file mode 100644
index f5bfb120d..000000000
--- a/src/uipath/_cli/_runtime/_hitl.py
+++ /dev/null
@@ -1,257 +0,0 @@
-import json
-import uuid
-from dataclasses import dataclass
-from functools import cached_property
-from typing import Any, Optional
-
-from uipath import UiPath
-from uipath.models import CreateAction, InvokeProcess, WaitAction, WaitJob
-
-from .._runtime._contracts import (
-    UiPathApiTrigger,
-    UiPathErrorCategory,
-    UiPathResumeTrigger,
-    UiPathResumeTriggerType,
-    UiPathRuntimeError,
-    UiPathRuntimeStatus,
-)
-from .._utils._common import serialize_object
-from ._escalation import Escalation
-
-
-def _try_convert_to_json_format(value: str | None) -> str | None:
-    """Attempts to parse a string as JSON and returns the parsed object or original string.
-
-    Args:
-        value: The string value to attempt JSON parsing on.
-
-    Returns:
-        The parsed JSON object if successful, otherwise the original string value.
-    """
-    try:
-        if not value:
-            return None
-        return json.loads(value)
-    except json.decoder.JSONDecodeError:
-        return value
-
-
-class HitlReader:
-    """Handles reading and retrieving Human-In-The-Loop (HITL) data from UiPath services."""
-
-    @classmethod
-    async def read(cls, resume_trigger: UiPathResumeTrigger) -> Optional[str]:
-        """Reads data from a UiPath resume trigger based on its type.
-
-        This method handles different types of resume triggers (ACTION, JOB, API) and retrieves
-        the appropriate data from UiPath services. For actions, it retrieves action data with
-        optional escalation processing. For jobs, it retrieves job output and validates success.
-        For API triggers, it retrieves the API payload.
-
-        Args:
-            resume_trigger: The UiPath resume trigger containing the trigger type and metadata.
-
-        Returns:
-            The retrieved data as a string, or None if no data is available.
-
-        Raises:
-            UiPathRuntimeError: If the job failed, API connection failed, trigger type is unknown,
-                or HITL feedback retrieval failed.
-        """
-        uipath = UiPath()
-        default_escalation = Escalation()
-        match resume_trigger.trigger_type:
-            case UiPathResumeTriggerType.ACTION:
-                if resume_trigger.item_key:
-                    action = await uipath.actions.retrieve_async(
-                        resume_trigger.item_key,
-                        app_folder_key=resume_trigger.folder_key,
-                        app_folder_path=resume_trigger.folder_path,
-                    )
-
-                    if default_escalation.enabled:
-                        return default_escalation.extract_response_value(action.data)
-
-                    return action.data
-
-            case UiPathResumeTriggerType.JOB:
-                if resume_trigger.item_key:
-                    job = await uipath.jobs.retrieve_async(
-                        resume_trigger.item_key,
-                        folder_key=resume_trigger.folder_key,
-                        folder_path=resume_trigger.folder_path,
-                    )
-                    if (
-                        job.state
-                        and not job.state.lower()
-                        == UiPathRuntimeStatus.SUCCESSFUL.value.lower()
-                    ):
-                        raise UiPathRuntimeError(
-                            "INVOKED_PROCESS_FAILURE",
-                            "Invoked process did not finish successfully.",
-                            _try_convert_to_json_format(str(job.job_error or job.info))
-                            or "Job error unavailable.",
-                        )
-                    return _try_convert_to_json_format(job.output_arguments)
-
-            case UiPathResumeTriggerType.API:
-                if resume_trigger.api_resume and resume_trigger.api_resume.inbox_id:
-                    try:
-                        return await uipath.jobs.retrieve_api_payload_async(
-                            resume_trigger.api_resume.inbox_id
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "API_CONNECTION_ERROR",
-                            "Failed to get trigger payload",
-                            f"Error fetching API trigger payload for inbox {resume_trigger.api_resume.inbox_id}: {str(e)}",
-                            UiPathErrorCategory.SYSTEM,
-                        ) from e
-            case _:
-                raise UiPathRuntimeError(
-                    "UNKNOWN_TRIGGER_TYPE",
-                    "Unexpected trigger type received",
-                    f"Trigger type :{type(resume_trigger.trigger_type)} is invalid",
-                    UiPathErrorCategory.USER,
-                )
-
-        raise UiPathRuntimeError(
-            "HITL_FEEDBACK_FAILURE",
-            "Failed to receive payload from HITL action",
-            detail="Failed to receive payload from HITL action",
-            category=UiPathErrorCategory.SYSTEM,
-        )
-
-
-@dataclass
-class HitlProcessor:
-    """Processes events in a Human-(Robot/Agent)-In-The-Loop scenario.
-
-    This class handles the creation and processing of HITL resume triggers for different
-    types of UiPath operations including actions, jobs, and API calls. It determines the
-    appropriate trigger type based on the input value and creates the corresponding
-    resume trigger with proper configuration.
-
-    Attributes:
-        value: The input value to be processed, can be various UiPath model types or strings.
-    """
-
-    value: Any
-
-    @cached_property
-    def type(self) -> UiPathResumeTriggerType:
-        """Determines the resume trigger type based on the input value.
-
-        Analyzes the input value type and returns the corresponding UiPath resume trigger type.
-        Actions (CreateAction, WaitAction) map to ACTION type, jobs (InvokeProcess, WaitJob)
-        map to JOB type, and all other values default to API type.
-
-        Returns:
-            The appropriate UiPathResumeTriggerType based on the input value type.
-        """
-        if isinstance(self.value, CreateAction) or isinstance(self.value, WaitAction):
-            return UiPathResumeTriggerType.ACTION
-        if isinstance(self.value, InvokeProcess) or isinstance(self.value, WaitJob):
-            return UiPathResumeTriggerType.JOB
-        # default to API trigger
-        return UiPathResumeTriggerType.API
-
-    async def create_resume_trigger(self) -> UiPathResumeTrigger:
-        """Creates a UiPath resume trigger based on the input value and its type.
-
-        This method processes the input value and creates an appropriate resume trigger
-        for HITL scenarios. It handles different input types:
-        - Actions: Creates or references UiPath actions with folder information
-        - Jobs: Invokes processes or references existing jobs with folder information
-        - API: Creates API triggers with generated inbox IDs
-        - String with escalation: Creates escalated actions
-
-        Returns:
-            A configured UiPathResumeTrigger ready for HITL processing.
-
-        Raises:
-            UiPathRuntimeError: If action/job creation fails, escalation fails, or an
-                unknown model type is encountered.
-            Exception: If any underlying UiPath service calls fail.
-        """
-        uipath = UiPath()
-        default_escalation = Escalation()
-
-        try:
-            hitl_input = self.value
-            resume_trigger = UiPathResumeTrigger(
-                trigger_type=self.type, payload=serialize_object(hitl_input)
-            )
-
-            # check for default escalation config
-            if default_escalation.enabled and isinstance(hitl_input, str):
-                resume_trigger.trigger_type = UiPathResumeTriggerType.ACTION
-                action = await default_escalation.create(hitl_input)
-                if not action:
-                    raise Exception("Failed to create default escalation")
-                resume_trigger.item_key = action.key
-                return resume_trigger
-
-            match self.type:
-                case UiPathResumeTriggerType.ACTION:
-                    resume_trigger.folder_path = hitl_input.app_folder_path
-                    resume_trigger.folder_key = hitl_input.app_folder_key
-                    if isinstance(hitl_input, WaitAction):
-                        resume_trigger.item_key = hitl_input.action.key
-                    elif isinstance(hitl_input, CreateAction):
-                        action = await uipath.actions.create_async(
-                            title=hitl_input.title,
-                            app_name=hitl_input.app_name if hitl_input.app_name else "",
-                            app_folder_path=hitl_input.app_folder_path
-                            if hitl_input.app_folder_path
-                            else "",
-                            app_folder_key=hitl_input.app_folder_key
-                            if hitl_input.app_folder_key
-                            else "",
-                            app_key=hitl_input.app_key if hitl_input.app_key else "",
-                            app_version=hitl_input.app_version
-                            if hitl_input.app_version
-                            else 1,
-                            assignee=hitl_input.assignee if hitl_input.assignee else "",
-                            data=hitl_input.data,
-                        )
-                        if not action:
-                            raise Exception("Failed to create action")
-                        resume_trigger.item_key = action.key
-
-                case UiPathResumeTriggerType.JOB:
-                    resume_trigger.folder_path = hitl_input.process_folder_path
-                    resume_trigger.folder_key = hitl_input.process_folder_key
-                    if isinstance(hitl_input, WaitJob):
-                        resume_trigger.item_key = hitl_input.job.key
-                    elif isinstance(hitl_input, InvokeProcess):
-                        job = await uipath.processes.invoke_async(
-                            name=hitl_input.name,
-                            input_arguments=hitl_input.input_arguments,
-                            folder_path=hitl_input.process_folder_path,
-                            folder_key=hitl_input.process_folder_key,
-                        )
-                        if not job:
-                            raise Exception("Failed to invoke process")
-                        resume_trigger.item_key = job.key
-
-                case UiPathResumeTriggerType.API:
-                    resume_trigger.api_resume = UiPathApiTrigger(
-                        inbox_id=str(uuid.uuid4()), request=serialize_object(hitl_input)
-                    )
-                case _:
-                    raise UiPathRuntimeError(
-                        "UNKNOWN_HITL_MODEL",
-                        "Unexpected model received",
-                        f"{type(hitl_input)} is not a valid Human(Robot/Agent)-In-The-Loop model",
-                        UiPathErrorCategory.USER,
-                    )
-        except Exception as e:
-            raise UiPathRuntimeError(
-                "HITL_ACTION_CREATION_FAILED",
-                "Failed to create HITL action",
-                f"{str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
-
-        return resume_trigger
diff --git a/src/uipath/_cli/_runtime/_logging.py b/src/uipath/_cli/_runtime/_logging.py
deleted file mode 100644
index b6c2b4ea5..000000000
--- a/src/uipath/_cli/_runtime/_logging.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import logging
-import os
-import sys
-from typing import Optional, TextIO, Union, cast
-
-
-class PersistentLogsHandler(logging.FileHandler):
-    """A simple log handler that always writes to a single file without rotation."""
-
-    def __init__(self, file: str):
-        """Initialize the handler to write logs to a single file, appending always.
-
-        Args:
-            file (str): The file where logs should be stored.
-        """
-        # Open file in append mode ('a'), so logs are not overwritten
-        super().__init__(file, mode="a", encoding="utf8")
-
-        self.formatter = logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s")
-        self.setFormatter(self.formatter)
-
-
-class LogsInterceptor:
-    """Intercepts all logging and stdout/stderr, routing to either persistent log files or stdout based on whether it's running as a job or not."""
-
-    def __init__(
-        self,
-        min_level: Optional[str] = "INFO",
-        dir: Optional[str] = "__uipath",
-        file: Optional[str] = "execution.log",
-        job_id: Optional[str] = None,
-    ):
-        """Initialize the log interceptor.
-
-        Args:
-            min_level: Minimum logging level to capture.
-            dir (str): The directory where logs should be stored.
-            file (str): The log file name.
-            job_id (str, optional): If provided, logs go to file; otherwise, to stdout.
-        """
-        min_level = min_level or "INFO"
-        self.job_id = job_id
-
-        # Convert to numeric level for consistent comparison
-        self.numeric_min_level = getattr(logging, min_level.upper(), logging.INFO)
-
-        # Store the original disable level
-        self.original_disable_level = logging.root.manager.disable
-
-        self.root_logger = logging.getLogger()
-        self.original_level = self.root_logger.level
-        self.original_handlers = list(self.root_logger.handlers)
-
-        # Store system stdout/stderr
-        self.original_stdout = cast(TextIO, sys.stdout)
-        self.original_stderr = cast(TextIO, sys.stderr)
-
-        self.log_handler: Union[PersistentLogsHandler, logging.StreamHandler[TextIO]]
-
-        # Create either file handler (runtime) or stdout handler (debug)
-        if self.job_id:
-            # Ensure directory exists for file logging
-            dir = dir or "__uipath"
-            file = file or "execution.log"
-            os.makedirs(dir, exist_ok=True)
-            log_file = os.path.join(dir, file)
-            self.log_handler = PersistentLogsHandler(file=log_file)
-        else:
-            # Use stdout handler when not running as a job
-            self.log_handler = logging.StreamHandler(sys.stdout)
-            formatter = logging.Formatter("%(message)s")
-            self.log_handler.setFormatter(formatter)
-
-        self.log_handler.setLevel(self.numeric_min_level)
-        self.logger = logging.getLogger("runtime")
-        self.patched_loggers: set[str] = set()
-
-    def _clean_all_handlers(self, logger: logging.Logger) -> None:
-        """Remove ALL handlers from a logger except ours."""
-        handlers_to_remove = list(logger.handlers)
-        for handler in handlers_to_remove:
-            logger.removeHandler(handler)
-
-        # Now add our handler
-        logger.addHandler(self.log_handler)
-
-    def setup(self) -> None:
-        """Configure logging to use our persistent handler."""
-        # Use global disable to prevent all logging below our minimum level
-        if self.numeric_min_level > logging.NOTSET:
-            logging.disable(self.numeric_min_level - 1)
-
-        # Set root logger level
-        self.root_logger.setLevel(self.numeric_min_level)
-
-        # Remove ALL handlers from root logger and add only ours
-        self._clean_all_handlers(self.root_logger)
-
-        # Set up propagation for all existing loggers
-        for logger_name in logging.root.manager.loggerDict:
-            logger = logging.getLogger(logger_name)
-            logger.propagate = False  # Prevent double-logging
-            self._clean_all_handlers(logger)
-            self.patched_loggers.add(logger_name)
-
-        # Set up stdout/stderr redirection
-        self._redirect_stdout_stderr()
-
-    def _redirect_stdout_stderr(self) -> None:
-        """Redirect stdout and stderr to the logging system."""
-
-        class LoggerWriter:
-            def __init__(
-                self,
-                logger: logging.Logger,
-                level: int,
-                min_level: int,
-                sys_file: TextIO,
-            ):
-                self.logger = logger
-                self.level = level
-                self.min_level = min_level
-                self.buffer = ""
-                self.sys_file = sys_file  # Store reference to system stdout/stderr
-
-            def write(self, message: str) -> None:
-                self.buffer += message
-                while "\n" in self.buffer:
-                    line, self.buffer = self.buffer.split("\n", 1)
-                    # Only log if the message is not empty and the level is sufficient
-                    if line and self.level >= self.min_level:
-                        # Use _log to avoid potential recursive logging if logging methods are overridden
-                        self.logger._log(self.level, line, ())
-
-            def flush(self) -> None:
-                # Log any remaining content in the buffer on flush
-                if self.buffer and self.level >= self.min_level:
-                    self.logger._log(self.level, self.buffer, ())
-                self.buffer = ""
-
-            def fileno(self) -> int:
-                # Return the file descriptor of the original system stdout/stderr
-                try:
-                    return self.sys_file.fileno()
-                except Exception:
-                    return -1
-
-            def isatty(self) -> bool:
-                return hasattr(self.sys_file, "isatty") and self.sys_file.isatty()
-
-            def writable(self) -> bool:
-                return True
-
-        # Set up stdout and stderr loggers with propagate=False
-        stdout_logger = logging.getLogger("stdout")
-        stdout_logger.propagate = False
-        self._clean_all_handlers(stdout_logger)
-
-        stderr_logger = logging.getLogger("stderr")
-        stderr_logger.propagate = False
-        self._clean_all_handlers(stderr_logger)
-
-        # Use the min_level in the LoggerWriter to filter messages
-        sys.stdout = LoggerWriter(
-            stdout_logger, logging.INFO, self.numeric_min_level, self.original_stdout
-        )
-        sys.stderr = LoggerWriter(
-            stderr_logger, logging.ERROR, self.numeric_min_level, self.original_stderr
-        )
-
-    def teardown(self) -> None:
-        """Restore original logging configuration."""
-        # Restore the original disable level
-        logging.disable(self.original_disable_level)
-
-        if self.log_handler in self.root_logger.handlers:
-            self.root_logger.removeHandler(self.log_handler)
-
-        for logger_name in self.patched_loggers:
-            logger = logging.getLogger(logger_name)
-            if self.log_handler in logger.handlers:
-                logger.removeHandler(self.log_handler)
-
-        self.root_logger.setLevel(self.original_level)
-        for handler in self.original_handlers:
-            if handler not in self.root_logger.handlers:
-                self.root_logger.addHandler(handler)
-
-        self.log_handler.close()
-
-        if self.original_stdout and self.original_stderr:
-            sys.stdout = self.original_stdout
-            sys.stderr = self.original_stderr
-
-    def __enter__(self):
-        self.setup()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            self.logger.error(
-                f"Exception occurred: {exc_val}", exc_info=(exc_type, exc_val, exc_tb)
-            )
-        self.teardown()
-        return False
diff --git a/src/uipath/_cli/_runtime/_runtime.py b/src/uipath/_cli/_runtime/_runtime.py
deleted file mode 100644
index 10cb652bb..000000000
--- a/src/uipath/_cli/_runtime/_runtime.py
+++ /dev/null
@@ -1,288 +0,0 @@
-"""Python script runtime implementation for executing and managing python scripts."""
-
-import importlib.util
-import inspect
-import json
-import logging
-import os
-from dataclasses import asdict, is_dataclass
-from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
-
-from opentelemetry import trace
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-
-from uipath.tracing import LlmOpsHttpExporter
-
-from ._contracts import (
-    UiPathBaseRuntime,
-    UiPathErrorCategory,
-    UiPathRuntimeError,
-    UiPathRuntimeResult,
-    UiPathRuntimeStatus,
-)
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar("T")
-
-
-class UiPathRuntime(UiPathBaseRuntime):
-    """Runtime for executing Python scripts."""
-
-    async def execute(self) -> Optional[UiPathRuntimeResult]:
-        """Execute the Python script with the provided input and configuration.
-
-        Returns:
-            Dictionary with execution results
-
-        Raises:
-            UiPathRuntimeError: If execution fails
-        """
-        await self.validate()
-
-        try:
-            trace.set_tracer_provider(TracerProvider())
-            trace.get_tracer_provider().add_span_processor(  # type: ignore
-                BatchSpanProcessor(LlmOpsHttpExporter())
-            )
-
-            if self.context.entrypoint is None:
-                return None
-
-            script_result = await self._execute_python_script(
-                self.context.entrypoint, self.context.input_json
-            )
-
-            if self.context.job_id is None:
-                logger.info(script_result)
-
-            self.context.result = UiPathRuntimeResult(
-                output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
-            )
-
-            return self.context.result
-
-        except Exception as e:
-            if isinstance(e, UiPathRuntimeError):
-                raise
-
-            raise UiPathRuntimeError(
-                "EXECUTION_ERROR",
-                "Python script execution failed",
-                f"Error: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
-        finally:
-            trace.get_tracer_provider().shutdown()  # type: ignore
-
-    async def validate(self) -> None:
-        """Validate runtime inputs."""
-        if not self.context.entrypoint:
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_MISSING",
-                "No entrypoint specified",
-                "Please provide a path to a Python script.",
-                UiPathErrorCategory.USER,
-            )
-
-        if not os.path.exists(self.context.entrypoint):
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_NOT_FOUND",
-                "Script not found",
-                f"Script not found at path {self.context.entrypoint}.",
-                UiPathErrorCategory.USER,
-            )
-
-        try:
-            if self.context.input:
-                self.context.input_json = json.loads(self.context.input)
-            else:
-                self.context.input_json = {}
-        except json.JSONDecodeError as e:
-            raise UiPathRuntimeError(
-                "INPUT_INVALID_JSON",
-                "Invalid JSON input",
-                f"The input data is not valid JSON: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-    async def cleanup(self) -> None:
-        """Cleanup runtime resources."""
-        pass
-
-    async def _execute_python_script(self, script_path: str, input_data: Any) -> Any:
-        """Execute the Python script with the given input."""
-        spec = importlib.util.spec_from_file_location("dynamic_module", script_path)
-        if not spec or not spec.loader:
-            raise UiPathRuntimeError(
-                "IMPORT_ERROR",
-                "Module import failed",
-                f"Could not load spec for {script_path}",
-                UiPathErrorCategory.USER,
-            )
-
-        module = importlib.util.module_from_spec(spec)
-        try:
-            spec.loader.exec_module(module)
-        except Exception as e:
-            raise UiPathRuntimeError(
-                "MODULE_EXECUTION_ERROR",
-                "Module execution failed",
-                f"Error executing module: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-        for func_name in ["main", "run", "execute"]:
-            if hasattr(module, func_name):
-                main_func = getattr(module, func_name)
-                sig = inspect.signature(main_func)
-                params = list(sig.parameters.values())
-
-                # Check if the function is asynchronous
-                is_async = inspect.iscoroutinefunction(main_func)
-
-                # Case 1: No parameters
-                if not params:
-                    try:
-                        result = await main_func() if is_async else main_func()
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                input_param = params[0]
-                input_type = input_param.annotation
-
-                # Case 2: Class or dataclass parameter
-                if input_type != inspect.Parameter.empty and (
-                    is_dataclass(input_type) or hasattr(input_type, "__annotations__")
-                ):
-                    try:
-                        valid_type = cast(Type[Any], input_type)
-                        typed_input = self._convert_to_class(input_data, valid_type)
-                        result = (
-                            await main_func(typed_input)
-                            if is_async
-                            else main_func(typed_input)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with typed input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                # Case 3: Dict parameter
-                else:
-                    try:
-                        result = (
-                            await main_func(input_data)
-                            if is_async
-                            else main_func(input_data)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with dictionary input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-        raise UiPathRuntimeError(
-            "ENTRYPOINT_FUNCTION_MISSING",
-            "No entry function found",
-            f"No main function (main, run, or execute) found in {script_path}",
-            UiPathErrorCategory.USER,
-        )
-
-    def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
-        """Convert a dictionary to either a dataclass or regular class instance."""
-        if is_dataclass(cls):
-            field_types = get_type_hints(cls)
-            converted_data = {}
-
-            for field_name, field_type in field_types.items():
-                if field_name not in data:
-                    continue
-
-                value = data[field_name]
-                if (
-                    is_dataclass(field_type) or hasattr(field_type, "__annotations__")
-                ) and isinstance(value, dict):
-                    typed_field = cast(Type[Any], field_type)
-                    value = self._convert_to_class(value, typed_field)
-                converted_data[field_name] = value
-
-            return cast(T, cls(**converted_data))
-        else:
-            sig = inspect.signature(cls.__init__)
-            params = sig.parameters
-
-            init_args = {}
-
-            for param_name, param in params.items():
-                if param_name == "self":
-                    continue
-
-                if param_name in data:
-                    value = data[param_name]
-                    param_type = (
-                        param.annotation
-                        if param.annotation != inspect.Parameter.empty
-                        else Any
-                    )
-
-                    if (
-                        is_dataclass(param_type)
-                        or hasattr(param_type, "__annotations__")
-                    ) and isinstance(value, dict):
-                        typed_param = cast(Type[Any], param_type)
-                        value = self._convert_to_class(value, typed_param)
-
-                    init_args[param_name] = value
-                elif param.default != inspect.Parameter.empty:
-                    init_args[param_name] = param.default
-
-            return cls(**init_args)
-
-    def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
-        """Convert a class instance (dataclass or regular) to a dictionary."""
-        if obj is None:
-            return {}
-
-        if is_dataclass(obj):
-            # Make sure obj is an instance, not a class
-            if isinstance(obj, type):
-                return {}
-            return asdict(obj)
-        elif hasattr(obj, "__dict__"):
-            result = {}
-            for key, value in obj.__dict__.items():
-                # Skip private attributes
-                if not key.startswith("_"):
-                    if hasattr(value, "__dict__") or is_dataclass(value):
-                        result[key] = self._convert_from_class(value)
-                    else:
-                        result[key] = value
-            return result
-        return {} if obj is None else {str(type(obj).__name__): str(obj)}  # Fallback
diff --git a/src/uipath/_cli/_utils/_common.py b/src/uipath/_cli/_utils/_common.py
deleted file mode 100644
index d423c2001..000000000
--- a/src/uipath/_cli/_utils/_common.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import os
-from typing import Optional
-
-import click
-
-from ..spinner import Spinner
-
-
-def environment_options(function):
-    function = click.option(
-        "--alpha",
-        "domain",
-        flag_value="alpha",
-        help="Use alpha environment",
-    )(function)
-    function = click.option(
-        "--staging",
-        "domain",
-        flag_value="staging",
-        help="Use staging environment",
-    )(function)
-    function = click.option(
-        "--cloud",
-        "domain",
-        flag_value="cloud",
-        default=True,
-        help="Use production environment",
-    )(function)
-    return function
-
-
-def get_env_vars(spinner: Optional[Spinner] = None) -> list[str | None]:
-    base_url = os.environ.get("UIPATH_URL")
-    token = os.environ.get("UIPATH_ACCESS_TOKEN")
-
-    if not all([base_url, token]):
-        if spinner:
-            spinner.stop()
-        click.echo(
-            "❌ Missing required environment variables. Please check your .env file contains:"
-        )
-        click.echo("UIPATH_URL, UIPATH_ACCESS_TOKEN")
-        click.get_current_context().exit(1)
-
-    return [base_url, token]
-
-
-def serialize_object(obj):
-    """Recursively serializes an object and all its nested components."""
-    # Handle Pydantic models
-    if hasattr(obj, "model_dump"):
-        return serialize_object(obj.model_dump(by_alias=True))
-    elif hasattr(obj, "dict"):
-        return serialize_object(obj.dict())
-    elif hasattr(obj, "to_dict"):
-        return serialize_object(obj.to_dict())
-    # Handle dictionaries
-    elif isinstance(obj, dict):
-        return {k: serialize_object(v) for k, v in obj.items()}
-    # Handle lists
-    elif isinstance(obj, list):
-        return [serialize_object(item) for item in obj]
-    # Handle other iterable objects (convert to dict first)
-    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
-        try:
-            return serialize_object(dict(obj))
-        except (TypeError, ValueError):
-            return obj
-    # Return primitive types as is
-    else:
-        return obj
diff --git a/src/uipath/_cli/_utils/_folders.py b/src/uipath/_cli/_utils/_folders.py
deleted file mode 100644
index 49c9979a2..000000000
--- a/src/uipath/_cli/_utils/_folders.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from typing import Optional, Tuple
-
-import httpx
-
-from ..._utils._ssl_context import get_httpx_client_kwargs
-from ._console import ConsoleLogger
-
-console = ConsoleLogger()
-
-
-def get_personal_workspace_info(
-    base_url: str, token: str
-) -> Tuple[Optional[str], Optional[str]]:
-    user_url = f"{base_url}/orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended?$expand=PersonalWorkspace"
-
-    with httpx.Client(**get_httpx_client_kwargs()) as client:
-        user_response = client.get(
-            user_url, headers={"Authorization": f"Bearer {token}"}
-        )
-
-        if user_response.status_code != 200:
-            console.error(
-                "Error: Failed to fetch user info. Please try reauthenticating."
-            )
-            return None, None
-
-        user_data = user_response.json()
-        feed_id = user_data.get("PersonalWorskpaceFeedId")
-        personal_workspace = user_data.get("PersonalWorkspace")
-
-        if not personal_workspace or not feed_id or "Id" not in personal_workspace:
-            return None, None
-
-        folder_id = personal_workspace.get("Id")
-        return feed_id, folder_id
diff --git a/src/uipath/_cli/_utils/_input_args.py b/src/uipath/_cli/_utils/_input_args.py
deleted file mode 100644
index 7cc638347..000000000
--- a/src/uipath/_cli/_utils/_input_args.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import importlib.util
-import inspect
-import sys
-from dataclasses import fields, is_dataclass
-from types import ModuleType
-from typing import (
-    Any,
-    Dict,
-    List,
-    Literal,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
-
-SchemaType = Literal["object", "integer", "double", "string", "boolean", "array"]
-
-TYPE_MAP: Dict[str, SchemaType] = {
-    "int": "integer",
-    "float": "double",
-    "str": "string",
-    "bool": "boolean",
-    "list": "array",
-    "dict": "object",
-    "List": "array",
-    "Dict": "object",
-}
-
-
-def get_type_schema(type_hint: Any) -> Dict[str, Any]:
-    """Convert a type hint to a JSON schema."""
-    if type_hint is None or type_hint == inspect.Parameter.empty:
-        return {"type": "object"}
-
-    origin = get_origin(type_hint)
-    args = get_args(type_hint)
-
-    if origin is Union:
-        if type(None) in args:
-            real_type = next(arg for arg in args if arg is not type(None))
-            return get_type_schema(real_type)
-        return {"type": "object"}
-
-    if origin in (list, List):
-        item_type = args[0] if args else Any
-        return {"type": "array", "items": get_type_schema(item_type)}
-
-    if origin in (dict, Dict):
-        return {"type": "object"}
-
-    if inspect.isclass(type_hint):
-        if is_dataclass(type_hint):
-            properties = {}
-            required = []
-
-            for field in fields(type_hint):
-                field_schema = get_type_schema(field.type)
-                properties[field.name] = field_schema
-                if field.default == field.default_factory:
-                    required.append(field.name)
-
-            return {"type": "object", "properties": properties, "required": required}
-        elif hasattr(type_hint, "__annotations__"):
-            properties = {}
-            required = []
-
-            for name, field_type in type_hint.__annotations__.items():
-                field_schema = get_type_schema(field_type)
-                properties[name] = field_schema
-                # For regular classes, we'll consider all annotated fields as required
-                # unless they have a default value in __init__
-                if hasattr(type_hint, "__init__"):
-                    sig = inspect.signature(type_hint.__init__)
-                    if (
-                        name in sig.parameters
-                        and sig.parameters[name].default == inspect.Parameter.empty
-                    ):
-                        required.append(name)
-                else:
-                    required.append(name)
-
-            return {"type": "object", "properties": properties, "required": required}
-
-    type_name = type_hint.__name__ if hasattr(type_hint, "__name__") else str(type_hint)
-    schema_type = TYPE_MAP.get(type_name, "object")
-
-    return {"type": schema_type}
-
-
-def load_module(file_path: str) -> ModuleType:
-    """Load a Python module from file path."""
-    spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
-    if not spec or not spec.loader:
-        raise ImportError(f"Could not load spec for {file_path}")
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["dynamic_module"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def generate_args(path: str) -> Dict[str, Dict[str, Any]]:
-    """Generate input/output schema from main function type hints."""
-    module = load_module(path)
-
-    main_func = None
-    for func_name in ["main", "run", "execute"]:
-        if hasattr(module, func_name):
-            main_func = getattr(module, func_name)
-            break
-
-    if not main_func:
-        raise ValueError("No main function found in module")
-
-    hints = get_type_hints(main_func)
-    sig = inspect.signature(main_func)
-
-    if not sig.parameters:
-        return {"input": {}, "output": get_type_schema(hints.get("return", None))}
-
-    input_param_name = next(iter(sig.parameters))
-    input_schema = get_type_schema(hints.get(input_param_name))
-    output_schema = get_type_schema(hints.get("return"))
-
-    return {"input": input_schema, "output": output_schema}
diff --git a/src/uipath/_cli/_utils/_parse_ast.py b/src/uipath/_cli/_utils/_parse_ast.py
deleted file mode 100644
index 46b48faaa..000000000
--- a/src/uipath/_cli/_utils/_parse_ast.py
+++ /dev/null
@@ -1,523 +0,0 @@
-# type: ignore
-
-import ast
-import os
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple
-
-from ..._services import (
-    AssetsService,
-    BucketsService,
-    ContextGroundingService,
-    ProcessesService,
-)
-from ..._utils import get_inferred_bindings_names
-from ._constants import BINDINGS_VERSION
-
-
-@dataclass
-class ServiceMethodCall:
-    """Represents a call to a service method with its parameters."""
-
-    method_name: str
-    args: List[Any] = field(default_factory=list)
-    kwargs: Dict[str, Any] = field(default_factory=dict)
-    line_number: int = 0
-
-    def extract_string_arg(self, index: int = 0) -> Optional[str]:
-        """Extract a string argument at the given position if it exists."""
-        if index < len(self.args):
-            if isinstance(self.args[index], str):
-                return self.args[index]
-            elif isinstance(self.args[index], (int, float, bool)):
-                return str(self.args[index])
-        return None
-
-
-service_name_resource_mapping = {
-    "assets": "asset",
-    "processes": "process",
-    "buckets": "bucket",
-    "connections": "connection",
-    "context_grounding": "index",
-}
-
-supported_bindings_by_service = {
-    "assets": AssetsService,
-    "processes": ProcessesService,
-    "buckets": BucketsService,
-    "context_grounding": ContextGroundingService,
-}
-
-
-def transform_connector_name(connector_name: str) -> str:
-    """Transform connector name from underscore format to hyphenated format.
-
-    Args:
-        connector_name: Connector name in format "one_two"
-
-    Returns:
-        str: Connector name in format "uipath-one-two"
-
-    Examples:
-        >>> transform_connector_name("google_gmail")
-        'uipath-google-gmail'
-        >>> transform_connector_name("salesforce_sfdc")
-        'uipath-salesforce-sfdc'
-    """
-    if not connector_name:
-        return ""
-    parts = connector_name.split("_")
-    return f"uipath-{'-'.join(parts)}"
-
-
-@dataclass
-class ServiceUsage:
-    """Collects all method calls for a specific service type."""
-
-    service_name: str
-    method_calls: List[ServiceMethodCall] = field(default_factory=list)
-
-    def get_component_info(self) -> List[Dict[str, str]]:
-        """Extract component names and folders based on the service type."""
-        result = []
-        has_support, service_cls = self._support_for_bindings_inference()
-        if has_support:
-            for call in self.method_calls:
-                inferred_bindings = get_inferred_bindings_names(service_cls)
-                if call.method_name in inferred_bindings:
-                    name = extract_parameter(
-                        call, inferred_bindings[call.method_name]["name"], 0
-                    )
-                    folder_path = extract_parameter(
-                        call, inferred_bindings[call.method_name]["folder_path"]
-                    )
-                    if name:
-                        result.append(
-                            {
-                                "name": name,
-                                "folder": folder_path or "",
-                                "method": call.method_name,
-                            }
-                        )
-
-        # custom logic for connections bindings
-        elif self.service_name == "connections":
-            for call in self.method_calls:
-                if len(call.args) > 0:
-                    connection_id = call.args[0]
-                    if connection_id:
-                        result.append(
-                            {
-                                "name": str(connection_id),
-                                "connector": call.method_name,
-                                "method": "connector",
-                            }
-                        )
-
-        return result
-
-    def _support_for_bindings_inference(self) -> Tuple[bool, Any]:
-        return (
-            self.service_name in supported_bindings_by_service,
-            supported_bindings_by_service.get(self.service_name, None),
-        )
-
-
-def extract_parameter(
-    method_call: ServiceMethodCall,
-    param_name: str,
-    position_index: Optional[int] = None,
-) -> Optional[Any]:
-    """Extract a parameter from a method call, checking both keyword and positional arguments.
-
-    Args:
-        method_call: The ServiceMethodCall object
-        param_name: The name of the parameter to extract
-        position_index: Optional position of the parameter if passed as a positional argument
-
-    Returns:
-        The parameter value if found, None otherwise
-    """
-    if param_name in method_call.kwargs:
-        return method_call.kwargs[param_name]
-
-    if position_index is not None and position_index < len(method_call.args):
-        return method_call.args[position_index]
-
-    return None
-
-
-def parse_local_module(
-    module_path: str, base_dir: str
-) -> Dict[str, List[Dict[str, str]]]:
-    """Parse a local module and extract SDK usage.
-
-    Args:
-        module_path: Import path of the module (e.g., 'myapp.utils')
-        base_dir: Base directory to resolve relative imports
-
-    Returns:
-        Dictionary of SDK usage from the module
-    """
-    # Convert module path to file path
-    file_path = os.path.join(base_dir, *module_path.split(".")) + ".py"
-
-    # Check if the file exists
-    if not os.path.exists(file_path):
-        # Try as a package with __init__.py
-        file_path = os.path.join(base_dir, *module_path.split("."), "__init__.py")
-        if not os.path.exists(file_path):
-            return {}
-
-    # Parse the module
-    try:
-        with open(file_path, "r") as f:
-            source_code = f.read()
-        return parse_sdk_usage(source_code, base_dir)
-    except Exception:
-        return {}
-
-
-class UiPathTracker:
-    """Tracks UiPath usage throughout the code."""
-
-    def __init__(self, source_code: str, base_dir: str = ""):
-        self.source_code = source_code
-        self.base_dir = base_dir
-        self.tree = ast.parse(source_code)
-        self.sdk_imports: Dict[str, str] = {}  # Import alias -> original module
-        self.sdk_instances: Dict[str, str] = {}  # Instance name -> class
-        self.local_imports: List[str] = []  # List of local module imports
-        self.service_usage: Dict[str, ServiceUsage] = {
-            "assets": ServiceUsage("assets"),
-            "processes": ServiceUsage("processes"),
-            "buckets": ServiceUsage("buckets"),
-            "actions": ServiceUsage("actions"),
-            "context_grounding": ServiceUsage("context_grounding"),
-            "api_client": ServiceUsage("api_client"),
-            "connections": ServiceUsage("connections"),  # Add connections service
-        }
-
-    def analyze(self) -> None:
-        """Run all analysis steps."""
-        self._find_imports()
-        self._find_instances()
-        self._find_method_calls()
-
-    def _find_imports(self) -> None:
-        """Find all imports of UiPath and local modules."""
-
-        class ImportVisitor(ast.NodeVisitor):
-            def __init__(self):
-                self.imports = {}
-                self.local_imports = []
-
-            def visit_Import(self, node):
-                for alias in node.names:
-                    if alias.name == "uipath":
-                        self.imports[alias.asname or alias.name] = alias.name
-                    elif (
-                        not alias.name.startswith(("__", "builtins", "typing"))
-                        and "." not in alias.name
-                    ):
-                        # Potential local import
-                        self.local_imports.append(alias.name)
-                self.generic_visit(node)
-
-            def visit_ImportFrom(self, node):
-                if node.module == "uipath":
-                    for alias in node.names:
-                        if alias.name == "UiPath":
-                            self.imports[alias.asname or alias.name] = "uipath.UiPath"
-                elif node.module and not node.module.startswith(
-                    ("__", "builtins", "typing")
-                ):
-                    # Potential local import
-                    self.local_imports.append(node.module)
-                self.generic_visit(node)
-
-        visitor = ImportVisitor()
-        visitor.visit(self.tree)
-        self.sdk_imports = visitor.imports
-        self.local_imports = visitor.local_imports
-
-    def _find_instances(self) -> None:
-        """Find all instances created from UiPath."""
-
-        class InstanceVisitor(ast.NodeVisitor):
-            def __init__(self, sdk_imports):
-                self.sdk_imports = sdk_imports
-                self.instances = {}
-
-            def visit_Assign(self, node):
-                if isinstance(node.value, ast.Call):
-                    call = node.value
-                    if (
-                        isinstance(call.func, ast.Name)
-                        and call.func.id in self.sdk_imports
-                    ):
-                        for target in node.targets:
-                            if isinstance(target, ast.Name):
-                                self.instances[target.id] = "UiPath"
-                self.generic_visit(node)
-
-        visitor = InstanceVisitor(self.sdk_imports)
-        visitor.visit(self.tree)
-        self.sdk_instances = visitor.instances
-
-    def _find_method_calls(self) -> None:
-        """Find all method calls on UiPath instances."""
-
-        class MethodCallVisitor(ast.NodeVisitor):
-            def __init__(self, source_code, sdk_instances, service_usage):
-                self.source_code = source_code
-                self.sdk_instances = sdk_instances
-                self.service_usage = service_usage
-
-            def visit_Call(self, node):
-                if isinstance(node.func, ast.Attribute) and isinstance(
-                    node.func.value, ast.Attribute
-                ):
-                    if (
-                        isinstance(node.func.value.value, ast.Name)
-                        and node.func.value.value.id in self.sdk_instances
-                    ):
-                        service_name = node.func.value.attr
-                        method_name = node.func.attr
-
-                        if service_name in self.service_usage:
-                            # Extract arguments
-                            args = []
-                            for arg in node.args:
-                                if isinstance(arg, ast.Constant) and isinstance(
-                                    arg.value, str
-                                ):
-                                    args.append(arg.value)
-                                elif isinstance(arg, ast.Constant):
-                                    # Handle non-string constants normally
-                                    args.append(arg.value)
-                                else:
-                                    # For expressions and variables, prefix with EXPR$
-                                    source_segment = ast.get_source_segment(
-                                        self.source_code, arg
-                                    )
-                                    args.append(f"EXPR${source_segment}")
-
-                            kwargs = {}
-                            for keyword in node.keywords:
-                                if isinstance(keyword.value, ast.Constant):
-                                    kwargs[keyword.arg] = keyword.value.value
-                                else:
-                                    source_segment = ast.get_source_segment(
-                                        self.source_code, keyword.value
-                                    )
-                                    kwargs[keyword.arg] = f"EXPR${source_segment}"
-
-                            method_call = ServiceMethodCall(
-                                method_name=method_name,
-                                args=args,
-                                kwargs=kwargs,
-                                line_number=node.lineno,
-                            )
-                            self.service_usage[service_name].method_calls.append(
-                                method_call
-                            )
-
-                elif isinstance(node.func, ast.Attribute) and isinstance(
-                    node.func.value, ast.Attribute
-                ):
-                    if (
-                        isinstance(node.func.value.value, ast.Name)
-                        and node.func.value.value.id in self.sdk_instances
-                        and node.func.value.attr == "connections"
-                    ):
-                        connector_name = node.func.attr
-
-                        args = []
-                        for arg in node.args:
-                            if isinstance(arg, ast.Constant) and isinstance(
-                                arg.value, (str, int)
-                            ):
-                                args.append(arg.value)
-                            elif isinstance(arg, ast.Constant):
-                                args.append(arg.value)
-                            else:
-                                source_segment = ast.get_source_segment(
-                                    self.source_code, arg
-                                )
-                                args.append(f"EXPR${source_segment}")
-
-                        kwargs = {}
-                        for keyword in node.keywords:
-                            if isinstance(keyword.value, ast.Constant):
-                                kwargs[keyword.arg] = keyword.value.value
-                            else:
-                                source_segment = ast.get_source_segment(
-                                    self.source_code, keyword.value
-                                )
-                                kwargs[keyword.arg] = f"EXPR${source_segment}"
-
-                        method_call = ServiceMethodCall(
-                            method_name=connector_name,
-                            args=args,
-                            kwargs=kwargs,
-                            line_number=node.lineno,
-                        )
-                        self.service_usage["connections"].method_calls.append(
-                            method_call
-                        )
-
-                self.generic_visit(node)
-
-        visitor = MethodCallVisitor(
-            self.source_code, self.sdk_instances, self.service_usage
-        )
-        visitor.visit(self.tree)
-
-    def get_results(self) -> Dict[str, List[Dict[str, str]]]:
-        """Get the analysis results organized by service type."""
-        results = {}
-        for service_name, usage in self.service_usage.items():
-            components = usage.get_component_info()
-            if components:
-                results[service_name] = components
-        return results
-
-
-def parse_sdk_usage(
-    source_code: str, base_dir: str = ""
-) -> Dict[str, List[Dict[str, str]]]:
-    """Parse the source code and return UiPath usage information.
-
-    Args:
-        source_code: The Python source code to analyze
-        base_dir: Base directory to resolve relative imports
-
-    Returns:
-        Dictionary of SDK usage information
-    """
-    tracker = UiPathTracker(source_code, base_dir)
-    tracker.analyze()
-    results = tracker.get_results()
-
-    # Parse local imports recursively
-    if base_dir:
-        for module_path in tracker.local_imports:
-            module_results = parse_local_module(module_path, base_dir)
-
-            # Merge results
-            for service_name, components in module_results.items():
-                if service_name in results:
-                    results[service_name].extend(components)
-                else:
-                    results[service_name] = components
-
-    return results
-
-
-def convert_to_bindings_format(sdk_usage_data):
-    """Convert the output of parse_sdk_usage to a structure similar to bindings_v2.json.
-
-    Args:
-        sdk_usage_data: Dictionary output from parse_sdk_usage
-
-    Returns:
-        Dictionary in bindings_v2.json format
-    """
-    bindings = {"version": "2.0", "resources": []}
-
-    for resource_type, components in sdk_usage_data.items():
-        for component in components:
-            if resource_type == "connections":
-                connection_id = component.get("name", "")
-                connector_name = transform_connector_name(
-                    component.get("connector", "")
-                )
-                is_connection_id_expression = connection_id.startswith("EXPR$")
-                connection_id = connection_id.replace("EXPR$", "")
-                resource_entry = {
-                    "resource": "connection",
-                    "key": connection_id,
-                    "value": {
-                        "ConnectionId": {
-                            "defaultValue": connection_id,
-                            "isExpression": is_connection_id_expression,
-                            "displayName": "Connection",
-                        }
-                    },
-                    "metadata": {
-                        "BindingsVersion": BINDINGS_VERSION,
-                        "Connector": connector_name,
-                        "UseConnectionService": "True",
-                    },
-                }
-
-                bindings["resources"].append(resource_entry)
-                continue
-
-            resource_name = component.get("name", "")
-            folder_path = component.get("folder", None)
-            method_name = component.get("method", "Unknown")
-
-            name = resource_name
-
-            is_expression = name.startswith("EXPR$")
-            is_folder_path_expression = folder_path and folder_path.startswith("EXPR$")
-            name = name.replace("EXPR$", "")
-            folder_path = folder_path.replace("EXPR$", "") if folder_path else None
-            key = name
-            if folder_path:
-                key = f"{folder_path}.{name}"
-            resource_entry = {
-                "resource": service_name_resource_mapping[resource_type],
-                "key": key,
-                "value": {
-                    "name": {
-                        "defaultValue": name,
-                        "isExpression": is_expression,
-                        "displayName": "Name",
-                    }
-                },
-                "metadata": {
-                    "ActivityName": method_name,
-                    "BindingsVersion": BINDINGS_VERSION,
-                    "DisplayLabel": "FullName",
-                },
-            }
-
-            if folder_path:
-                resource_entry["value"]["folderPath"] = {
-                    "defaultValue": folder_path,
-                    "isExpression": is_folder_path_expression,
-                    "displayName": "Folder Path",
-                }
-
-            bindings["resources"].append(resource_entry)
-
-    return bindings
-
-
-def generate_bindings_json(file_path: str) -> str:
-    """Generate bindings JSON from a Python file.
-
-    Args:
-        file_path: Path to the Python file to analyze
-
-    Returns:
-        JSON string representation of the bindings
-    """
-    try:
-        with open(file_path, "r") as f:
-            source_code = f.read()
-
-        # Get the base directory for resolving imports
-        base_dir = os.path.dirname(os.path.abspath(file_path))
-
-        sdk_usage = parse_sdk_usage(source_code, base_dir)
-        bindings = convert_to_bindings_format(sdk_usage)
-
-        return bindings
-
-    except Exception as e:
-        raise Exception(f"Error generating bindings JSON: {e}") from e
diff --git a/src/uipath/_cli/cli_auth.py b/src/uipath/_cli/cli_auth.py
deleted file mode 100644
index b5f6a5854..000000000
--- a/src/uipath/_cli/cli_auth.py
+++ /dev/null
@@ -1,187 +0,0 @@
-# type: ignore
-import json
-import os
-import socket
-import webbrowser
-
-import click
-from dotenv import load_dotenv
-
-from ..telemetry import track
-from ._auth._auth_server import HTTPServer
-from ._auth._client_credentials import ClientCredentialsService
-from ._auth._oidc_utils import get_auth_config, get_auth_url
-from ._auth._portal_service import PortalService, select_tenant
-from ._auth._utils import update_auth_file, update_env_file
-from ._utils._common import environment_options
-from ._utils._console import ConsoleLogger
-
-load_dotenv(override=True)
-console = ConsoleLogger()
-
-
-def is_port_in_use(port: int) -> bool:
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            s.bind(("localhost", port))
-            s.close()
-            return False
-        except socket.error:
-            return True
-
-
-def set_port():
-    auth_config = get_auth_config()
-    port = auth_config.get("port", 8104)
-    port_option_one = auth_config.get("portOptionOne", 8104)
-    port_option_two = auth_config.get("portOptionTwo", 8055)
-    port_option_three = auth_config.get("portOptionThree", 42042)
-    if is_port_in_use(port):
-        if is_port_in_use(port_option_one):
-            if is_port_in_use(port_option_two):
-                if is_port_in_use(port_option_three):
-                    console.error(
-                        "All configured ports are in use. Please close applications using ports or configure different ports."
-                    )
-                else:
-                    port = port_option_three
-            else:
-                port = port_option_two
-        else:
-            port = port_option_one
-    auth_config["port"] = port
-    with open(
-        os.path.join(os.path.dirname(__file__), "..", "auth_config.json"), "w"
-    ) as f:
-        json.dump(auth_config, f)
-
-
-@click.command()
-@environment_options
-@click.option(
-    "-f",
-    "--force",
-    is_flag=True,
-    required=False,
-    help="Force new token",
-)
-@click.option(
-    "--client-id",
-    required=False,
-    help="Client ID for client credentials authentication (unattended mode)",
-)
-@click.option(
-    "--client-secret",
-    required=False,
-    help="Client secret for client credentials authentication (unattended mode)",
-)
-@click.option(
-    "--base-url",
-    required=False,
-    help="Base URL for the UiPath tenant instance (required for client credentials)",
-)
-@track
-def auth(
-    domain,
-    force: None | bool = False,
-    client_id: str = None,
-    client_secret: str = None,
-    base_url: str = None,
-):
-    """Authenticate with UiPath Cloud Platform.
-
-    Interactive mode (default): Opens browser for OAuth authentication.
-    Unattended mode: Use --client-id, --client-secret and --base-url for client credentials flow.
-
-    Network options:
-    - Set HTTP_PROXY/HTTPS_PROXY/NO_PROXY environment variables for proxy configuration
-    - Set REQUESTS_CA_BUNDLE to specify a custom CA bundle for SSL verification
-    - Set UIPATH_DISABLE_SSL_VERIFY to disable SSL verification (not recommended)
-    """
-    # Check if client credentials are provided for unattended authentication
-    if client_id and client_secret:
-        if not base_url:
-            console.error(
-                "--base-url is required when using client credentials authentication."
-            )
-            return
-
-        with console.spinner("Authenticating with client credentials ..."):
-            credentials_service = ClientCredentialsService(domain)
-
-            # If base_url is provided, extract domain from it to override the CLI domain parameter
-            if base_url:
-                extracted_domain = credentials_service.extract_domain_from_base_url(
-                    base_url
-                )
-                credentials_service.domain = extracted_domain
-
-            token_data = credentials_service.authenticate(client_id, client_secret)
-
-            if token_data:
-                credentials_service.setup_environment(token_data, base_url)
-                console.success(
-                    "Client credentials authentication successful.",
-                )
-            else:
-                console.error(
-                    "Client credentials authentication failed. Please check your credentials.",
-                )
-        return
-
-    # Interactive authentication flow (existing logic)
-    with console.spinner("Authenticating with UiPath ..."):
-        with PortalService(domain) as portal_service:
-            if not force:
-                if (
-                    os.getenv("UIPATH_URL")
-                    and os.getenv("UIPATH_TENANT_ID")
-                    and os.getenv("UIPATH_ORGANIZATION_ID")
-                ):
-                    try:
-                        portal_service.ensure_valid_token()
-                        console.success(
-                            "Authentication successful.",
-                        )
-                        return
-                    except Exception:
-                        console.info(
-                            "Authentication token is invalid. Please reauthenticate.",
-                        )
-
-            auth_url, code_verifier, state = get_auth_url(domain)
-
-            webbrowser.open(auth_url, 1)
-            auth_config = get_auth_config()
-
-            console.link(
-                "If a browser window did not open, please open the following URL in your browser:",
-                auth_url,
-            )
-
-            server = HTTPServer(port=auth_config["port"])
-            token_data = server.start(state, code_verifier, domain)
-
-            if token_data:
-                portal_service.update_token_data(token_data)
-                update_auth_file(token_data)
-                access_token = token_data["access_token"]
-                update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
-
-                tenants_and_organizations = (
-                    portal_service.get_tenants_and_organizations()
-                )
-                base_url = select_tenant(domain, tenants_and_organizations)
-                try:
-                    portal_service.post_auth(base_url)
-                    console.success(
-                        "Authentication successful.",
-                    )
-                except Exception:
-                    console.error(
-                        "Could not prepare the environment. Please try again.",
-                    )
-            else:
-                console.error(
-                    "Authentication failed. Please try again.",
-                )
diff --git a/src/uipath/_cli/cli_init.py b/src/uipath/_cli/cli_init.py
deleted file mode 100644
index 6cf2c4e38..000000000
--- a/src/uipath/_cli/cli_init.py
+++ /dev/null
@@ -1,162 +0,0 @@
-# type: ignore
-import json
-import os
-import uuid
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import click
-from dotenv import load_dotenv
-
-from ..telemetry import track
-from ._utils._console import ConsoleLogger
-from ._utils._input_args import generate_args
-from ._utils._parse_ast import generate_bindings_json
-from .middlewares import Middlewares
-
-console = ConsoleLogger()
-
-CONFIG_PATH = "uipath.json"
-
-
-def generate_env_file(target_directory):
-    env_path = os.path.join(target_directory, ".env")
-
-    if not os.path.exists(env_path):
-        relative_path = os.path.relpath(env_path, target_directory)
-        with open(env_path, "w"):
-            pass
-        console.success(f" Created '{relative_path}' file.")
-
-
-def get_existing_settings(config_path: str) -> Optional[Dict[str, Any]]:
-    """Read existing settings from uipath.json if it exists.
-
-    Args:
-        config_path: Path to the uipath.json file.
-
-    Returns:
-        The settings dictionary if it exists, None otherwise.
-    """
-    if not os.path.exists(config_path):
-        return None
-
-    try:
-        with open(config_path, "r") as config_file:
-            existing_config = json.load(config_file)
-            return existing_config.get("settings")
-    except (json.JSONDecodeError, IOError):
-        return None
-
-
-def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:
-    """Find the Python script to process."""
-    if entrypoint:
-        script_path = os.path.join(directory, entrypoint)
-        if not os.path.isfile(script_path):
-            console.error(
-                f"The {entrypoint} file does not exist in the current directory."
-            )
-            return None
-        return script_path
-
-    python_files = [f for f in os.listdir(directory) if f.endswith(".py")]
-
-    if not python_files:
-        console.error("No python files found in the current directory.")
-        return None
-    elif len(python_files) == 1:
-        return os.path.join(directory, python_files[0])
-    else:
-        console.error(
-            "Multiple python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
-        )
-        return None
-
-
-def write_config_file(config_data: Dict[str, Any]) -> None:
-    existing_settings = get_existing_settings(CONFIG_PATH)
-    if existing_settings is not None:
-        config_data["settings"] = existing_settings
-
-    with open(CONFIG_PATH, "w") as config_file:
-        json.dump(config_data, config_file, indent=4)
-
-    return CONFIG_PATH
-
-
-@click.command()
-@click.argument("entrypoint", required=False, default=None)
-@click.option(
-    "--infer-bindings/--no-infer-bindings",
-    is_flag=True,
-    required=False,
-    default=True,
-    help="Infer bindings from the script.",
-)
-@track
-def init(entrypoint: str, infer_bindings: bool) -> None:
-    """Create uipath.json with input/output schemas and bindings."""
-    current_path = os.getcwd()
-    load_dotenv(os.path.join(current_path, ".env"), override=True)
-
-    with console.spinner("Initializing UiPath project ..."):
-        current_directory = os.getcwd()
-        generate_env_file(current_directory)
-
-        result = Middlewares.next(
-            "init",
-            entrypoint,
-            options={"infer_bindings": infer_bindings},
-            write_config=write_config_file,
-        )
-
-        if result.error_message:
-            console.error(
-                result.error_message, include_traceback=result.should_include_stacktrace
-            )
-
-        if result.info_message:
-            console.info(result.info_message)
-
-        if not result.should_continue:
-            return
-
-        script_path = get_user_script(current_directory, entrypoint=entrypoint)
-
-        if not script_path:
-            return
-
-        try:
-            args = generate_args(script_path)
-
-            relative_path = Path(script_path).relative_to(current_directory).as_posix()
-
-            config_data = {
-                "entryPoints": [
-                    {
-                        "filePath": relative_path,
-                        "uniqueId": str(uuid.uuid4()),
-                        # "type": "process", OR BE doesn't offer json schema support for type: Process
-                        "type": "agent",
-                        "input": args["input"],
-                        "output": args["output"],
-                    }
-                ]
-            }
-
-            # Generate bindings JSON based on the script path
-            try:
-                if infer_bindings:
-                    bindings_data = generate_bindings_json(script_path)
-                else:
-                    bindings_data = {}
-                # Add bindings to the config data
-                config_data["bindings"] = bindings_data
-            except Exception as e:
-                console.warning(f"Warning: Could not generate bindings: {str(e)}")
-
-            config_path = write_config_file(config_data)
-            console.success(f"Created '{config_path}' file.")
-        except Exception as e:
-            console.error(f"Error creating configuration file:\n {str(e)}")
diff --git a/src/uipath/_cli/cli_pack.py b/src/uipath/_cli/cli_pack.py
deleted file mode 100644
index be2e86f88..000000000
--- a/src/uipath/_cli/cli_pack.py
+++ /dev/null
@@ -1,619 +0,0 @@
-# type: ignore
-import json
-import os
-import re
-import subprocess
-import uuid
-import zipfile
-from string import Template
-from typing import Dict, Tuple
-
-import click
-
-try:
-    import tomllib
-except ImportError:
-    import tomli as tomllib
-
-from ..telemetry import track
-from ._utils._console import ConsoleLogger
-from ._utils._constants import is_binary_file
-
-console = ConsoleLogger()
-
-schema = "https://cloud.uipath.com/draft/2024-12/entry-point"
-
-
-def validate_config_structure(config_data):
-    required_fields = ["entryPoints"]
-    for field in required_fields:
-        if field not in config_data:
-            console.error(f"uipath.json is missing the required field: {field}.")
-
-
-def check_config(directory):
-    config_path = os.path.join(directory, "uipath.json")
-    toml_path = os.path.join(directory, "pyproject.toml")
-
-    if not os.path.isfile(config_path):
-        console.error("uipath.json not found, please run `uipath init`.")
-    if not os.path.isfile(toml_path):
-        console.error("pyproject.toml not found.")
-
-    with open(config_path, "r") as config_file:
-        config_data = json.load(config_file)
-
-    validate_config_structure(config_data)
-
-    toml_data = read_toml_project(toml_path)
-
-    return {
-        "project_name": toml_data["name"],
-        "description": toml_data["description"],
-        "entryPoints": config_data["entryPoints"],
-        "version": toml_data["version"],
-        "authors": toml_data["authors"],
-        "dependencies": toml_data.get("dependencies", {}),
-    }
-
-
-def is_uv_available():
-    """Check if uv command is available in the system."""
-    try:
-        subprocess.run(["uv", "--version"], capture_output=True, check=True, timeout=20)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
-    except Exception as e:
-        console.warning(
-            f"An unexpected error occurred while checking uv availability: {str(e)}"
-        )
-        return False
-
-
-def is_uv_project(directory):
-    """Check if this is a uv project by looking for the uv.lock file."""
-    uv_lock_path = os.path.join(directory, "uv.lock")
-
-    # If uv.lock exists, it's definitely a uv project
-    if os.path.exists(uv_lock_path):
-        return True
-
-    return False
-
-
-def run_uv_lock(directory):
-    """Run uv lock to update the lock file."""
-    try:
-        subprocess.run(
-            ["uv", "lock"],
-            cwd=directory,
-            capture_output=True,
-            text=True,
-            check=True,
-            timeout=60,
-        )
-        return True
-    except subprocess.CalledProcessError as e:
-        console.warning(f"uv lock failed: {e.stderr}")
-        return False
-    except FileNotFoundError:
-        console.warning("uv command not found. Skipping lock file update.")
-        return False
-    except Exception as e:
-        console.warning(f"An unexpected error occurred while running uv lock: {str(e)}")
-        return False
-
-
-def handle_uv_operations(directory):
-    """Handle uv operations if uv is detected and available."""
-    if not is_uv_available():
-        return
-
-    if not is_uv_project(directory):
-        return
-
-    # Always run uv lock to ensure lock file is up to date
-    run_uv_lock(directory)
-
-
-def generate_operate_file(entryPoints, dependencies=None):
-    project_id = str(uuid.uuid4())
-
-    first_entry = entryPoints[0]
-    file_path = first_entry["filePath"]
-    type = first_entry["type"]
-
-    operate_json_data = {
-        "$schema": schema,
-        "projectId": project_id,
-        "main": file_path,
-        "contentType": type,
-        "targetFramework": "Portable",
-        "targetRuntime": "python",
-        "runtimeOptions": {"requiresUserInteraction": False, "isAttended": False},
-    }
-
-    # Add dependencies if provided
-    if dependencies:
-        operate_json_data["dependencies"] = dependencies
-
-    return operate_json_data
-
-
-def generate_entrypoints_file(entryPoints):
-    entrypoint_json_data = {
-        "$schema": schema,
-        "$id": "entry-points.json",
-        "entryPoints": entryPoints,
-    }
-
-    return entrypoint_json_data
-
-
-def generate_bindings_content():
-    bindings_content = {"version": "2.0", "resources": []}
-
-    return bindings_content
-
-
-def generate_content_types_content():
-    templates_path = os.path.join(
-        os.path.dirname(__file__), "_templates", "[Content_Types].xml.template"
-    )
-    with open(templates_path, "r") as file:
-        content_types_content = file.read()
-    return content_types_content
-
-
-def generate_nuspec_content(projectName, packageVersion, description, authors):
-    variables = {
-        "packageName": projectName,
-        "packageVersion": packageVersion,
-        "description": description,
-        "authors": authors,
-    }
-    templates_path = os.path.join(
-        os.path.dirname(__file__), "_templates", "package.nuspec.template"
-    )
-    with open(templates_path, "r", encoding="utf-8-sig") as f:
-        content = f.read()
-    return Template(content).substitute(variables)
-
-
-def generate_rels_content(nuspecPath, psmdcpPath):
-    # /package/services/metadata/core-properties/254324ccede240e093a925f0231429a0.psmdcp
-    templates_path = os.path.join(
-        os.path.dirname(__file__), "_templates", ".rels.template"
-    )
-    nuspecId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
-    psmdcpId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
-    variables = {
-        "nuspecPath": nuspecPath,
-        "nuspecId": nuspecId,
-        "psmdcpPath": psmdcpPath,
-        "psmdcpId": psmdcpId,
-    }
-    with open(templates_path, "r", encoding="utf-8-sig") as f:
-        content = f.read()
-    return Template(content).substitute(variables)
-
-
-def generate_psmdcp_content(projectName, version, description, authors):
-    templates_path = os.path.join(
-        os.path.dirname(__file__), "_templates", ".psmdcp.template"
-    )
-
-    token = str(uuid.uuid4()).replace("-", "")[:32]
-    random_file_name = f"{uuid.uuid4().hex[:16]}.psmdcp"
-    variables = {
-        "creator": authors,
-        "description": description,
-        "packageVersion": version,
-        "projectName": projectName,
-        "publicKeyToken": token,
-    }
-    with open(templates_path, "r", encoding="utf-8-sig") as f:
-        content = f.read()
-
-    return [random_file_name, Template(content).substitute(variables)]
-
-
-def generate_package_descriptor_content(entryPoints):
-    files = {
-        "operate.json": "content/operate.json",
-        "entry-points.json": "content/entry-points.json",
-        "bindings.json": "content/bindings_v2.json",
-    }
-
-    for entry in entryPoints:
-        files[entry["filePath"]] = entry["filePath"]
-
-    package_descriptor_content = {
-        "$schema": "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-        "files": files,
-    }
-
-    return package_descriptor_content
-
-
-def is_venv_dir(d):
-    return (
-        os.path.exists(os.path.join(d, "Scripts", "activate"))
-        if os.name == "nt"
-        else os.path.exists(os.path.join(d, "bin", "activate"))
-    )
-
-
-def pack_fn(
-    projectName,
-    description,
-    entryPoints,
-    version,
-    authors,
-    directory,
-    dependencies=None,
-    include_uv_lock=True,
-):
-    operate_file = generate_operate_file(entryPoints, dependencies)
-    entrypoints_file = generate_entrypoints_file(entryPoints)
-
-    # Get bindings from uipath.json if available
-    config_path = os.path.join(directory, "uipath.json")
-    if not os.path.exists(config_path):
-        console.error("uipath.json not found, please run `uipath init`.")
-
-    # Define the allowlist of file extensions to include
-    file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]
-    files_included = []
-
-    with open(config_path, "r") as f:
-        config_data = json.load(f)
-        if "bindings" in config_data:
-            bindings_content = config_data["bindings"]
-        else:
-            bindings_content = generate_bindings_content()
-        if "settings" in config_data:
-            settings = config_data["settings"]
-            if "fileExtensionsIncluded" in settings:
-                file_extensions_included.extend(settings["fileExtensionsIncluded"])
-            if "filesIncluded" in settings:
-                files_included = settings["filesIncluded"]
-
-    content_types_content = generate_content_types_content()
-    [psmdcp_file_name, psmdcp_content] = generate_psmdcp_content(
-        projectName, version, description, authors
-    )
-    nuspec_content = generate_nuspec_content(projectName, version, description, authors)
-    rels_content = generate_rels_content(
-        f"/{projectName}.nuspec",
-        f"/package/services/metadata/core-properties/{psmdcp_file_name}",
-    )
-    package_descriptor_content = generate_package_descriptor_content(entryPoints)
-
-    # Create .uipath directory if it doesn't exist
-    os.makedirs(".uipath", exist_ok=True)
-
-    with zipfile.ZipFile(
-        f".uipath/{projectName}.{version}.nupkg", "w", zipfile.ZIP_DEFLATED
-    ) as z:
-        # Add metadata files
-        z.writestr(
-            f"./package/services/metadata/core-properties/{psmdcp_file_name}",
-            psmdcp_content,
-        )
-        z.writestr("[Content_Types].xml", content_types_content)
-        z.writestr(
-            "content/package-descriptor.json",
-            json.dumps(package_descriptor_content, indent=4),
-        )
-        z.writestr("content/operate.json", json.dumps(operate_file, indent=4))
-        z.writestr("content/entry-points.json", json.dumps(entrypoints_file, indent=4))
-        z.writestr("content/bindings_v2.json", json.dumps(bindings_content, indent=4))
-        z.writestr(f"{projectName}.nuspec", nuspec_content)
-        z.writestr("_rels/.rels", rels_content)
-
-        # Walk through directory and add all files with extensions in the allowlist
-        for root, dirs, files in os.walk(directory):
-            # Skip all directories that start with . or are a venv
-            dirs[:] = [
-                d
-                for d in dirs
-                if not d.startswith(".") and not is_venv_dir(os.path.join(root, d))
-            ]
-
-            for file in files:
-                file_extension = os.path.splitext(file)[1].lower()
-                if file_extension in file_extensions_included or file in files_included:
-                    file_path = os.path.join(root, file)
-                    rel_path = os.path.relpath(file_path, directory)
-                    if is_binary_file(file_extension):
-                        # Read binary files in binary mode
-                        with open(file_path, "rb") as f:
-                            z.writestr(f"content/{rel_path}", f.read())
-                    else:
-                        try:
-                            # Try UTF-8 first
-                            with open(file_path, "r", encoding="utf-8") as f:
-                                z.writestr(f"content/{rel_path}", f.read())
-                        except UnicodeDecodeError:
-                            # If UTF-8 fails, try with utf-8-sig (for files with BOM)
-                            try:
-                                with open(file_path, "r", encoding="utf-8-sig") as f:
-                                    z.writestr(f"content/{rel_path}", f.read())
-                            except UnicodeDecodeError:
-                                # If that also fails, try with latin-1 as a fallback
-                                with open(file_path, "r", encoding="latin-1") as f:
-                                    z.writestr(f"content/{rel_path}", f.read())
-
-        # Handle optional files, conditionally including uv.lock
-        optional_files = ["pyproject.toml"]
-        if include_uv_lock:
-            optional_files.append("uv.lock")
-
-        for file in optional_files:
-            file_path = os.path.join(directory, file)
-            if os.path.exists(file_path):
-                try:
-                    with open(file_path, "r", encoding="utf-8") as f:
-                        z.writestr(f"content/{file}", f.read())
-                except UnicodeDecodeError:
-                    with open(file_path, "r", encoding="latin-1") as f:
-                        z.writestr(f"content/{file}", f.read())
-
-
-def parse_dependency_string(dependency: str) -> Tuple[str, str]:
-    """Parse a dependency string into package name and version specifier.
-
-    Handles PEP 508 dependency specifications including:
-    - Simple names: "requests"
-    - Version specifiers: "requests>=2.28.0"
-    - Complex specifiers: "requests>=2.28.0,<3.0.0"
-    - Extras: "requests[security]>=2.28.0"
-    - Environment markers: "requests>=2.28.0; python_version>='3.8'"
-
-    Args:
-        dependency: Raw dependency string from pyproject.toml
-
-    Returns:
-        Tuple of (package_name, version_specifier)
-
-    Examples:
-        "requests" -> ("requests", "*")
-        "requests>=2.28.0" -> ("requests", ">=2.28.0")
-        "requests>=2.28.0,<3.0.0" -> ("requests", ">=2.28.0,<3.0.0")
-        "requests[security]>=2.28.0" -> ("requests", ">=2.28.0")
-    """
-    # Remove whitespace
-    dependency = dependency.strip()
-
-    # Handle environment markers (everything after semicolon)
-    if ";" in dependency:
-        dependency = dependency.split(";")[0].strip()
-
-    # Pattern to match package name with optional extras and version specifiers
-    # Matches: package_name[extras] version_specs
-    pattern = r"^([a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?)(\[[^\]]+\])?(.*)"
-    match = re.match(pattern, dependency)
-
-    if not match:
-        # Fallback for edge cases
-        return dependency, "*"
-
-    package_name = match.group(1)
-    version_part = match.group(4).strip() if match.group(4) else ""
-
-    # If no version specifier, return wildcard
-    if not version_part:
-        return package_name, "*"
-
-    # Clean up version specifier
-    version_spec = version_part.strip()
-
-    # Validate that version specifier starts with a valid operator
-    valid_operators = [">=", "<=", "==", "!=", "~=", ">", "<"]
-    if not any(version_spec.startswith(op) for op in valid_operators):
-        # If it doesn't start with an operator, treat as exact version
-        if version_spec:
-            version_spec = f"=={version_spec}"
-        else:
-            version_spec = "*"
-
-    return package_name, version_spec
-
-
-def extract_dependencies_from_toml(project_data: Dict) -> Dict[str, str]:
-    """Extract and parse dependencies from pyproject.toml project data.
-
-    Args:
-        project_data: The "project" section from pyproject.toml
-
-    Returns:
-        Dictionary mapping package names to version specifiers
-    """
-    dependencies = {}
-
-    if "dependencies" not in project_data:
-        return dependencies
-
-    deps_list = project_data["dependencies"]
-    if not isinstance(deps_list, list):
-        console.warning("dependencies should be a list in pyproject.toml")
-        return dependencies
-
-    for dep in deps_list:
-        if not isinstance(dep, str):
-            console.warning(f"Skipping non-string dependency: {dep}")
-            continue
-
-        try:
-            name, version_spec = parse_dependency_string(dep)
-            if name:  # Only add if we got a valid name
-                dependencies[name] = version_spec
-        except Exception as e:
-            console.warning(f"Failed to parse dependency '{dep}': {e}")
-            continue
-
-    return dependencies
-
-
-def read_toml_project(file_path: str) -> dict:
-    """Read and parse pyproject.toml file with improved error handling and validation.
-
-    Args:
-        file_path: Path to pyproject.toml file
-
-    Returns:
-        Dictionary containing project metadata and dependencies
-    """
-    try:
-        with open(file_path, "rb") as f:
-            content = tomllib.load(f)
-    except Exception as e:
-        console.error(f"Failed to read or parse pyproject.toml: {e}")
-
-    # Validate required sections
-    if "project" not in content:
-        console.error("pyproject.toml is missing the required field: project.")
-
-    project = content["project"]
-
-    # Validate required fields with better error messages
-    required_fields = {
-        "name": "Project name is required in pyproject.toml",
-        "description": "Project description is required in pyproject.toml",
-        "version": "Project version is required in pyproject.toml",
-    }
-
-    for field, error_msg in required_fields.items():
-        if field not in project:
-            console.error(
-                f"pyproject.toml is missing the required field: project.{field}. {error_msg}"
-            )
-
-        # Check for empty values only if field exists
-        if field in project and (
-            not project[field]
-            or (isinstance(project[field], str) and not project[field].strip())
-        ):
-            console.error(
-                f"Project {field} cannot be empty. Please specify a {field} in pyproject.toml."
-            )
-
-    # Extract author information safely
-    authors = project.get("authors", [])
-    author_name = ""
-
-    if authors and isinstance(authors, list) and len(authors) > 0:
-        first_author = authors[0]
-        if isinstance(first_author, dict):
-            author_name = first_author.get("name", "")
-        elif isinstance(first_author, str):
-            # Handle case where authors is a list of strings
-            author_name = first_author
-
-    # Extract dependencies with improved parsing
-    dependencies = extract_dependencies_from_toml(project)
-
-    return {
-        "name": project["name"].strip(),
-        "description": project["description"].strip(),
-        "version": project["version"].strip(),
-        "authors": author_name.strip(),
-        "dependencies": dependencies,
-    }
-
-
-def get_project_version(directory):
-    toml_path = os.path.join(directory, "pyproject.toml")
-    if not os.path.exists(toml_path):
-        console.warning("pyproject.toml not found. Using default version 0.0.1")
-        return "0.0.1"
-    toml_data = read_toml_project(toml_path)
-    return toml_data["version"]
-
-
-def display_project_info(config):
-    max_label_length = max(
-        len(label) for label in ["Name", "Version", "Description", "Authors"]
-    )
-
-    max_length = 100
-    description = config["description"]
-    if len(description) >= max_length:
-        description = description[: max_length - 3] + " ..."
-
-    console.log(f"{'Name'.ljust(max_label_length)}: {config['project_name']}")
-    console.log(f"{'Version'.ljust(max_label_length)}: {config['version']}")
-    console.log(f"{'Description'.ljust(max_label_length)}: {description}")
-    console.log(f"{'Authors'.ljust(max_label_length)}: {config['authors']}")
-
-
-@click.command()
-@click.argument("root", type=str, default="./")
-@click.option(
-    "--nolock",
-    is_flag=True,
-    help="Skip running uv lock and exclude uv.lock from the package",
-)
-@track
-def pack(root, nolock):
-    """Pack the project."""
-    version = get_project_version(root)
-
-    while not os.path.isfile(os.path.join(root, "uipath.json")):
-        console.error(
-            "uipath.json not found. Please run `uipath init` in the project directory."
-        )
-    config = check_config(root)
-    if not config["project_name"] or config["project_name"].strip() == "":
-        console.error(
-            "Project name cannot be empty. Please specify a name in pyproject.toml."
-        )
-
-    if not config["description"] or config["description"].strip() == "":
-        console.error(
-            "Project description cannot be empty. Please specify a description in pyproject.toml."
-        )
-
-    if not config["authors"] or config["authors"].strip() == "":
-        console.error(
-            'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
-        )
-
-    invalid_chars = ["&", "<", ">", '"', "'", ";"]
-    for char in invalid_chars:
-        if char in config["project_name"]:
-            console.error(f"Project name contains invalid character: '{char}'")
-
-    for char in invalid_chars:
-        if char in config["description"]:
-            console.error(f"Project description contains invalid character: '{char}'")
-
-    with console.spinner("Packaging project ..."):
-        try:
-            # Handle uv operations before packaging, unless nolock is specified
-            if not nolock:
-                handle_uv_operations(root)
-
-            pack_fn(
-                config["project_name"],
-                config["description"],
-                config["entryPoints"],
-                version or config["version"],
-                config["authors"],
-                root,
-                config.get("dependencies"),
-                include_uv_lock=not nolock,
-            )
-            display_project_info(config)
-            console.success("Project successfully packaged.")
-
-        except Exception as e:
-            console.error(
-                f"Failed to create package {config['project_name']}.{version or config['version']}: {str(e)}"
-            )
-
-
-if __name__ == "__main__":
-    pack()
diff --git a/src/uipath/_cli/cli_run.py b/src/uipath/_cli/cli_run.py
deleted file mode 100644
index fb3298d74..000000000
--- a/src/uipath/_cli/cli_run.py
+++ /dev/null
@@ -1,206 +0,0 @@
-# type: ignore
-import asyncio
-import os
-import traceback
-from os import environ as env
-from typing import Optional
-from uuid import uuid4
-
-import click
-from dotenv import load_dotenv
-
-from uipath._cli._utils._debug import setup_debugging
-
-from .._utils.constants import (
-    ENV_JOB_ID,
-)
-from ..telemetry import track
-from ._runtime._contracts import (
-    UiPathRuntimeContext,
-    UiPathRuntimeError,
-    UiPathTraceContext,
-)
-from ._runtime._runtime import UiPathRuntime
-from ._utils._console import ConsoleLogger
-from .middlewares import MiddlewareResult, Middlewares
-
-console = ConsoleLogger()
-load_dotenv(override=True)
-
-
-def python_run_middleware(
-    entrypoint: Optional[str],
-    input: Optional[str],
-    resume: bool,
-    **kwargs,
-) -> MiddlewareResult:
-    """Middleware to handle Python script execution.
-
-    Args:
-        entrypoint: Path to the Python script to execute
-        input: JSON string with input data
-        resume: Flag indicating if this is a resume execution
-        debug: Enable debugging with debugpy
-        debug_port: Port for debug server (default: 5678)
-
-    Returns:
-        MiddlewareResult with execution status and messages
-    """
-    if not entrypoint:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message="""No entrypoint specified. Please provide a path to a Python script.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    if not os.path.exists(entrypoint):
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"""Script not found at path {entrypoint}.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    try:
-
-        async def execute():
-            context = UiPathRuntimeContext.from_config(
-                env.get("UIPATH_CONFIG_PATH", "uipath.json")
-            )
-            context.entrypoint = entrypoint
-            context.input = input
-            context.resume = resume
-            context.job_id = env.get("UIPATH_JOB_KEY")
-            context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.input_file = kwargs.get("input_file", None)
-            context.execution_output_file = kwargs.get("execution_output_file", None)
-            context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
-            context.trace_context = UiPathTraceContext(
-                trace_id=env.get("UIPATH_TRACE_ID"),
-                parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
-                root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
-                enabled=env.get("UIPATH_TRACING_ENABLED", True),
-                job_id=env.get("UIPATH_JOB_KEY"),
-                org_id=env.get("UIPATH_ORGANIZATION_ID"),
-                tenant_id=env.get("UIPATH_TENANT_ID"),
-                process_key=env.get("UIPATH_PROCESS_UUID"),
-                folder_key=env.get("UIPATH_FOLDER_KEY"),
-                reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
-            )
-            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            async with UiPathRuntime.from_context(context) as runtime:
-                await runtime.execute()
-
-        asyncio.run(execute())
-
-        # Return success
-        return MiddlewareResult(should_continue=False)
-
-    except UiPathRuntimeError as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: {e.error_info.title} - {e.error_info.detail}",
-            should_include_stacktrace=False,
-        )
-    except Exception as e:
-        # Handle unexpected errors
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: Unexpected error occurred - {str(e)}",
-            should_include_stacktrace=True,
-        )
-
-
-@click.command()
-@click.argument("entrypoint", required=False)
-@click.argument("input", required=False, default="{}")
-@click.option("--resume", is_flag=True, help="Resume execution from a previous state")
-@click.option(
-    "-f",
-    "--file",
-    required=False,
-    type=click.Path(exists=True),
-    help="File path for the .json input",
-)
-@click.option(
-    "--input-file",
-    required=False,
-    type=click.Path(exists=True),
-    help="Alias for '-f/--file' arguments",
-)
-@click.option(
-    "--output-file",
-    required=False,
-    type=click.Path(exists=False),
-    help="File path where the output will be written",
-)
-@click.option(
-    "--debug",
-    is_flag=True,
-    help="Enable debugging with debugpy. The process will wait for a debugger to attach.",
-)
-@click.option(
-    "--debug-port",
-    type=int,
-    default=5678,
-    help="Port for the debug server (default: 5678)",
-)
-@track(when=lambda *_a, **_kw: env.get(ENV_JOB_ID) is None)
-def run(
-    entrypoint: Optional[str],
-    input: Optional[str],
-    resume: bool,
-    file: Optional[str],
-    input_file: Optional[str],
-    output_file: Optional[str],
-    debug: bool,
-    debug_port: int,
-) -> None:
-    """Execute the project."""
-    input_file = file or input_file
-    # Setup debugging if requested
-    if not setup_debugging(debug, debug_port):
-        console.error(f"Failed to start debug server on port {debug_port}")
-
-    # Process through middleware chain
-    result = Middlewares.next(
-        "run",
-        entrypoint,
-        input,
-        resume,
-        debug=debug,
-        debug_port=debug_port,
-        input_file=input_file,
-        execution_output_file=output_file,
-    )
-
-    if result.should_continue:
-        result = python_run_middleware(
-            entrypoint=entrypoint,
-            input=input,
-            resume=resume,
-            input_file=input_file,
-            execution_output_file=output_file,
-        )
-
-    # Handle result from middleware
-    if result.error_message:
-        console.error(result.error_message, include_traceback=True)
-        if result.should_include_stacktrace:
-            console.error(traceback.format_exc())
-        click.get_current_context().exit(1)
-
-    if result.info_message:
-        console.info(result.info_message)
-
-    # If middleware chain completed but didn't handle the request
-    if result.should_continue:
-        console.error(
-            "Error: Could not process the request with any available handler."
-        )
-
-    if not result.should_continue and not result.error_message:
-        console.success("Successful execution.")
-
-
-if __name__ == "__main__":
-    run()
diff --git a/src/uipath/_config.py b/src/uipath/_config.py
deleted file mode 100644
index 6cd58547f..000000000
--- a/src/uipath/_config.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from pydantic import BaseModel
-
-
-class Config(BaseModel):
-    base_url: str
-    secret: str
diff --git a/src/uipath/_services/__init__.py b/src/uipath/_services/__init__.py
deleted file mode 100644
index adf7fb5d7..000000000
--- a/src/uipath/_services/__init__.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from .actions_service import ActionsService
-from .api_client import ApiClient
-from .assets_service import AssetsService
-from .attachments_service import AttachmentsService
-from .buckets_service import BucketsService
-from .connections_service import ConnectionsService
-from .context_grounding_service import ContextGroundingService
-from .folder_service import FolderService
-from .jobs_service import JobsService
-from .llm_gateway_service import UiPathLlmChatService, UiPathOpenAIService
-from .processes_service import ProcessesService
-from .queues_service import QueuesService
-
-__all__ = [
-    "ActionsService",
-    "AssetsService",
-    "AttachmentsService",
-    "BucketsService",
-    "ConnectionsService",
-    "ContextGroundingService",
-    "ProcessesService",
-    "ApiClient",
-    "QueuesService",
-    "JobsService",
-    "UiPathOpenAIService",
-    "UiPathLlmChatService",
-    "FolderService",
-]
diff --git a/src/uipath/_services/_base_service.py b/src/uipath/_services/_base_service.py
deleted file mode 100644
index 095269d21..000000000
--- a/src/uipath/_services/_base_service.py
+++ /dev/null
@@ -1,194 +0,0 @@
-import inspect
-from logging import getLogger
-from typing import Any, Literal, Union
-
-from httpx import (
-    URL,
-    AsyncClient,
-    Client,
-    ConnectTimeout,
-    Headers,
-    HTTPStatusError,
-    Response,
-    TimeoutException,
-)
-from tenacity import (
-    retry,
-    retry_if_exception,
-    retry_if_result,
-    wait_exponential,
-)
-
-from uipath._utils._read_overwrites import OverwritesManager
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._utils import UiPathUrl, user_agent_value
-from .._utils._ssl_context import get_httpx_client_kwargs
-from .._utils.constants import HEADER_USER_AGENT
-from ..models.exceptions import EnrichedException
-
-
-def is_retryable_exception(exception: BaseException) -> bool:
-    return isinstance(exception, (ConnectTimeout, TimeoutException))
-
-
-def is_retryable_status_code(response: Response) -> bool:
-    return response.status_code >= 500 and response.status_code < 600
-
-
-class BaseService:
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        self._logger = getLogger("uipath")
-        self._config = config
-        self._execution_context = execution_context
-
-        self._url = UiPathUrl(self._config.base_url)
-
-        default_client_kwargs = get_httpx_client_kwargs()
-
-        client_kwargs = {
-            **default_client_kwargs,  # SSL, proxy, timeout, redirects
-            "base_url": self._url.base_url,
-            "headers": Headers(self.default_headers),
-        }
-
-        self._client = Client(**client_kwargs)
-        self._client_async = AsyncClient(**client_kwargs)
-
-        self._overwrites_manager = OverwritesManager()
-        self._logger.debug(f"HEADERS: {self.default_headers}")
-
-        super().__init__()
-
-    @retry(
-        retry=(
-            retry_if_exception(is_retryable_exception)
-            | retry_if_result(is_retryable_status_code)
-        ),
-        wait=wait_exponential(multiplier=1, min=1, max=10),
-    )
-    def request(
-        self,
-        method: str,
-        url: Union[URL, str],
-        *,
-        scoped: Literal["org", "tenant"] = "tenant",
-        **kwargs: Any,
-    ) -> Response:
-        self._logger.debug(f"Request: {method} {url}")
-        self._logger.debug(f"HEADERS: {kwargs.get('headers', self._client.headers)}")
-
-        try:
-            stack = inspect.stack()
-
-            # use the third frame because of the retry decorator
-            caller_frame = stack[3].frame
-            function_name = caller_frame.f_code.co_name
-
-            if "self" in caller_frame.f_locals:
-                module_name = type(caller_frame.f_locals["self"]).__name__
-            elif "cls" in caller_frame.f_locals:
-                module_name = caller_frame.f_locals["cls"].__name__
-            else:
-                module_name = ""
-        except Exception:
-            function_name = ""
-            module_name = ""
-
-        specific_component = (
-            f"{module_name}.{function_name}" if module_name and function_name else ""
-        )
-
-        kwargs.setdefault("headers", {})
-        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(specific_component)
-
-        scoped_url = self._url.scope_url(str(url), scoped)
-
-        response = self._client.request(method, scoped_url, **kwargs)
-
-        try:
-            response.raise_for_status()
-        except HTTPStatusError as e:
-            # include the http response in the error message
-            raise EnrichedException(e) from e
-
-        return response
-
-    @retry(
-        retry=(
-            retry_if_exception(is_retryable_exception)
-            | retry_if_result(is_retryable_status_code)
-        ),
-        wait=wait_exponential(multiplier=1, min=1, max=10),
-    )
-    async def request_async(
-        self,
-        method: str,
-        url: Union[URL, str],
-        *,
-        scoped: Literal["org", "tenant"] = "tenant",
-        **kwargs: Any,
-    ) -> Response:
-        self._logger.debug(f"Request: {method} {url}")
-        self._logger.debug(
-            f"HEADERS: {kwargs.get('headers', self._client_async.headers)}"
-        )
-
-        kwargs.setdefault("headers", {})
-        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(
-            self._specific_component
-        )
-
-        scoped_url = self._url.scope_url(str(url), scoped)
-
-        response = await self._client_async.request(method, scoped_url, **kwargs)
-
-        try:
-            response.raise_for_status()
-        except HTTPStatusError as e:
-            # include the http response in the error message
-            raise EnrichedException(e) from e
-        return response
-
-    @property
-    def default_headers(self) -> dict[str, str]:
-        return {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            **self.auth_headers,
-            **self.custom_headers,
-        }
-
-    @property
-    def auth_headers(self) -> dict[str, str]:
-        header = f"Bearer {self._config.secret}"
-        return {"Authorization": header}
-
-    @property
-    def custom_headers(self) -> dict[str, str]:
-        return {}
-
-    @property
-    def _specific_component(self) -> str:
-        try:
-            stack = inspect.stack()
-
-            caller_frame = stack[4].frame
-            function_name = caller_frame.f_code.co_name
-
-            if "self" in caller_frame.f_locals:
-                module_name = type(caller_frame.f_locals["self"]).__name__
-            elif "cls" in caller_frame.f_locals:
-                module_name = caller_frame.f_locals["cls"].__name__
-            else:
-                module_name = ""
-        except Exception:
-            function_name = ""
-            module_name = ""
-
-        specific_component = (
-            f"{module_name}.{function_name}" if module_name and function_name else ""
-        )
-
-        return specific_component
diff --git a/src/uipath/_services/actions_service.py b/src/uipath/_services/actions_service.py
deleted file mode 100644
index 5546134b5..000000000
--- a/src/uipath/_services/actions_service.py
+++ /dev/null
@@ -1,443 +0,0 @@
-import os
-import uuid
-from json import dumps
-from typing import Any, Dict, List, Optional, Tuple
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec
-from .._utils.constants import (
-    ENV_TENANT_ID,
-    HEADER_FOLDER_KEY,
-    HEADER_FOLDER_PATH,
-    HEADER_TENANT_ID,
-)
-from ..models import Action, ActionSchema
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-
-def _create_spec(
-    data: Optional[Dict[str, Any]],
-    action_schema: Optional[ActionSchema],
-    title: str,
-    app_key: Optional[str] = None,
-    app_version: Optional[int] = 1,
-    app_folder_key: Optional[str] = None,
-    app_folder_path: Optional[str] = None,
-) -> RequestSpec:
-    field_list = []
-    outcome_list = []
-    if action_schema:
-        if action_schema.inputs:
-            for input_field in action_schema.inputs:
-                field_name = input_field.name
-                field_list.append(
-                    {
-                        "Id": input_field.key,
-                        "Name": field_name,
-                        "Title": field_name,
-                        "Type": "Fact",
-                        "Value": data.get(field_name, "") if data is not None else "",
-                    }
-                )
-        if action_schema.outputs:
-            for output_field in action_schema.outputs:
-                field_name = output_field.name
-                field_list.append(
-                    {
-                        "Id": output_field.key,
-                        "Name": field_name,
-                        "Title": field_name,
-                        "Type": "Fact",
-                        "Value": "",
-                    }
-                )
-        if action_schema.in_outs:
-            for inout_field in action_schema.in_outs:
-                field_name = inout_field.name
-                field_list.append(
-                    {
-                        "Id": inout_field.key,
-                        "Name": field_name,
-                        "Title": field_name,
-                        "Type": "Fact",
-                        "Value": data.get(field_name, "") if data is not None else "",
-                    }
-                )
-        if action_schema.outcomes:
-            for outcome in action_schema.outcomes:
-                outcome_list.append(
-                    {
-                        "Id": action_schema.key,
-                        "Name": outcome.name,
-                        "Title": outcome.name,
-                        "Type": "Action.Http",
-                        "IsPrimary": True,
-                    }
-                )
-
-    return RequestSpec(
-        method="POST",
-        endpoint=Endpoint("/orchestrator_/tasks/AppTasks/CreateAppTask"),
-        content=dumps(
-            {
-                "appId": app_key,
-                "appVersion": app_version,
-                "title": title,
-                "data": data if data is not None else {},
-                "actionableMessageMetaData": {
-                    "fieldSet": {
-                        "id": str(uuid.uuid4()),
-                        "fields": field_list,
-                    }
-                    if len(field_list) != 0
-                    else {},
-                    "actionSet": {
-                        "id": str(uuid.uuid4()),
-                        "actions": outcome_list,
-                    }
-                    if len(outcome_list) != 0
-                    else {},
-                }
-                if action_schema is not None
-                else {},
-            }
-        ),
-        headers=folder_headers(app_folder_key, app_folder_path),
-    )
-
-
-def _retrieve_action_spec(
-    action_key: str, app_folder_key: str, app_folder_path: str
-) -> RequestSpec:
-    return RequestSpec(
-        method="GET",
-        endpoint=Endpoint("/orchestrator_/tasks/GenericTasks/GetTaskDataByKey"),
-        params={"taskKey": action_key},
-        headers=folder_headers(app_folder_key, app_folder_path),
-    )
-
-
-def _assign_task_spec(task_key: str, assignee: str) -> RequestSpec:
-    return RequestSpec(
-        method="POST",
-        endpoint=Endpoint(
-            "/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks"
-        ),
-        content=dumps(
-            {"taskAssignments": [{"taskId": task_key, "UserNameOrEmail": assignee}]}
-        ),
-    )
-
-
-def _retrieve_app_key_spec(app_name: str) -> RequestSpec:
-    tenant_id = os.getenv(ENV_TENANT_ID, None)
-    if not tenant_id:
-        raise Exception(f"{ENV_TENANT_ID} env var is not set")
-    return RequestSpec(
-        method="GET",
-        endpoint=Endpoint("/apps_/default/api/v1/default/deployed-action-apps-schemas"),
-        params={"search": app_name},
-        headers={HEADER_TENANT_ID: tenant_id},
-    )
-
-
-def folder_headers(
-    app_folder_key: Optional[str], app_folder_path: Optional[str]
-) -> Dict[str, str]:
-    headers = {}
-    if app_folder_key:
-        headers[HEADER_FOLDER_KEY] = app_folder_key
-    elif app_folder_path:
-        headers[HEADER_FOLDER_PATH] = app_folder_path
-    return headers
-
-
-class ActionsService(FolderContext, BaseService):
-    """Service for managing UiPath Actions.
-
-    Actions are task-based automation components that can be integrated into
-    applications and processes. They represent discrete units of work that can
-    be triggered and monitored through the UiPath API.
-
-    This service provides methods to create and retrieve actions, supporting
-    both app-specific and generic actions. It inherits folder context management
-    capabilities from FolderContext.
-
-    Reference: https://docs.uipath.com/automation-cloud/docs/actions
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(name="actions_create", run_type="uipath")
-    async def create_async(
-        self,
-        title: str,
-        data: Optional[Dict[str, Any]] = None,
-        *,
-        app_name: Optional[str] = None,
-        app_key: Optional[str] = None,
-        app_folder_path: Optional[str] = None,
-        app_folder_key: Optional[str] = None,
-        app_version: Optional[int] = 1,
-        assignee: Optional[str] = None,
-    ) -> Action:
-        """Creates a new action asynchronously.
-
-        This method creates a new action task in UiPath Orchestrator. The action can be
-        either app-specific (using app_name or app_key) or a generic action.
-
-        Args:
-            title: The title of the action
-            data: Optional dictionary containing input data for the action
-            app_name: The name of the application (if creating an app-specific action)
-            app_key: The key of the application (if creating an app-specific action)
-            app_folder_path: Optional folder path for the action
-            app_folder_key: Optional folder key for the action
-            app_version: The version of the application
-            assignee: Optional username or email to assign the task to
-
-        Returns:
-            Action: The created action object
-
-        Raises:
-            Exception: If neither app_name nor app_key is provided for app-specific actions
-        """
-        app_folder_path = app_folder_path if app_folder_path else self._folder_path
-
-        (key, action_schema) = (
-            (app_key, None)
-            if app_key
-            else await self._get_app_key_and_schema_async(app_name, app_folder_path)
-        )
-        spec = _create_spec(
-            title=title,
-            data=data,
-            app_key=key,
-            app_version=app_version,
-            action_schema=action_schema,
-            app_folder_key=app_folder_key,
-            app_folder_path=app_folder_path,
-        )
-
-        response = await self.request_async(
-            spec.method, spec.endpoint, content=spec.content, headers=spec.headers
-        )
-        json_response = response.json()
-        if assignee:
-            spec = _assign_task_spec(json_response["id"], assignee)
-            await self.request_async(spec.method, spec.endpoint, content=spec.content)
-        return Action.model_validate(json_response)
-
-    @traced(name="actions_create", run_type="uipath")
-    def create(
-        self,
-        title: str,
-        data: Optional[Dict[str, Any]] = None,
-        *,
-        app_name: Optional[str] = None,
-        app_key: Optional[str] = None,
-        app_folder_path: Optional[str] = None,
-        app_folder_key: Optional[str] = None,
-        app_version: Optional[int] = 1,
-        assignee: Optional[str] = None,
-    ) -> Action:
-        """Creates a new action synchronously.
-
-        This method creates a new action task in UiPath Orchestrator. The action can be
-        either app-specific (using app_name or app_key) or a generic action.
-
-        Args:
-            title: The title of the action
-            data: Optional dictionary containing input data for the action
-            app_name: The name of the application (if creating an app-specific action)
-            app_key: The key of the application (if creating an app-specific action)
-            app_folder_path: Optional folder path for the action
-            app_folder_key: Optional folder key for the action
-            app_version: The version of the application
-            assignee: Optional username or email to assign the task to
-
-        Returns:
-            Action: The created action object
-
-        Raises:
-            Exception: If neither app_name nor app_key is provided for app-specific actions
-        """
-        app_folder_path = app_folder_path if app_folder_path else self._folder_path
-
-        (key, action_schema) = (
-            (app_key, None)
-            if app_key
-            else self._get_app_key_and_schema(app_name, app_folder_path)
-        )
-        spec = _create_spec(
-            title=title,
-            data=data,
-            app_key=key,
-            app_version=app_version,
-            action_schema=action_schema,
-            app_folder_key=app_folder_key,
-            app_folder_path=app_folder_path,
-        )
-
-        response = self.request(
-            spec.method, spec.endpoint, content=spec.content, headers=spec.headers
-        )
-        json_response = response.json()
-        if assignee:
-            spec = _assign_task_spec(json_response["id"], assignee)
-            self.request(spec.method, spec.endpoint, content=spec.content)
-        return Action.model_validate(json_response)
-
-    @traced(name="actions_retrieve", run_type="uipath")
-    def retrieve(
-        self, action_key: str, app_folder_path: str = "", app_folder_key: str = ""
-    ) -> Action:
-        """Retrieves an action by its key synchronously.
-
-        Args:
-            action_key: The unique identifier of the action to retrieve
-            app_folder_path: Optional folder path for the action
-            app_folder_key: Optional folder key for the action
-
-        Returns:
-            Action: The retrieved action object
-        """
-        spec = _retrieve_action_spec(
-            action_key=action_key,
-            app_folder_key=app_folder_key,
-            app_folder_path=app_folder_path,
-        )
-        response = self.request(
-            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
-        )
-
-        return Action.model_validate(response.json())
-
-    @traced(name="actions_retrieve", run_type="uipath")
-    async def retrieve_async(
-        self, action_key: str, app_folder_path: str = "", app_folder_key: str = ""
-    ) -> Action:
-        """Retrieves an action by its key asynchronously.
-
-        Args:
-            action_key: The unique identifier of the action to retrieve
-            app_folder_path: Optional folder path for the action
-            app_folder_key: Optional folder key for the action
-
-        Returns:
-            Action: The retrieved action object
-        """
-        spec = _retrieve_action_spec(
-            action_key=action_key,
-            app_folder_key=app_folder_key,
-            app_folder_path=app_folder_path,
-        )
-        response = await self.request_async(
-            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
-        )
-
-        return Action.model_validate(response.json())
-
-    async def _get_app_key_and_schema_async(
-        self, app_name: Optional[str], app_folder_path: Optional[str]
-    ) -> Tuple[str, Optional[ActionSchema]]:
-        if not app_name:
-            raise Exception("appName or appKey is required")
-        spec = _retrieve_app_key_spec(app_name=app_name)
-
-        response = await self.request_async(
-            spec.method,
-            spec.endpoint,
-            params=spec.params,
-            headers=spec.headers,
-            scoped="org",
-        )
-        try:
-            deployed_app = self._extract_deployed_app(
-                response.json()["deployed"], app_folder_path
-            )
-            action_schema = deployed_app["actionSchema"]
-            deployed_app_key = deployed_app["systemName"]
-        except (KeyError, IndexError):
-            raise Exception("Action app not found") from None
-        try:
-            return (
-                deployed_app_key,
-                ActionSchema(
-                    key=action_schema["key"],
-                    in_outs=action_schema["inOuts"],
-                    inputs=action_schema["inputs"],
-                    outputs=action_schema["outputs"],
-                    outcomes=action_schema["outcomes"],
-                ),
-            )
-        except KeyError:
-            raise Exception("Failed to deserialize action schema") from KeyError
-
-    def _get_app_key_and_schema(
-        self, app_name: Optional[str], app_folder_path: Optional[str]
-    ) -> Tuple[str, Optional[ActionSchema]]:
-        if not app_name:
-            raise Exception("appName or appKey is required")
-
-        spec = _retrieve_app_key_spec(app_name=app_name)
-
-        response = self.request(
-            spec.method,
-            spec.endpoint,
-            params=spec.params,
-            headers=spec.headers,
-            scoped="org",
-        )
-
-        try:
-            deployed_app = self._extract_deployed_app(
-                response.json()["deployed"], app_folder_path
-            )
-            action_schema = deployed_app["actionSchema"]
-            deployed_app_key = deployed_app["systemName"]
-        except (KeyError, IndexError):
-            raise Exception("Action app not found") from None
-        try:
-            return (
-                deployed_app_key,
-                ActionSchema(
-                    key=action_schema["key"],
-                    in_outs=action_schema["inOuts"],
-                    inputs=action_schema["inputs"],
-                    outputs=action_schema["outputs"],
-                    outcomes=action_schema["outcomes"],
-                ),
-            )
-        except KeyError:
-            raise Exception("Failed to deserialize action schema") from KeyError
-
-    # should be removed after folder filtering support is added on apps API
-    def _extract_deployed_app(
-        self, deployed_apps: List[Dict[str, Any]], app_folder_path: Optional[str]
-    ) -> Dict[str, Any]:
-        if len(deployed_apps) > 1 and not app_folder_path:
-            raise Exception("Multiple app schemas found")
-        try:
-            if app_folder_path:
-                return next(
-                    app
-                    for app in deployed_apps
-                    if app["deploymentFolder"]["fullyQualifiedName"] == app_folder_path
-                )
-            else:
-                return next(
-                    app
-                    for app in deployed_apps
-                    if app["deploymentFolder"]["key"] == self._folder_key
-                )
-        except StopIteration:
-            raise KeyError from StopIteration
-
-    @property
-    def custom_headers(self) -> Dict[str, str]:
-        return self.folder_headers
diff --git a/src/uipath/_services/assets_service.py b/src/uipath/_services/assets_service.py
deleted file mode 100644
index 3112ed64e..000000000
--- a/src/uipath/_services/assets_service.py
+++ /dev/null
@@ -1,367 +0,0 @@
-from typing import Dict, Optional
-
-from httpx import Response
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils._read_overwrites import OverwritesManager
-from ..models import Asset, UserAsset
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-
-class AssetsService(FolderContext, BaseService):
-    """Service for managing UiPath assets.
-
-    Assets are key-value pairs that can be used to store configuration data,
-    credentials, and other settings used by automation processes.
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-        self._overwrites_manager = OverwritesManager()
-        self._base_url = "assets"
-
-    @traced(
-        name="assets_retrieve", run_type="uipath", hide_input=True, hide_output=True
-    )
-    @infer_bindings(resource_type="asset")
-    def retrieve(
-        self,
-        name: str,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> UserAsset | Asset:
-        """Retrieve an asset by its name.
-
-        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
-
-        Args:
-            name (str): The name of the asset.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-           UserAsset: The asset data.
-
-        Examples:
-            ```python
-            from uipath import UiPath
-
-            client = UiPath()
-
-            client.assets.retrieve(name="MyAsset")
-            ```
-        """
-        try:
-            is_user = self._execution_context.robot_key is not None
-        except ValueError:
-            is_user = False
-
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            params=spec.params,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        if is_user:
-            return UserAsset.model_validate(response.json())
-        else:
-            return Asset.model_validate(response.json()["value"][0])
-
-    @traced(
-        name="assets_retrieve", run_type="uipath", hide_input=True, hide_output=True
-    )
-    @infer_bindings(resource_type="asset")
-    async def retrieve_async(
-        self,
-        name: str,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> UserAsset | Asset:
-        """Asynchronously retrieve an asset by its name.
-
-        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
-
-        Args:
-            name (str): The name of the asset.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-            UserAsset: The asset data.
-        """
-        try:
-            is_user = self._execution_context.robot_key is not None
-        except ValueError:
-            is_user = False
-
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            params=spec.params,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        if is_user:
-            return UserAsset.model_validate(response.json())
-        else:
-            return Asset.model_validate(response.json()["value"][0])
-
-    @traced(
-        name="assets_credential", run_type="uipath", hide_input=True, hide_output=True
-    )
-    @infer_bindings(resource_type="asset")
-    def retrieve_credential(
-        self,
-        name: str,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Optional[str]:
-        """Gets a specified Orchestrator credential.
-
-        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable)
-
-        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
-
-        Args:
-            name (str): The name of the credential asset.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-            Optional[str]: The decrypted credential password.
-
-        Raises:
-            ValueError: If the method is called for a user asset.
-        """
-        try:
-            is_user = self._execution_context.robot_key is not None
-        except ValueError:
-            is_user = False
-
-        if not is_user:
-            raise ValueError("This method can only be used for robot assets.")
-
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        user_asset = UserAsset.model_validate(response.json())
-
-        return user_asset.credential_password
-
-    @traced(
-        name="assets_credential", run_type="uipath", hide_input=True, hide_output=True
-    )
-    @infer_bindings(resource_type="asset")
-    async def retrieve_credential_async(
-        self,
-        name: str,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Optional[str]:
-        """Asynchronously gets a specified Orchestrator credential.
-
-        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable)
-
-        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
-
-        Args:
-            name (str): The name of the credential asset.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-            Optional[str]: The decrypted credential password.
-
-        Raises:
-            ValueError: If the method is called for a user asset.
-        """
-        try:
-            is_user = self._execution_context.robot_key is not None
-        except ValueError:
-            is_user = False
-
-        if not is_user:
-            raise ValueError("This method can only be used for robot assets.")
-
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        user_asset = UserAsset.model_validate(response.json())
-
-        return user_asset.credential_password
-
-    @traced(name="assets_update", run_type="uipath", hide_input=True, hide_output=True)
-    def update(
-        self,
-        robot_asset: UserAsset,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Response:
-        """Update an asset's value.
-
-        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
-
-        Args:
-            robot_asset (UserAsset): The asset object containing the updated values.
-
-        Returns:
-            Response: The HTTP response confirming the update.
-
-        Raises:
-            ValueError: If the method is called for a user asset.
-        """
-        try:
-            is_user = self._execution_context.robot_key is not None
-        except ValueError:
-            is_user = False
-
-        if not is_user:
-            raise ValueError("This method can only be used for robot assets.")
-
-        spec = self._update_spec(
-            robot_asset, folder_key=folder_key, folder_path=folder_path
-        )
-
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        return response.json()
-
-    @traced(name="assets_update", run_type="uipath", hide_input=True, hide_output=True)
-    async def update_async(
-        self,
-        robot_asset: UserAsset,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Response:
-        """Asynchronously update an asset's value.
-
-        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
-
-        Args:
-            robot_asset (UserAsset): The asset object containing the updated values.
-
-        Returns:
-            Response: The HTTP response confirming the update.
-        """
-        spec = self._update_spec(
-            robot_asset, folder_key=folder_key, folder_path=folder_path
-        )
-
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        return response.json()
-
-    @property
-    def custom_headers(self) -> Dict[str, str]:
-        return self.folder_headers
-
-    def _retrieve_spec(
-        self,
-        name: str,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        try:
-            robot_key = self._execution_context.robot_key
-        except ValueError:
-            robot_key = None
-
-        if robot_key is None:
-            return RequestSpec(
-                method="GET",
-                endpoint=Endpoint(
-                    "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered",
-                ),
-                params={"$filter": f"Name eq '{name}'", "$top": 1},
-                headers={
-                    **header_folder(folder_key, folder_path),
-                },
-            )
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
-            ),
-            content=str({"assetName": name, "robotKey": robot_key}),
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
-
-    def _update_spec(
-        self,
-        robot_asset: UserAsset,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
-            ),
-            content=str(
-                {
-                    "robotKey": self._execution_context.robot_key,
-                    "robotAsset": robot_asset,
-                }
-            ),
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
diff --git a/src/uipath/_services/buckets_service.py b/src/uipath/_services/buckets_service.py
deleted file mode 100644
index f8c51a21c..000000000
--- a/src/uipath/_services/buckets_service.py
+++ /dev/null
@@ -1,509 +0,0 @@
-import mimetypes
-from typing import Dict, Optional, Union
-
-import httpx
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils._ssl_context import get_httpx_client_kwargs
-from ..models import Bucket
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-
-class BucketsService(FolderContext, BaseService):
-    """Service for managing UiPath storage buckets.
-
-    Buckets are cloud storage containers that can be used to store and manage files
-    used by automation processes.
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-        self.custom_client = httpx.Client(**get_httpx_client_kwargs())
-        self.custom_client_async = httpx.AsyncClient(**get_httpx_client_kwargs())
-
-    @traced(name="buckets_download", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    def download(
-        self,
-        *,
-        name: Optional[str] = None,
-        key: Optional[str] = None,
-        blob_file_path: str,
-        destination_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Download a file from a bucket.
-
-        Args:
-            key (Optional[str]): The key of the bucket.
-            name (Optional[str]): The name of the bucket.
-            blob_file_path (str): The path to the file in the bucket.
-            destination_path (str): The local path where the file will be saved.
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Raises:
-            ValueError: If neither key nor name is provided.
-            Exception: If the bucket with the specified key is not found.
-        """
-        bucket = self.retrieve(
-            name=name, key=key, folder_key=folder_key, folder_path=folder_path
-        )
-        spec = self._retrieve_readUri_spec(
-            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
-        )
-        result = self.request(
-            spec.method,
-            url=spec.endpoint,
-            params=spec.params,
-            headers=spec.headers,
-        ).json()
-
-        read_uri = result["Uri"]
-
-        headers = {
-            key: value
-            for key, value in zip(
-                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
-            )
-        }
-
-        with open(destination_path, "wb") as file:
-            # the self.request adds auth bearer token
-            if result["RequiresAuth"]:
-                file_content = self.request("GET", read_uri, headers=headers).content
-            else:
-                file_content = self.custom_client.get(read_uri, headers=headers).content
-            file.write(file_content)
-
-    @traced(name="buckets_download", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    async def download_async(
-        self,
-        *,
-        name: Optional[str] = None,
-        key: Optional[str] = None,
-        blob_file_path: str,
-        destination_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Download a file from a bucket asynchronously.
-
-        Args:
-            key (Optional[str]): The key of the bucket.
-            name (Optional[str]): The name of the bucket.
-            blob_file_path (str): The path to the file in the bucket.
-            destination_path (str): The local path where the file will be saved.
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Raises:
-            ValueError: If neither key nor name is provided.
-            Exception: If the bucket with the specified key is not found.
-        """
-        bucket = await self.retrieve_async(
-            name=name, key=key, folder_key=folder_key, folder_path=folder_path
-        )
-        spec = self._retrieve_readUri_spec(
-            bucket.id, blob_file_path, folder_key=folder_key, folder_path=folder_path
-        )
-        result = (
-            await self.request_async(
-                spec.method,
-                url=spec.endpoint,
-                params=spec.params,
-                headers=spec.headers,
-            )
-        ).json()
-
-        read_uri = result["Uri"]
-
-        headers = {
-            key: value
-            for key, value in zip(
-                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
-            )
-        }
-
-        with open(destination_path, "wb") as file:
-            # the self.request adds auth bearer token
-            if result["RequiresAuth"]:
-                file_content = (
-                    await self.request_async("GET", read_uri, headers=headers)
-                ).content
-            else:
-                file_content = (
-                    await self.custom_client_async.get(read_uri, headers=headers)
-                ).content
-            file.write(file_content)
-
-    @traced(name="buckets_upload", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    def upload(
-        self,
-        *,
-        key: Optional[str] = None,
-        name: Optional[str] = None,
-        blob_file_path: str,
-        content_type: Optional[str] = None,
-        source_path: Optional[str] = None,
-        content: Optional[Union[str, bytes]] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Upload a file to a bucket.
-
-        Args:
-            key (Optional[str]): The key of the bucket.
-            name (Optional[str]): The name of the bucket.
-            blob_file_path (str): The path where the file will be stored in the bucket.
-            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
-            source_path (Optional[str]): The local path of the file to upload.
-            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Raises:
-            ValueError: If neither key nor name is provided.
-            Exception: If the bucket with the specified key or name is not found.
-        """
-        if content is not None and source_path is not None:
-            raise ValueError("Content and source_path are mutually exclusive")
-        if content is None and source_path is None:
-            raise ValueError("Either content or source_path must be provided")
-
-        bucket = self.retrieve(
-            name=name, key=key, folder_key=folder_key, folder_path=folder_path
-        )
-
-        # if source_path, dynamically detect the mime type
-        # default to application/octet-stream
-        if source_path:
-            _content_type, _ = mimetypes.guess_type(source_path)
-        else:
-            _content_type = content_type
-        _content_type = _content_type or "application/octet-stream"
-
-        spec = self._retrieve_writeri_spec(
-            bucket.id,
-            _content_type,
-            blob_file_path,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        result = self.request(
-            spec.method,
-            url=spec.endpoint,
-            params=spec.params,
-            headers=spec.headers,
-        ).json()
-
-        write_uri = result["Uri"]
-
-        headers = {
-            key: value
-            for key, value in zip(
-                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
-            )
-        }
-
-        headers["Content-Type"] = _content_type
-
-        if content is not None:
-            if isinstance(content, str):
-                content = content.encode("utf-8")
-
-            if result["RequiresAuth"]:
-                self.request("PUT", write_uri, headers=headers, content=content)
-            else:
-                self.custom_client.put(write_uri, headers=headers, content=content)
-
-        if source_path is not None:
-            with open(source_path, "rb") as file:
-                file_content = file.read()
-                if result["RequiresAuth"]:
-                    self.request(
-                        "PUT", write_uri, headers=headers, content=file_content
-                    )
-                else:
-                    self.custom_client.put(
-                        write_uri, headers=headers, content=file_content
-                    )
-
-    @traced(name="buckets_upload", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    async def upload_async(
-        self,
-        *,
-        key: Optional[str] = None,
-        name: Optional[str] = None,
-        blob_file_path: str,
-        content_type: Optional[str] = None,
-        source_path: Optional[str] = None,
-        content: Optional[Union[str, bytes]] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Upload a file to a bucket asynchronously.
-
-        Args:
-            key (Optional[str]): The key of the bucket.
-            name (Optional[str]): The name of the bucket.
-            blob_file_path (str): The path where the file will be stored in the bucket.
-            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
-            source_path (str): The local path of the file to upload.
-            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Raises:
-            ValueError: If neither key nor name is provided.
-            Exception: If the bucket with the specified key or name is not found.
-        """
-        if content is not None and source_path is not None:
-            raise ValueError("Content and source_path are mutually exclusive")
-        if content is None and source_path is None:
-            raise ValueError("Either content or source_path must be provided")
-
-        bucket = await self.retrieve_async(
-            name=name, key=key, folder_key=folder_key, folder_path=folder_path
-        )
-
-        # if source_path, dynamically detect the mime type
-        # default to application/octet-stream
-        if source_path:
-            _content_type, _ = mimetypes.guess_type(source_path)
-        else:
-            _content_type = content_type
-        _content_type = _content_type or "application/octet-stream"
-
-        spec = self._retrieve_writeri_spec(
-            bucket.id,
-            _content_type,
-            blob_file_path,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        result = (
-            await self.request_async(
-                spec.method,
-                url=spec.endpoint,
-                params=spec.params,
-                headers=spec.headers,
-            )
-        ).json()
-
-        write_uri = result["Uri"]
-
-        headers = {
-            key: value
-            for key, value in zip(
-                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
-            )
-        }
-
-        headers["Content-Type"] = _content_type
-
-        if content is not None:
-            if isinstance(content, str):
-                content = content.encode("utf-8")
-
-            if result["RequiresAuth"]:
-                await self.request_async(
-                    "PUT", write_uri, headers=headers, content=content
-                )
-            else:
-                await self.custom_client_async.put(
-                    write_uri, headers=headers, content=content
-                )
-
-        if source_path is not None:
-            with open(source_path, "rb") as file:
-                file_content = file.read()
-                if result["RequiresAuth"]:
-                    await self.request_async(
-                        "PUT", write_uri, headers=headers, content=file_content
-                    )
-                else:
-                    await self.custom_client_async.put(
-                        write_uri, headers=headers, content=file_content
-                    )
-
-    @traced(name="buckets_retrieve", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    def retrieve(
-        self,
-        *,
-        name: Optional[str] = None,
-        key: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Bucket:
-        """Retrieve bucket information by its name.
-
-        Args:
-            name (Optional[str]): The name of the bucket to retrieve.
-            key (Optional[str]): The key of the bucket.
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Returns:
-            Response: The bucket details.
-
-        Raises:
-            ValueError: If neither bucket key nor bucket name is provided.
-            Exception: If the bucket with the specified name is not found.
-        """
-        if not (key or name):
-            raise ValueError("Must specify a bucket name or bucket key")
-        if key:
-            spec = self._retrieve_by_key_spec(
-                key, folder_key=folder_key, folder_path=folder_path
-            )
-        else:
-            spec = self._retrieve_spec(
-                name,  # type: ignore
-                folder_key=folder_key,
-                folder_path=folder_path,
-            )
-        try:
-            response = self.request(
-                spec.method,
-                url=spec.endpoint,
-                params=spec.params,
-                headers=spec.headers,
-            ).json()["value"][0]
-        except (KeyError, IndexError) as e:
-            raise Exception(f"Bucket with name '{name}' not found") from e
-        return Bucket.model_validate(response)
-
-    @traced(name="buckets_retrieve", run_type="uipath")
-    @infer_bindings(resource_type="bucket")
-    async def retrieve_async(
-        self,
-        *,
-        name: Optional[str] = None,
-        key: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Bucket:
-        """Asynchronously retrieve bucket information by its name.
-
-        Args:
-            name (Optional[str]): The name of the bucket to retrieve.
-            key (Optional[str]): The key of the bucket.
-            folder_key (Optional[str]): The key of the folder where the bucket resides.
-            folder_path (Optional[str]): The path of the folder where the bucket resides.
-
-        Returns:
-            Response: The bucket details.
-
-        Raises:
-            ValueError: If neither bucket key nor bucket name is provided.
-            Exception: If the bucket with the specified name is not found.
-        """
-        if not (key or name):
-            raise ValueError("Must specify a bucket name or bucket key")
-        if key:
-            spec = self._retrieve_by_key_spec(
-                key, folder_key=folder_key, folder_path=folder_path
-            )
-        else:
-            spec = self._retrieve_spec(
-                name,  # type: ignore
-                folder_key=folder_key,
-                folder_path=folder_path,
-            )
-
-        try:
-            response = (
-                await self.request_async(
-                    spec.method,
-                    url=spec.endpoint,
-                    params=spec.params,
-                    headers=spec.headers,
-                )
-            ).json()["value"][0]
-        except (KeyError, IndexError) as e:
-            raise Exception(f"Bucket with name '{name}' not found") from e
-        return Bucket.model_validate(response)
-
-    @property
-    def custom_headers(self) -> Dict[str, str]:
-        return self.folder_headers
-
-    def _retrieve_spec(
-        self,
-        name: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint("/orchestrator_/odata/Buckets"),
-            params={"$filter": f"Name eq '{name}'", "$top": 1},
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
-
-    def _retrieve_readUri_spec(
-        self,
-        bucket_id: int,
-        blob_file_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(
-                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetReadUri"
-            ),
-            params={"path": blob_file_path},
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
-
-    def _retrieve_writeri_spec(
-        self,
-        bucket_id: int,
-        content_type: str,
-        blob_file_path: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(
-                f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetWriteUri"
-            ),
-            params={"path": blob_file_path, "contentType": content_type},
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
-
-    def _retrieve_by_key_spec(
-        self,
-        key: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(
-                f"/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={key})"
-            ),
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
diff --git a/src/uipath/_services/connections_service.py b/src/uipath/_services/connections_service.py
deleted file mode 100644
index 0bc0efc8b..000000000
--- a/src/uipath/_services/connections_service.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import logging
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._utils import Endpoint, RequestSpec
-from ..models import Connection, ConnectionToken
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-logger: logging.Logger = logging.getLogger("uipath")
-
-
-class ConnectionsService(BaseService):
-    """Service for managing UiPath external service connections.
-
-    This service provides methods to retrieve direct connection information retrieval
-    and secure token management.
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(
-        name="connections_retrieve",
-        run_type="uipath",
-        hide_output=True,
-    )
-    def retrieve(self, key: str) -> Connection:
-        """Retrieve connection details by its key.
-
-        This method fetches the configuration and metadata for a connection,
-        which can be used to establish communication with an external service.
-
-        Args:
-            key (str): The unique identifier of the connection to retrieve.
-
-        Returns:
-            Connection: The connection details, including configuration parameters
-                and authentication information.
-        """
-        spec = self._retrieve_spec(key)
-        response = self.request(spec.method, url=spec.endpoint)
-        return Connection.model_validate(response.json())
-
-    @traced(
-        name="connections_retrieve",
-        run_type="uipath",
-        hide_output=True,
-    )
-    async def retrieve_async(self, key: str) -> Connection:
-        """Asynchronously retrieve connection details by its key.
-
-        This method fetches the configuration and metadata for a connection,
-        which can be used to establish communication with an external service.
-
-        Args:
-            key (str): The unique identifier of the connection to retrieve.
-
-        Returns:
-            Connection: The connection details, including configuration parameters
-                and authentication information.
-        """
-        spec = self._retrieve_spec(key)
-        response = await self.request_async(spec.method, url=spec.endpoint)
-        return Connection.model_validate(response.json())
-
-    @traced(
-        name="connections_retrieve_token",
-        run_type="uipath",
-        hide_output=True,
-    )
-    def retrieve_token(self, key: str) -> ConnectionToken:
-        """Retrieve an authentication token for a connection.
-
-        This method obtains a fresh authentication token that can be used to
-        communicate with the external service. This is particularly useful for
-        services that use token-based authentication.
-
-        Args:
-            key (str): The unique identifier of the connection.
-
-        Returns:
-            ConnectionToken: The authentication token details, including the token
-                value and any associated metadata.
-        """
-        spec = self._retrieve_token_spec(key)
-        response = self.request(spec.method, url=spec.endpoint, params=spec.params)
-        return ConnectionToken.model_validate(response.json())
-
-    @traced(
-        name="connections_retrieve_token",
-        run_type="uipath",
-        hide_output=True,
-    )
-    async def retrieve_token_async(self, key: str) -> ConnectionToken:
-        """Asynchronously retrieve an authentication token for a connection.
-
-        This method obtains a fresh authentication token that can be used to
-        communicate with the external service. This is particularly useful for
-        services that use token-based authentication.
-
-        Args:
-            key (str): The unique identifier of the connection.
-
-        Returns:
-            ConnectionToken: The authentication token details, including the token
-                value and any associated metadata.
-        """
-        spec = self._retrieve_token_spec(key)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, params=spec.params
-        )
-        return ConnectionToken.model_validate(response.json())
-
-    def _retrieve_spec(self, key: str) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}"),
-        )
-
-    def _retrieve_token_spec(self, key: str) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}/token"),
-            params={"type": "direct"},
-        )
diff --git a/src/uipath/_services/context_grounding_service.py b/src/uipath/_services/context_grounding_service.py
deleted file mode 100644
index 0f9017396..000000000
--- a/src/uipath/_services/context_grounding_service.py
+++ /dev/null
@@ -1,693 +0,0 @@
-import json
-from typing import Any, List, Optional, Tuple, Union
-
-import httpx
-from pydantic import TypeAdapter
-from typing_extensions import deprecated
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils.constants import (
-    ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
-)
-from ..models import IngestionInProgressException
-from ..models.context_grounding import ContextGroundingQueryResponse
-from ..models.context_grounding_index import ContextGroundingIndex
-from ..tracing._traced import traced
-from ._base_service import BaseService
-from .buckets_service import BucketsService
-from .folder_service import FolderService
-
-
-class ContextGroundingService(FolderContext, BaseService):
-    """Service for managing semantic automation contexts in UiPath.
-
-    Context Grounding is a feature that helps in understanding and managing the
-    semantic context in which automation processes operate. It provides capabilities
-    for indexing, retrieving, and searching through contextual information that
-    can be used to enhance AI-enabled automation.
-
-    This service requires a valid folder key to be set in the environment, as
-    context grounding operations are always performed within a specific folder
-    context.
-    """
-
-    def __init__(
-        self,
-        config: Config,
-        execution_context: ExecutionContext,
-        folders_service: FolderService,
-        buckets_service: BucketsService,
-    ) -> None:
-        self._folders_service = folders_service
-        self._buckets_service = buckets_service
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(name="add_to_index", run_type="uipath")
-    @infer_bindings(resource_type="index")
-    def add_to_index(
-        self,
-        name: str,
-        blob_file_path: str,
-        content_type: Optional[str] = None,
-        content: Optional[Union[str, bytes]] = None,
-        source_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-        ingest_data: bool = True,
-    ) -> None:
-        """Add content to the index.
-
-        Args:
-            name (str): The name of the index to add content to.
-            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
-            blob_file_path (str): The path where the blob will be stored in the storage bucket.
-            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
-            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-            ingest_data (bool): Whether to ingest data in the index after content is uploaded. Defaults to True.
-
-        Raises:
-            ValueError: If neither content nor source_path is provided, or if both are provided.
-        """
-        if not (content or source_path):
-            raise ValueError("Content or source_path is required")
-        if content and source_path:
-            raise ValueError("Content and source_path are mutually exclusive")
-
-        index = self.retrieve(name=name, folder_key=folder_key, folder_path=folder_path)
-        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
-        if source_path:
-            self._buckets_service.upload(
-                name=bucket_name,
-                blob_file_path=blob_file_path,
-                source_path=source_path,
-                folder_path=bucket_folder_path,
-                content_type=content_type,
-            )
-        else:
-            self._buckets_service.upload(
-                name=bucket_name,
-                content=content,
-                blob_file_path=blob_file_path,
-                folder_path=bucket_folder_path,
-                content_type=content_type,
-            )
-
-        if ingest_data:
-            self.ingest_data(index, folder_key=folder_key, folder_path=folder_path)
-
-    @traced(name="add_to_index", run_type="uipath")
-    @infer_bindings(resource_type="index")
-    async def add_to_index_async(
-        self,
-        name: str,
-        blob_file_path: str,
-        content_type: Optional[str] = None,
-        content: Optional[Union[str, bytes]] = None,
-        source_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-        ingest_data: bool = True,
-    ) -> None:
-        """Asynchronously add content to the index.
-
-        Args:
-            name (str): The name of the index to add content to.
-            content_type (Optional[str]): The MIME type of the file. For file inputs this is computed dynamically. Default is "application/octet-stream".
-            blob_file_path (str): The path where the blob will be stored in the storage bucket.
-            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
-            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-            ingest_data (bool): Whether to ingest data in the index after content is uploaded. Defaults to True.
-
-        Raises:
-            ValueError: If neither content nor source_path is provided, or if both are provided.
-        """
-        if not (content or source_path):
-            raise ValueError("Content or source_path is required")
-        if content and source_path:
-            raise ValueError("Content and source_path are mutually exclusive")
-
-        index = await self.retrieve_async(
-            name=name, folder_key=folder_key, folder_path=folder_path
-        )
-        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
-        if source_path:
-            await self._buckets_service.upload_async(
-                name=bucket_name,
-                blob_file_path=blob_file_path,
-                source_path=source_path,
-                folder_path=bucket_folder_path,
-                content_type=content_type,
-            )
-        else:
-            await self._buckets_service.upload_async(
-                name=bucket_name,
-                content=content,
-                blob_file_path=blob_file_path,
-                folder_path=bucket_folder_path,
-                content_type=content_type,
-            )
-
-        if ingest_data:
-            await self.ingest_data_async(
-                index, folder_key=folder_key, folder_path=folder_path
-            )
-
-    @traced(name="contextgrounding_retrieve", run_type="uipath")
-    @infer_bindings(resource_type="index")
-    def retrieve(
-        self,
-        name: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> ContextGroundingIndex:
-        """Retrieve context grounding index information by its name.
-
-        Args:
-            name (str): The name of the context index to retrieve.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-
-        Returns:
-            ContextGroundingIndex: The index information, including its configuration and metadata if found.
-
-        Raises:
-            Exception: If no index with the given name is found.
-        """
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = self.request(
-            spec.method,
-            spec.endpoint,
-            params=spec.params,
-            headers=spec.headers,
-        ).json()
-        try:
-            return next(
-                ContextGroundingIndex.model_validate(item)
-                for item in response["value"]
-                if item["name"] == name
-            )
-        except StopIteration as e:
-            raise Exception("ContextGroundingIndex not found") from e
-
-    @traced(name="contextgrounding_retrieve", run_type="uipath")
-    @infer_bindings(resource_type="index")
-    async def retrieve_async(
-        self,
-        name: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> ContextGroundingIndex:
-        """Asynchronously retrieve context grounding index information by its name.
-
-        Args:
-            name (str): The name of the context index to retrieve.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-
-        Returns:
-            ContextGroundingIndex: The index information, including its configuration and metadata if found.
-
-        Raises:
-            Exception: If no index with the given name is found.
-        """
-        spec = self._retrieve_spec(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = (
-            await self.request_async(
-                spec.method,
-                spec.endpoint,
-                params=spec.params,
-                headers=spec.headers,
-            )
-        ).json()
-        try:
-            return next(
-                ContextGroundingIndex.model_validate(item)
-                for item in response["value"]
-                if item["name"] == name
-            )
-        except StopIteration as e:
-            raise Exception("ContextGroundingIndex not found") from e
-
-    @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
-    @deprecated("Use retrieve instead")
-    def retrieve_by_id(
-        self,
-        id: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Any:
-        """Retrieve context grounding index information by its ID.
-
-        This method provides direct access to a context index using its unique
-        identifier, which can be more efficient than searching by name.
-
-        Args:
-            id (str): The unique identifier of the context index.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-
-        Returns:
-            Any: The index information, including its configuration and metadata.
-        """
-        spec = self._retrieve_by_id_spec(
-            id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        return self.request(
-            spec.method,
-            spec.endpoint,
-            params=spec.params,
-        ).json()
-
-    @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
-    @deprecated("Use retrieve_async instead")
-    async def retrieve_by_id_async(
-        self,
-        id: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Any:
-        """Retrieve asynchronously context grounding index information by its ID.
-
-        This method provides direct access to a context index using its unique
-        identifier, which can be more efficient than searching by name.
-
-        Args:
-            id (str): The unique identifier of the context index.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-
-        Returns:
-            Any: The index information, including its configuration and metadata.
-        """
-        spec = self._retrieve_by_id_spec(
-            id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = await self.request_async(
-            spec.method,
-            spec.endpoint,
-            params=spec.params,
-        )
-
-        return response.json()
-
-    @traced(name="contextgrounding_search", run_type="uipath")
-    def search(
-        self,
-        name: str,
-        query: str,
-        number_of_results: int = 10,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> List[ContextGroundingQueryResponse]:
-        """Search for contextual information within a specific index.
-
-        This method performs a semantic search against the specified context index,
-        helping to find relevant information that can be used in automation processes.
-        The search is powered by AI and understands natural language queries.
-
-        Args:
-            name (str): The name of the context index to search in.
-            query (str): The search query in natural language.
-            number_of_results (int, optional): Maximum number of results to return.
-                Defaults to 10.
-
-        Returns:
-            List[ContextGroundingQueryResponse]: A list of search results, each containing
-                relevant contextual information and metadata.
-        """
-        index = self.retrieve(name, folder_key=folder_key, folder_path=folder_path)
-        if index and index.in_progress_ingestion():
-            raise IngestionInProgressException(index_name=name)
-
-        spec = self._search_spec(
-            name,
-            query,
-            number_of_results,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = self.request(
-            spec.method,
-            spec.endpoint,
-            content=spec.content,
-        )
-
-        return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
-            response.json()
-        )
-
-    @traced(name="contextgrounding_search", run_type="uipath")
-    async def search_async(
-        self,
-        name: str,
-        query: str,
-        number_of_results: int = 10,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> List[ContextGroundingQueryResponse]:
-        """Search asynchronously for contextual information within a specific index.
-
-        This method performs a semantic search against the specified context index,
-        helping to find relevant information that can be used in automation processes.
-        The search is powered by AI and understands natural language queries.
-
-        Args:
-            name (str): The name of the context index to search in.
-            query (str): The search query in natural language.
-            number_of_results (int, optional): Maximum number of results to return.
-                Defaults to 10.
-
-        Returns:
-            List[ContextGroundingQueryResponse]: A list of search results, each containing
-                relevant contextual information and metadata.
-        """
-        index = self.retrieve(
-            name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        if index and index.in_progress_ingestion():
-            raise IngestionInProgressException(index_name=name)
-        spec = self._search_spec(
-            name,
-            query,
-            number_of_results,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = await self.request_async(
-            spec.method,
-            spec.endpoint,
-            content=spec.content,
-        )
-
-        return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
-            response.json()
-        )
-
-    @traced(name="contextgrounding_ingest_data", run_type="uipath")
-    def ingest_data(
-        self,
-        index: ContextGroundingIndex,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Ingest data into the context grounding index.
-
-        Args:
-            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-        """
-        if not index.id:
-            return
-        spec = self._ingest_spec(
-            index.id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        try:
-            self.request(
-                spec.method,
-                spec.endpoint,
-                headers=spec.headers,
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code != 409:
-                raise e
-            raise IngestionInProgressException(
-                index_name=index.name, search_operation=False
-            ) from e
-
-    @traced(name="contextgrounding_ingest_data", run_type="uipath")
-    async def ingest_data_async(
-        self,
-        index: ContextGroundingIndex,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Asynchronously ingest data into the context grounding index.
-
-        Args:
-            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-        """
-        if not index.id:
-            return
-        spec = self._ingest_spec(
-            index.id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        try:
-            await self.request_async(
-                spec.method,
-                spec.endpoint,
-                headers=spec.headers,
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code != 409:
-                raise e
-            raise IngestionInProgressException(
-                index_name=index.name, search_operation=False
-            ) from e
-
-    @traced(name="contextgrounding_delete_index", run_type="uipath")
-    def delete_index(
-        self,
-        index: ContextGroundingIndex,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Delete a context grounding index.
-
-        This method removes the specified context grounding index from Orchestrator.
-
-        Args:
-            index (ContextGroundingIndex): The context grounding index to delete.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-        """
-        if not index.id:
-            return
-        spec = self._delete_by_id_spec(
-            index.id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        self.request(
-            spec.method,
-            spec.endpoint,
-            headers=spec.headers,
-        )
-
-    @traced(name="contextgrounding_delete_index", run_type="uipath")
-    async def delete_index_async(
-        self,
-        index: ContextGroundingIndex,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> None:
-        """Asynchronously delete a context grounding index.
-
-        This method removes the specified context grounding index from Orchestrator.
-
-        Args:
-            index (ContextGroundingIndex): The context grounding index to delete.
-            folder_key (Optional[str]): The key of the folder where the index resides.
-            folder_path (Optional[str]): The path of the folder where the index resides.
-        """
-        if not index.id:
-            return
-        spec = self._delete_by_id_spec(
-            index.id,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        await self.request_async(
-            spec.method,
-            spec.endpoint,
-            headers=spec.headers,
-        )
-
-    def _ingest_spec(
-        self,
-        key: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(f"/ecs_/v2/indexes/{key}/ingest"),
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _retrieve_spec(
-        self,
-        name: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint("/ecs_/v2/indexes"),
-            params={
-                "$filter": f"Name eq '{name}'",
-                "$expand": "dataSource",
-            },
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _create_spec(
-        self,
-        name: str,
-        description: Optional[str],
-        storage_bucket_name: Optional[str],
-        file_name_glob: Optional[str],
-        storage_bucket_folder_path: Optional[str],
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        storage_bucket_folder_path = (
-            storage_bucket_folder_path
-            if storage_bucket_folder_path
-            else self._folder_path
-        )
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint("/ecs_/v2/indexes/create"),
-            content=json.dumps(
-                {
-                    "name": name,
-                    "description": description,
-                    "dataSource": {
-                        "@odata.type": ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
-                        "folder": storage_bucket_folder_path,
-                        "bucketName": storage_bucket_name,
-                        "fileNameGlob": file_name_glob
-                        if file_name_glob is not None
-                        else "*",
-                        "directoryPath": "/",
-                    },
-                }
-            ),
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _retrieve_by_id_spec(
-        self,
-        id: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(f"/ecs_/v2/indexes/{id}"),
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _delete_by_id_spec(
-        self,
-        id: str,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        return RequestSpec(
-            method="DELETE",
-            endpoint=Endpoint(f"/ecs_/v2/indexes/{id}"),
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _search_spec(
-        self,
-        name: str,
-        query: str,
-        number_of_results: int = 10,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        folder_key = self._resolve_folder_key(folder_key, folder_path)
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint("/ecs_/v1/search"),
-            content=json.dumps(
-                {
-                    "query": {"query": query, "numberOfResults": number_of_results},
-                    "schema": {"name": name},
-                }
-            ),
-            headers={
-                **header_folder(folder_key, None),
-            },
-        )
-
-    def _resolve_folder_key(self, folder_key, folder_path):
-        if folder_key is None and folder_path is not None:
-            folder_key = self._folders_service.retrieve_key(folder_path=folder_path)
-
-        if folder_key is None and folder_path is None:
-            folder_key = self._folder_key or (
-                self._folders_service.retrieve_key(folder_path=self._folder_path)
-                if self._folder_path
-                else None
-            )
-
-        if folder_key is None:
-            raise ValueError("ContextGrounding: Failed to resolve folder key")
-
-        return folder_key
-
-    def _extract_bucket_info(self, index: ContextGroundingIndex) -> Tuple[str, str]:
-        try:
-            return index.data_source.bucketName, index.data_source.folder  # type: ignore
-        except AttributeError as e:
-            raise Exception(
-                "ContextGrounding: Cannot extract bucket data from index"
-            ) from e
diff --git a/src/uipath/_services/folder_service.py b/src/uipath/_services/folder_service.py
deleted file mode 100644
index 37c810eaf..000000000
--- a/src/uipath/_services/folder_service.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from typing import Optional
-
-from typing_extensions import deprecated
-
-from uipath.tracing._traced import traced
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._utils import Endpoint, RequestSpec
-from ._base_service import BaseService
-
-
-class FolderService(BaseService):
-    """Service for managing UiPath Folders.
-
-    A folder represents a single area for data organization
-    and access control - it is created when you need to categorize, manage, and enforce authorization rules for a group
-    of UiPath resources (i.e. processes, assets, connections, storage buckets etc.) or other folders
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(name="folder_retrieve_key_by_folder_path", run_type="uipath")
-    @deprecated("Use retrieve_key instead")
-    def retrieve_key_by_folder_path(self, folder_path: str) -> Optional[str]:
-        return self.retrieve_key(folder_path=folder_path)
-
-    @traced(name="folder_retrieve_key", run_type="uipath")
-    def retrieve_key(self, *, folder_path: str) -> Optional[str]:
-        """Retrieve the folder key by folder path with pagination support.
-
-        Args:
-            folder_path: The fully qualified folder path to search for.
-
-        Returns:
-            The folder key if found, None otherwise.
-        """
-        skip = 0
-        take = 20
-
-        while True:
-            spec = self._retrieve_spec(folder_path, skip=skip, take=take)
-            response = self.request(
-                spec.method,
-                url=spec.endpoint,
-                params=spec.params,
-            ).json()
-
-            # Search for the folder in current page
-            folder_key = next(
-                (
-                    item["Key"]
-                    for item in response["PageItems"]
-                    if item["FullyQualifiedName"] == folder_path
-                ),
-                None,
-            )
-
-            if folder_key is not None:
-                return folder_key
-
-            page_items = response["PageItems"]
-            if len(page_items) < take:
-                break
-
-            skip += take
-
-        return None
-
-    def _retrieve_spec(
-        self, folder_path: str, *, skip: int = 0, take: int = 20
-    ) -> RequestSpec:
-        folder_name = folder_path.split("/")[-1]
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint(
-                "orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser"
-            ),
-            params={
-                "searchText": folder_name,
-                "skip": skip,
-                "take": take,
-            },
-        )
diff --git a/src/uipath/_services/processes_service.py b/src/uipath/_services/processes_service.py
deleted file mode 100644
index 14fe580da..000000000
--- a/src/uipath/_services/processes_service.py
+++ /dev/null
@@ -1,171 +0,0 @@
-import json
-import os
-from typing import Any, Dict, Optional
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils.constants import ENV_JOB_ID, HEADER_JOB_KEY
-from ..models.job import Job
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-
-class ProcessesService(FolderContext, BaseService):
-    """Service for managing and executing UiPath automation processes.
-
-    Processes (also known as automations or workflows) are the core units of
-    automation in UiPath, representing sequences of activities that perform
-    specific business tasks.
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(name="processes_invoke", run_type="uipath")
-    @infer_bindings(resource_type="process")
-    def invoke(
-        self,
-        name: str,
-        input_arguments: Optional[Dict[str, Any]] = None,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Job:
-        """Start execution of a process by its name.
-
-        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
-
-        Args:
-            name (str): The name of the process to execute.
-            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-            Job: The job execution details.
-
-        Examples:
-            ```python
-            from uipath import UiPath
-
-            client = UiPath()
-
-            client.processes.invoke(name="MyProcess")
-            ```
-
-            ```python
-            # if you want to execute the process in a specific folder
-            # another one than the one set in the SDK config
-            from uipath import UiPath
-
-            client = UiPath()
-
-            client.processes.invoke(name="MyProcess", folder_path="my-folder-key")
-            ```
-        """
-        spec = self._invoke_spec(
-            name,
-            input_arguments=input_arguments,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        return Job.model_validate(response.json()["value"][0])
-
-    @traced(name="processes_invoke", run_type="uipath")
-    @infer_bindings(resource_type="process")
-    async def invoke_async(
-        self,
-        name: str,
-        input_arguments: Optional[Dict[str, Any]] = None,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> Job:
-        """Asynchronously start execution of a process by its name.
-
-        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
-
-        Args:
-            name (str): The name of the process to execute.
-            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
-            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
-            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
-
-        Returns:
-            Job: The job execution details.
-
-        Examples:
-            ```python
-            import asyncio
-
-            from uipath import UiPath
-
-            sdk = UiPath()
-
-            async def main():
-                job = await sdk.processes.invoke_async("testAppAction")
-                print(job)
-
-            asyncio.run(main())
-            ```
-        """
-        spec = self._invoke_spec(
-            name,
-            input_arguments=input_arguments,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        )
-
-        return Job.model_validate(response.json()["value"][0])
-
-    @property
-    def custom_headers(self) -> Dict[str, str]:
-        return self.folder_headers
-
-    def _invoke_spec(
-        self,
-        name: str,
-        input_arguments: Optional[Dict[str, Any]] = None,
-        *,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> RequestSpec:
-        request_scope = RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-            ),
-            content=str(
-                {
-                    "startInfo": {
-                        "ReleaseName": name,
-                        "InputArguments": json.dumps(input_arguments)
-                        if input_arguments
-                        else "{}",
-                    }
-                }
-            ),
-            headers={
-                **header_folder(folder_key, folder_path),
-            },
-        )
-        job_key = os.environ.get(ENV_JOB_ID, None)
-        if job_key:
-            request_scope.headers[HEADER_JOB_KEY] = job_key
-        return request_scope
diff --git a/src/uipath/_services/queues_service.py b/src/uipath/_services/queues_service.py
deleted file mode 100644
index 2a6e8fb97..000000000
--- a/src/uipath/_services/queues_service.py
+++ /dev/null
@@ -1,348 +0,0 @@
-from typing import Any, Dict, List, Union
-
-from httpx import Response
-
-from .._config import Config
-from .._execution_context import ExecutionContext
-from .._folder_context import FolderContext
-from .._utils import Endpoint, RequestSpec
-from ..models import CommitType, QueueItem, TransactionItem, TransactionItemResult
-from ..tracing._traced import traced
-from ._base_service import BaseService
-
-
-class QueuesService(FolderContext, BaseService):
-    """Service for managing UiPath queues and queue items.
-
-    Queues are a fundamental component of UiPath automation that enable distributed
-    and scalable processing of work items.
-    """
-
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
-        super().__init__(config=config, execution_context=execution_context)
-
-    @traced(name="queues_list_items", run_type="uipath")
-    def list_items(self) -> Response:
-        """Retrieves a list of queue items from the Orchestrator.
-
-        Returns:
-            Response: HTTP response containing the list of queue items.
-        """
-        spec = self._list_items_spec()
-        response = self.request(spec.method, url=spec.endpoint)
-
-        return response.json()
-
-    @traced(name="queues_list_items", run_type="uipath")
-    async def list_items_async(self) -> Response:
-        """Asynchronously retrieves a list of queue items from the Orchestrator.
-
-        Returns:
-            Response: HTTP response containing the list of queue items.
-        """
-        spec = self._list_items_spec()
-        response = await self.request_async(spec.method, url=spec.endpoint)
-        return response.json()
-
-    @traced(name="queues_create_item", run_type="uipath")
-    def create_item(self, item: Union[Dict[str, Any], QueueItem]) -> Response:
-        """Creates a new queue item in the Orchestrator.
-
-        Args:
-            item: Queue item data, either as a dictionary or QueueItem instance.
-
-        Returns:
-            Response: HTTP response containing the created queue item details.
-
-        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
-        """
-        spec = self._create_item_spec(item)
-        response = self.request(spec.method, url=spec.endpoint, json=spec.json)
-        return response.json()
-
-    @traced(name="queues_create_item", run_type="uipath")
-    async def create_item_async(
-        self, item: Union[Dict[str, Any], QueueItem]
-    ) -> Response:
-        """Asynchronously creates a new queue item in the Orchestrator.
-
-        Args:
-            item: Queue item data, either as a dictionary or QueueItem instance.
-
-        Returns:
-            Response: HTTP response containing the created queue item details.
-
-        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
-        """
-        spec = self._create_item_spec(item)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, json=spec.json
-        )
-        return response.json()
-
-    @traced(name="queues_create_items", run_type="uipath")
-    def create_items(
-        self,
-        items: List[Union[Dict[str, Any], QueueItem]],
-        queue_name: str,
-        commit_type: CommitType,
-    ) -> Response:
-        """Creates multiple queue items in bulk.
-
-        Args:
-            items: List of queue items to create, each either a dictionary or QueueItem instance.
-            queue_name: Name of the target queue.
-            commit_type: Type of commit operation to use for the bulk operation.
-
-        Returns:
-            Response: HTTP response containing the bulk operation result.
-        """
-        spec = self._create_items_spec(items, queue_name, commit_type)
-        response = self.request(spec.method, url=spec.endpoint, json=spec.json)
-        return response.json()
-
-    @traced(name="queues_create_items", run_type="uipath")
-    async def create_items_async(
-        self,
-        items: List[Union[Dict[str, Any], QueueItem]],
-        queue_name: str,
-        commit_type: CommitType,
-    ) -> Response:
-        """Asynchronously creates multiple queue items in bulk.
-
-        Args:
-            items: List of queue items to create, each either a dictionary or QueueItem instance.
-            queue_name: Name of the target queue.
-            commit_type: Type of commit operation to use for the bulk operation.
-
-        Returns:
-            Response: HTTP response containing the bulk operation result.
-        """
-        spec = self._create_items_spec(items, queue_name, commit_type)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, json=spec.json
-        )
-        return response.json()
-
-    @traced(name="queues_create_transaction_item", run_type="uipath")
-    def create_transaction_item(
-        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
-    ) -> Response:
-        """Creates a new transaction item in a queue.
-
-        Args:
-            item: Transaction item data, either as a dictionary or TransactionItem instance.
-            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
-
-        Returns:
-            Response: HTTP response containing the transaction item details.
-        """
-        spec = self._create_transaction_item_spec(item, no_robot)
-        response = self.request(spec.method, url=spec.endpoint, json=spec.json)
-        return response.json()
-
-    @traced(name="queues_create_transaction_item", run_type="uipath")
-    async def create_transaction_item_async(
-        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
-    ) -> Response:
-        """Asynchronously creates a new transaction item in a queue.
-
-        Args:
-            item: Transaction item data, either as a dictionary or TransactionItem instance.
-            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
-
-        Returns:
-            Response: HTTP response containing the transaction item details.
-        """
-        spec = self._create_transaction_item_spec(item, no_robot)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, json=spec.json
-        )
-        return response.json()
-
-    @traced(name="queues_update_progress_of_transaction_item", run_type="uipath")
-    def update_progress_of_transaction_item(
-        self, transaction_key: str, progress: str
-    ) -> Response:
-        """Updates the progress of a transaction item.
-
-        Args:
-            transaction_key: Unique identifier of the transaction.
-            progress: Progress message to set.
-
-        Returns:
-            Response: HTTP response confirming the progress update.
-
-        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
-        """
-        spec = self._update_progress_of_transaction_item_spec(transaction_key, progress)
-        response = self.request(spec.method, url=spec.endpoint, json=spec.json)
-        return response.json()
-
-    @traced(name="queues_update_progress_of_transaction_item", run_type="uipath")
-    async def update_progress_of_transaction_item_async(
-        self, transaction_key: str, progress: str
-    ) -> Response:
-        """Asynchronously updates the progress of a transaction item.
-
-        Args:
-            transaction_key: Unique identifier of the transaction.
-            progress: Progress message to set.
-
-        Returns:
-            Response: HTTP response confirming the progress update.
-
-        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
-        """
-        spec = self._update_progress_of_transaction_item_spec(transaction_key, progress)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, json=spec.json
-        )
-        return response.json()
-
-    @traced(name="queues_complete_transaction_item", run_type="uipath")
-    def complete_transaction_item(
-        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
-    ) -> Response:
-        """Completes a transaction item with the specified result.
-
-        Args:
-            transaction_key: Unique identifier of the transaction to complete.
-            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
-
-        Returns:
-            Response: HTTP response confirming the transaction completion.
-
-        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
-        """
-        spec = self._complete_transaction_item_spec(transaction_key, result)
-        response = self.request(spec.method, url=spec.endpoint, json=spec.json)
-        return response.json()
-
-    @traced(name="queues_complete_transaction_item", run_type="uipath")
-    async def complete_transaction_item_async(
-        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
-    ) -> Response:
-        """Asynchronously completes a transaction item with the specified result.
-
-        Args:
-            transaction_key: Unique identifier of the transaction to complete.
-            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
-
-        Returns:
-            Response: HTTP response confirming the transaction completion.
-
-        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
-        """
-        spec = self._complete_transaction_item_spec(transaction_key, result)
-        response = await self.request_async(
-            spec.method, url=spec.endpoint, json=spec.json
-        )
-        return response.json()
-
-    @property
-    def custom_headers(self) -> Dict[str, str]:
-        return self.folder_headers
-
-    def _list_items_spec(self) -> RequestSpec:
-        return RequestSpec(
-            method="GET",
-            endpoint=Endpoint("/orchestrator_/odata/QueueItems"),
-        )
-
-    def _create_item_spec(self, item: Union[Dict[str, Any], QueueItem]) -> RequestSpec:
-        if isinstance(item, dict):
-            queue_item = QueueItem(**item)
-        elif isinstance(item, QueueItem):
-            queue_item = item
-
-        json_payload = {
-            "itemData": queue_item.model_dump(exclude_unset=True, by_alias=True)
-        }
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem"
-            ),
-            json=json_payload,
-        )
-
-    def _create_items_spec(
-        self,
-        items: List[Union[Dict[str, Any], QueueItem]],
-        queue_name: str,
-        commit_type: CommitType,
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Queues/UiPathODataSvc.BulkAddQueueItems"
-            ),
-            json={
-                "queueName": queue_name,
-                "commitType": commit_type.value,
-                "queueItems": [
-                    item.model_dump(exclude_unset=True, by_alias=True)
-                    if isinstance(item, QueueItem)
-                    else QueueItem(**item).model_dump(exclude_unset=True, by_alias=True)
-                    for item in items
-                ],
-            },
-        )
-
-    def _create_transaction_item_spec(
-        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
-    ) -> RequestSpec:
-        if isinstance(item, dict):
-            transaction_item = TransactionItem(**item)
-        elif isinstance(item, TransactionItem):
-            transaction_item = item
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                "/orchestrator_/odata/Queues/UiPathODataSvc.StartTransaction"
-            ),
-            json={
-                "transactionData": {
-                    **transaction_item.model_dump(exclude_unset=True, by_alias=True),
-                    **(
-                        {"RobotIdentifier": self._execution_context.robot_key}
-                        if not no_robot
-                        else {}
-                    ),
-                }
-            },
-        )
-
-    def _update_progress_of_transaction_item_spec(
-        self, transaction_key: str, progress: str
-    ) -> RequestSpec:
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                f"/orchestrator_/odata/QueueItems({transaction_key})/UiPathODataSvc.SetTransactionProgress"
-            ),
-            json={"progress": progress},
-        )
-
-    def _complete_transaction_item_spec(
-        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
-    ) -> RequestSpec:
-        if isinstance(result, dict):
-            transaction_result = TransactionItemResult(**result)
-        elif isinstance(result, TransactionItemResult):
-            transaction_result = result
-
-        return RequestSpec(
-            method="POST",
-            endpoint=Endpoint(
-                f"/orchestrator_/odata/Queues({transaction_key})/UiPathODataSvc.SetTransactionResult"
-            ),
-            json={
-                "transactionResult": transaction_result.model_dump(
-                    exclude_unset=True, by_alias=True
-                )
-            },
-        )
diff --git a/src/uipath/_uipath.py b/src/uipath/_uipath.py
deleted file mode 100644
index b54c286ab..000000000
--- a/src/uipath/_uipath.py
+++ /dev/null
@@ -1,134 +0,0 @@
-from os import environ as env
-from typing import Optional
-
-from dotenv import load_dotenv
-from pydantic import ValidationError
-
-from ._config import Config
-from ._execution_context import ExecutionContext
-from ._services import (
-    ActionsService,
-    ApiClient,
-    AssetsService,
-    AttachmentsService,
-    BucketsService,
-    ConnectionsService,
-    ContextGroundingService,
-    FolderService,
-    JobsService,
-    ProcessesService,
-    QueuesService,
-    UiPathLlmChatService,
-    UiPathOpenAIService,
-)
-from ._utils import setup_logging
-from ._utils.constants import (
-    ENV_BASE_URL,
-    ENV_UIPATH_ACCESS_TOKEN,
-    ENV_UNATTENDED_USER_ACCESS_TOKEN,
-)
-from .models.errors import BaseUrlMissingError, SecretMissingError
-
-load_dotenv(override=True)
-
-
-class UiPath:
-    def __init__(
-        self,
-        *,
-        base_url: Optional[str] = None,
-        secret: Optional[str] = None,
-        debug: bool = False,
-    ) -> None:
-        base_url_value = base_url or env.get(ENV_BASE_URL)
-        secret_value = (
-            secret
-            or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
-            or env.get(ENV_UIPATH_ACCESS_TOKEN)
-        )
-
-        try:
-            self._config = Config(
-                base_url=base_url_value,  # type: ignore
-                secret=secret_value,  # type: ignore
-            )
-        except ValidationError as e:
-            for error in e.errors():
-                if error["loc"][0] == "base_url":
-                    raise BaseUrlMissingError() from e
-                elif error["loc"][0] == "secret":
-                    raise SecretMissingError() from e
-        self._folders_service: Optional[FolderService] = None
-        self._buckets_service: Optional[BucketsService] = None
-
-        setup_logging(debug)
-        self._execution_context = ExecutionContext()
-
-    @property
-    def api_client(self) -> ApiClient:
-        return ApiClient(self._config, self._execution_context)
-
-    @property
-    def assets(self) -> AssetsService:
-        return AssetsService(self._config, self._execution_context)
-
-    @property
-    def attachments(self) -> AttachmentsService:
-        return AttachmentsService(self._config, self._execution_context)
-
-    @property
-    def processes(self) -> ProcessesService:
-        return ProcessesService(self._config, self._execution_context)
-
-    @property
-    def actions(self) -> ActionsService:
-        return ActionsService(self._config, self._execution_context)
-
-    @property
-    def buckets(self) -> BucketsService:
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
-        return BucketsService(self._config, self._execution_context)
-
-    @property
-    def connections(self) -> ConnectionsService:
-        return ConnectionsService(self._config, self._execution_context)
-
-    @property
-    def context_grounding(self) -> ContextGroundingService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
-        return ContextGroundingService(
-            self._config,
-            self._execution_context,
-            self._folders_service,
-            self._buckets_service,
-        )
-
-    @property
-    def queues(self) -> QueuesService:
-        return QueuesService(self._config, self._execution_context)
-
-    @property
-    def jobs(self) -> JobsService:
-        return JobsService(self._config, self._execution_context)
-
-    @property
-    def folders(self) -> FolderService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        return self._folders_service
-
-    @property
-    def llm_openai(self) -> UiPathOpenAIService:
-        return UiPathOpenAIService(self._config, self._execution_context)
-
-    @property
-    def llm(self) -> UiPathLlmChatService:
-        return UiPathLlmChatService(self._config, self._execution_context)
diff --git a/src/uipath/_utils/_infer_bindings.py b/src/uipath/_utils/_infer_bindings.py
deleted file mode 100644
index 9307ff04b..000000000
--- a/src/uipath/_utils/_infer_bindings.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import functools
-import inspect
-from typing import Any, Callable, TypeVar
-
-from ._read_overwrites import read_resource_overwrites
-
-T = TypeVar("T")
-
-
-def infer_bindings(
-    resource_type: str, name: str = "name", folder_path: str = "folder_path"
-) -> Callable[..., Any]:
-    def decorator(func: Callable[..., Any]):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            # convert both args and kwargs to single dict
-            sig = inspect.signature(func)
-            bound = sig.bind_partial(*args, **kwargs)
-            bound.apply_defaults()
-            all_args = dict(bound.arguments)
-
-            if name in all_args or folder_path in all_args:
-                with read_resource_overwrites(
-                    resource_type,
-                    all_args.get(name),  # type: ignore
-                    all_args.get(folder_path, None),
-                ) as (name_overwrite_or_default, folder_path_overwrite_or_default):
-                    all_args[name] = name_overwrite_or_default
-                    all_args[folder_path] = folder_path_overwrite_or_default
-
-            return func(**all_args)
-
-        wrapper._should_infer_bindings = True  # type: ignore
-        wrapper._infer_bindings_mappings = {"name": name, "folder_path": folder_path}  # type: ignore
-        return wrapper
-
-    return decorator
-
-
-def get_inferred_bindings_names(cls: T):
-    inferred_bindings = {}
-    for name, method in inspect.getmembers(cls, inspect.isfunction):
-        if hasattr(method, "_should_infer_bindings") and method._should_infer_bindings:
-            inferred_bindings[name] = method._infer_bindings_mappings  # type: ignore
-
-    return inferred_bindings
diff --git a/src/uipath/_utils/_logs.py b/src/uipath/_utils/_logs.py
deleted file mode 100644
index 0dc83db46..000000000
--- a/src/uipath/_utils/_logs.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import logging
-import sys
-from typing import Optional
-
-logger: logging.Logger = logging.getLogger("uipath")
-
-
-def setup_logging(should_debug: Optional[bool] = None) -> None:
-    logging.basicConfig(
-        format="[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-    )
-    logger.setLevel(logging.DEBUG if should_debug else logging.INFO)
-    logger.removeHandler(logging.StreamHandler(sys.stdout))
-    logger.addHandler(logging.StreamHandler(sys.stderr))
diff --git a/src/uipath/_utils/_read_overwrites.py b/src/uipath/_utils/_read_overwrites.py
deleted file mode 100644
index 7e8eacd80..000000000
--- a/src/uipath/_utils/_read_overwrites.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import json
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Any, Dict, Generator, Optional, Tuple
-
-
-class OverwritesManager:
-    """Manages overwrites for different resource types and methods.
-
-    This class handles reading and accessing bindings overwrites from a JSON file.
-    The overwrites are stored under the 'resourceOverwrites' key, where each key is a
-    resource key (e.g., 'asset.MyAssetKeyFromBindingsJson') and the value contains
-    'name' and 'folderPath' fields.
-
-    This is a singleton class to ensure only one instance exists throughout the application.
-    """
-
-    _instance = None
-    _overwrites_file_path: Path = Path("__uipath/uipath.json")
-    _runtime_overwrites: Dict[str, Any] = {}
-
-    def __new__(
-        cls, overwrites_file_path: Optional[Path] = None
-    ) -> "OverwritesManager":
-        """Create or return the singleton instance.
-
-        Args:
-            overwrites_file_path: Optional path to the overwrites JSON file.
-                If not provided, defaults to 'uipath.json' in the project root.
-
-        Returns:
-            The singleton instance of OverwritesManager.
-        """
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._overwrites_file_path = (
-                overwrites_file_path or cls._overwrites_file_path
-            )
-            cls._instance._read_overwrites_file()
-        elif (
-            overwrites_file_path
-            and overwrites_file_path != cls._instance._overwrites_file_path
-        ):
-            # If a new file path is provided and it's different from the current one,
-            # update the path and re-read the file
-            cls._instance._overwrites_file_path = overwrites_file_path
-            cls._instance._read_overwrites_file()
-        return cls._instance
-
-    def _read_overwrites_file(self) -> None:
-        """Read the overwrites JSON file and cache the data.
-
-        Raises:
-            FileNotFoundError: If the overwrites file doesn't exist.
-            json.JSONDecodeError: If the file contains invalid JSON.
-        """
-        try:
-            with open(self._overwrites_file_path, "r") as f:
-                data = json.load(f)
-                self._runtime_overwrites = (
-                    data.get("runtime", {})
-                    .get("internalArguments", {})
-                    .get("resourceOverwrites", {})
-                )
-        except FileNotFoundError:
-            self._runtime_overwrites = {}
-
-    def get_overwrite(
-        self, resource_type: str, resource_name: str, folder_path: Optional[str] = None
-    ) -> Optional[Tuple[str, str]]:
-        """Get an overwrite value for a specific resource.
-
-        Args:
-            resource_type: The type of resource (e.g., 'process', 'asset').
-            resource_name: The name of the resource.
-
-        Returns:
-            A tuple of (name, folder_path) if found, None otherwise.
-        """
-        if folder_path:
-            key = f"{resource_type}.{resource_name}.{folder_path}"
-        else:
-            key = f"{resource_type}.{resource_name}"
-
-        if key not in self._runtime_overwrites:
-            return None
-
-        overwrite = self._runtime_overwrites[key]
-        return (
-            overwrite.get("name", resource_name),
-            overwrite.get("folderPath", ""),
-        )
-
-    def get_and_apply_overwrite(
-        self, resource_type: str, resource_name: str, folder_path: Optional[str] = None
-    ) -> Tuple[Any, Any]:
-        """Get and apply overwrites for a resource, falling back to provided values if no overwrites exist.
-
-        Args:
-            resource_type: The type of resource (e.g., 'process', 'asset').
-            resource_name: The name of the resource.
-            folder_path: Optional folder path to use if no overwrite exists.
-
-        Returns:
-            A tuple of (name, folder_path) with overwritten values if available,
-            otherwise the original values.
-        """
-        overwrite = self.get_overwrite(resource_type, resource_name, folder_path)
-        if overwrite:
-            resource_name, folder_path = overwrite
-        return resource_name, folder_path or None
-
-
-@contextmanager
-def read_resource_overwrites(
-    resource_type: str,
-    resource_name: str,
-    folder_path: Optional[str] = None,
-    overwrites_file_path: Optional[Path] = None,
-) -> Generator[Tuple[str, str], None, None]:
-    """Context manager for reading and applying resource overwrites.
-
-    Args:
-        resource_type: The type of resource (e.g., 'process', 'asset').
-        resource_name: The name of the resource.
-        folder_path: Optional folder path to use if no overwrite exists.
-        overwrites_file_path: Optional path to the overwrites JSON file.
-
-    Yields:
-        A tuple of (name, folder_path) with overwritten values if available,
-        otherwise the original values.
-
-    Example:
-        ```python
-        with read_resource_overwrites("asset", "MyAsset") as (name, folder_path):
-            # Use name and folder_path here
-            pass
-        ```
-    """
-    manager = OverwritesManager(overwrites_file_path)
-    try:
-        yield manager.get_and_apply_overwrite(resource_type, resource_name, folder_path)
-    finally:
-        pass
diff --git a/src/uipath/_utils/_request_override.py b/src/uipath/_utils/_request_override.py
deleted file mode 100644
index c93beec4f..000000000
--- a/src/uipath/_utils/_request_override.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from typing import Optional
-
-from .constants import HEADER_FOLDER_KEY, HEADER_FOLDER_PATH
-
-
-def header_folder(
-    folder_key: Optional[str], folder_path: Optional[str]
-) -> dict[str, str]:
-    if folder_key is not None and folder_path is not None:
-        raise ValueError("Only one of folder_key or folder_path can be provided")
-
-    headers = {}
-    if folder_key is not None and folder_key != "":
-        headers[HEADER_FOLDER_KEY] = folder_key
-    if folder_path is not None and folder_path != "":
-        headers[HEADER_FOLDER_PATH] = folder_path
-
-    return headers
diff --git a/src/uipath/_utils/constants.py b/src/uipath/_utils/constants.py
deleted file mode 100644
index 6050d4e22..000000000
--- a/src/uipath/_utils/constants.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# Environment variables
-ENV_BASE_URL = "UIPATH_URL"
-ENV_UNATTENDED_USER_ACCESS_TOKEN = "UNATTENDED_USER_ACCESS_TOKEN"
-ENV_UIPATH_ACCESS_TOKEN = "UIPATH_ACCESS_TOKEN"
-ENV_FOLDER_KEY = "UIPATH_FOLDER_KEY"
-ENV_FOLDER_PATH = "UIPATH_FOLDER_PATH"
-ENV_JOB_KEY = "UIPATH_JOB_KEY"
-ENV_JOB_ID = "UIPATH_JOB_ID"
-ENV_ROBOT_KEY = "UIPATH_ROBOT_KEY"
-ENV_TENANT_ID = "UIPATH_TENANT_ID"
-ENV_ORGANIZATION_ID = "UIPATH_ORGANIZATION_ID"
-ENV_TELEMETRY_ENABLED = "UIPATH_TELEMETRY_ENABLED"
-
-# Headers
-HEADER_FOLDER_KEY = "x-uipath-folderkey"
-HEADER_FOLDER_PATH = "x-uipath-folderpath"
-HEADER_USER_AGENT = "x-uipath-user-agent"
-HEADER_TENANT_ID = "x-uipath-tenantid"
-HEADER_JOB_KEY = "x-uipath-jobkey"
-
-# Data sources
-ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (
-    "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
-)
-
-# Local storage
-TEMP_ATTACHMENTS_FOLDER = "uipath_attachments"
diff --git a/src/uipath/models/__init__.py b/src/uipath/models/__init__.py
deleted file mode 100644
index cf6a34ded..000000000
--- a/src/uipath/models/__init__.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from .action_schema import ActionSchema
-from .actions import Action
-from .assets import Asset, UserAsset
-from .attachment import Attachment
-from .buckets import Bucket
-from .connections import Connection, ConnectionToken
-from .context_grounding import ContextGroundingQueryResponse
-from .context_grounding_index import ContextGroundingIndex
-from .errors import BaseUrlMissingError, SecretMissingError
-from .exceptions import IngestionInProgressException
-from .interrupt_models import (
-    CreateAction,
-    InvokeProcess,
-    WaitAction,
-    WaitJob,
-)
-from .job import Job
-from .processes import Process
-from .queues import (
-    CommitType,
-    QueueItem,
-    QueueItemPriority,
-    TransactionItem,
-    TransactionItemResult,
-)
-
-__all__ = [
-    "Action",
-    "Asset",
-    "Attachment",
-    "UserAsset",
-    "ContextGroundingQueryResponse",
-    "ContextGroundingIndex",
-    "Process",
-    "QueueItem",
-    "CommitType",
-    "TransactionItem",
-    "QueueItemPriority",
-    "TransactionItemResult",
-    "Connection",
-    "ConnectionToken",
-    "Job",
-    "InvokeProcess",
-    "ActionSchema",
-    "WaitJob",
-    "WaitAction",
-    "CreateAction",
-    "IngestionInProgressException",
-    "BaseUrlMissingError",
-    "SecretMissingError",
-    "Bucket",
-]
diff --git a/src/uipath/models/buckets.py b/src/uipath/models/buckets.py
deleted file mode 100644
index f789ca0ea..000000000
--- a/src/uipath/models/buckets.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class Bucket(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-    )
-    name: str = Field(alias="Name")
-    description: Optional[str] = Field(default=None, alias="Description")
-    identifier: str = Field(alias="Identifier")
-    storage_provider: Optional[str] = Field(default=None, alias="StorageProvider")
-    storage_parameters: Optional[str] = Field(default=None, alias="StorageParameters")
-    storage_container: Optional[str] = Field(default=None, alias="StorageContainer")
-    options: Optional[str] = Field(default=None, alias="Options")
-    credential_store_id: Optional[str] = Field(default=None, alias="CredentialStoreId")
-    external_name: Optional[str] = Field(default=None, alias="ExternalName")
-    password: Optional[str] = Field(default=None, alias="Password")
-    folders_count: Optional[int] = Field(default=None, alias="FoldersCount")
-    encrypted: Optional[bool] = Field(default=None, alias="Encrypted")
-    id: Optional[int] = Field(default=None, alias="Id")
-    tags: Optional[List[str]] = Field(default=None, alias="Tags")
diff --git a/src/uipath/models/connections.py b/src/uipath/models/connections.py
deleted file mode 100644
index 5eda068b4..000000000
--- a/src/uipath/models/connections.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from datetime import datetime
-from typing import Any, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class Connection(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-
-    id: Optional[str] = None
-    name: Optional[str] = None
-    owner: Optional[str] = None
-    create_time: Optional[str] = Field(default=None, alias="createTime")
-    update_time: Optional[str] = Field(default=None, alias="updateTime")
-    state: Optional[str] = None
-    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
-    element_instance_id: int = Field(alias="elementInstanceId")
-    connector: Optional[Any] = None
-    is_default: Optional[bool] = Field(default=None, alias="isDefault")
-    last_used_time: Optional[str] = Field(default=None, alias="lastUsedTime")
-    connection_identity: Optional[str] = Field(default=None, alias="connectionIdentity")
-    polling_interval_in_minutes: Optional[int] = Field(
-        default=None, alias="pollingIntervalInMinutes"
-    )
-    folder: Optional[Any] = None
-    element_version: Optional[str] = Field(default=None, alias="elementVersion")
-
-
-class ConnectionToken(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-
-    access_token: str = Field(alias="accessToken")
-    token_type: Optional[str] = Field(default=None, alias="tokenType")
-    scope: Optional[str] = None
-    expires_in: Optional[int] = Field(default=None, alias="expiresIn")
-    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
-    element_instance_id: Optional[int] = Field(default=None, alias="elementInstanceId")
diff --git a/src/uipath/models/context_grounding.py b/src/uipath/models/context_grounding.py
deleted file mode 100644
index a550b1b92..000000000
--- a/src/uipath/models/context_grounding.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ContextGroundingMetadata(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-    operation_id: str = Field(alias="operation_id")
-    strategy: str = Field(alias="strategy")
-
-
-class ContextGroundingQueryResponse(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-    source: str = Field(alias="source")
-    page_number: str = Field(alias="page_number")
-    content: str = Field(alias="content")
-    metadata: ContextGroundingMetadata = Field(alias="metadata")
-    source_document_id: Optional[str] = Field(default=None, alias="source_document_id")
-    caption: Optional[str] = Field(default=None, alias="caption")
-    score: Optional[float] = Field(default=None, alias="score")
-    reference: Optional[str] = Field(default=None, alias="reference")
diff --git a/src/uipath/models/context_grounding_index.py b/src/uipath/models/context_grounding_index.py
deleted file mode 100644
index 0dcbc41c1..000000000
--- a/src/uipath/models/context_grounding_index.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from datetime import datetime
-from typing import Any, List, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ContextGroundingField(BaseModel):
-    id: Optional[str] = Field(default=None, alias="id")
-    name: Optional[str] = Field(default=None, alias="name")
-    description: Optional[str] = Field(default=None, alias="description")
-    type: Optional[str] = Field(default=None, alias="type")
-    is_filterable: Optional[bool] = Field(default=None, alias="isFilterable")
-    searchable_type: Optional[str] = Field(default=None, alias="searchableType")
-    is_user_defined: Optional[bool] = Field(default=None, alias="isUserDefined")
-
-
-class ContextGroundingDataSource(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-    id: Optional[str] = Field(default=None, alias="id")
-    folder: Optional[str] = Field(default=None, alias="folder")
-    bucketName: Optional[str] = Field(default=None, alias="bucketName")
-
-
-class ContextGroundingIndex(BaseModel):
-    model_config = ConfigDict(
-        validate_by_name=True,
-        validate_by_alias=True,
-        use_enum_values=True,
-        arbitrary_types_allowed=True,
-        extra="allow",
-        json_encoders={datetime: lambda v: v.isoformat() if v else None},
-    )
-    id: Optional[str] = Field(default=None, alias="id")
-    name: Optional[str] = Field(default=None, alias="name")
-    description: Optional[str] = Field(default=None, alias="description")
-    memory_usage: Optional[int] = Field(default=None, alias="memoryUsage")
-    disk_usage: Optional[int] = Field(default=None, alias="diskUsage")
-    data_source: Optional[ContextGroundingDataSource] = Field(
-        default=None, alias="dataSource"
-    )
-    pre_processing: Any = Field(default=None, alias="preProcessing")
-    fields: Optional[List[ContextGroundingField]] = Field(default=None, alias="fields")
-    last_ingestion_status: Optional[str] = Field(
-        default=None, alias="lastIngestionStatus"
-    )
-    last_ingested: Optional[datetime] = Field(default=None, alias="lastIngested")
-    last_queried: Optional[datetime] = Field(default=None, alias="lastQueried")
-    folder_key: Optional[str] = Field(default=None, alias="folderKey")
-
-    def in_progress_ingestion(self):
-        return (
-            self.last_ingestion_status == "Queued"
-            or self.last_ingestion_status == "In Progress"
-        )
diff --git a/src/uipath/models/errors.py b/src/uipath/models/errors.py
deleted file mode 100644
index ecf5eca18..000000000
--- a/src/uipath/models/errors.py
+++ /dev/null
@@ -1,16 +0,0 @@
-class BaseUrlMissingError(Exception):
-    def __init__(
-        self,
-        message="Authentication required. Please run \033[1muipath auth\033[22m.",
-    ):
-        self.message = message
-        super().__init__(self.message)
-
-
-class SecretMissingError(Exception):
-    def __init__(
-        self,
-        message="Authentication required. Please run \033[1muipath auth\033[22m.",
-    ):
-        self.message = message
-        super().__init__(self.message)
diff --git a/src/uipath/models/exceptions.py b/src/uipath/models/exceptions.py
deleted file mode 100644
index 607bdcfe9..000000000
--- a/src/uipath/models/exceptions.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from typing import Optional
-
-from httpx import HTTPStatusError
-
-
-class IngestionInProgressException(Exception):
-    """An exception that is triggered when a search is attempted on an index that is currently undergoing ingestion."""
-
-    def __init__(self, index_name: Optional[str], search_operation: bool = True):
-        index_name = index_name or "Unknown index name"
-        if search_operation:
-            self.message = f"index '{index_name}' cannot be searched during ingestion"
-        else:
-            self.message = f"index '{index_name}' is currently queued for ingestion"
-        super().__init__(self.message)
-
-
-class EnrichedException(Exception):
-    def __init__(self, error: HTTPStatusError) -> None:
-        # Extract the relevant details from the HTTPStatusError
-        status_code = error.response.status_code if error.response else "Unknown"
-        url = str(error.request.url) if error.request else "Unknown"
-        response_content = (
-            error.response.content.decode("utf-8")
-            if error.response and error.response.content
-            else "No content"
-        )
-
-        enriched_message = (
-            f"\nRequest URL: {url}"
-            f"\nStatus Code: {status_code}"
-            f"\nResponse Content: {response_content}"
-        )
-
-        # Initialize the parent Exception class with the formatted message
-        super().__init__(enriched_message)
diff --git a/src/uipath/models/interrupt_models.py b/src/uipath/models/interrupt_models.py
deleted file mode 100644
index 8ca4b030d..000000000
--- a/src/uipath/models/interrupt_models.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-from .actions import Action
-from .job import Job
-
-
-class InvokeProcess(BaseModel):
-    name: str
-    process_folder_path: Optional[str] = None
-    process_folder_key: Optional[str] = None
-    input_arguments: Optional[Dict[str, Any]]
-
-
-class WaitJob(BaseModel):
-    job: Job
-    process_folder_path: Optional[str] = None
-    process_folder_key: Optional[str] = None
-
-
-class CreateAction(BaseModel):
-    title: str
-    data: Optional[Dict[str, Any]] = None
-    assignee: Optional[str] = ""
-    app_name: Optional[str] = None
-    app_folder_path: Optional[str] = None
-    app_folder_key: Optional[str] = None
-    app_key: Optional[str] = None
-    app_version: Optional[int] = 1
-
-
-class WaitAction(BaseModel):
-    action: Action
-    app_folder_path: Optional[str] = None
-    app_folder_key: Optional[str] = None
diff --git a/src/uipath/telemetry/__init__.py b/src/uipath/telemetry/__init__.py
deleted file mode 100644
index 9cdb01537..000000000
--- a/src/uipath/telemetry/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from ._track import track  # noqa: D104
-
-__all__ = ["track"]
diff --git a/src/uipath/telemetry/_track.py b/src/uipath/telemetry/_track.py
deleted file mode 100644
index aa404303e..000000000
--- a/src/uipath/telemetry/_track.py
+++ /dev/null
@@ -1,130 +0,0 @@
-import os
-from functools import wraps
-from importlib.metadata import version
-from logging import INFO, LogRecord, getLogger
-from typing import Any, Callable, Dict, Optional, Union
-
-from azure.monitor.opentelemetry import configure_azure_monitor
-from opentelemetry.sdk._logs import LoggingHandler
-from opentelemetry.util.types import Attributes
-
-from .._utils.constants import (
-    ENV_BASE_URL,
-    ENV_ORGANIZATION_ID,
-    ENV_TELEMETRY_ENABLED,
-    ENV_TENANT_ID,
-)
-from ._constants import (
-    _APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE,
-    _APP_NAME,
-    _CLOUD_ORG_ID,
-    _CLOUD_TENANT_ID,
-    _CLOUD_URL,
-    _CODE_FILEPATH,
-    _CODE_FUNCTION,
-    _CODE_LINENO,
-    _CONNECTION_STRING,
-    _OTEL_RESOURCE_ATTRIBUTES,
-    _SDK_VERSION,
-    _UNKNOWN,
-)
-
-_logger = getLogger(__name__)
-_logger.propagate = False
-
-
-class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
-    @staticmethod
-    def _get_attributes(record: LogRecord) -> Attributes:
-        attributes = dict(LoggingHandler._get_attributes(record) or {})
-        attributes[_APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE] = True
-        attributes[_CLOUD_TENANT_ID] = os.getenv(ENV_TENANT_ID, _UNKNOWN)
-        attributes[_CLOUD_ORG_ID] = os.getenv(ENV_ORGANIZATION_ID, _UNKNOWN)
-        attributes[_CLOUD_URL] = os.getenv(ENV_BASE_URL, _UNKNOWN)
-        attributes[_APP_NAME] = "UiPath.Sdk"
-        attributes[_SDK_VERSION] = version("uipath")
-
-        if _CODE_FILEPATH in attributes:
-            del attributes[_CODE_FILEPATH]
-        if _CODE_FUNCTION in attributes:
-            del attributes[_CODE_FUNCTION]
-        if _CODE_LINENO in attributes:
-            del attributes[_CODE_LINENO]
-
-        return attributes
-
-
-class _TelemetryClient:
-    """A class to handle telemetry."""
-
-    _initialized = False
-    _enabled = os.getenv(ENV_TELEMETRY_ENABLED, "true").lower() == "true"
-
-    @staticmethod
-    def _initialize():
-        """Initialize the telemetry client."""
-        if _TelemetryClient._initialized or not _TelemetryClient._enabled:
-            return
-
-        try:
-            os.environ[_OTEL_RESOURCE_ATTRIBUTES] = (
-                "service.name=uipath-sdk,service.instance.id=" + version("uipath")
-            )
-            os.environ["OTEL_TRACES_EXPORTER"] = "none"
-
-            configure_azure_monitor(
-                connection_string=_CONNECTION_STRING,
-                disable_offline_storage=True,
-            )
-
-            _logger.addHandler(_AzureMonitorOpenTelemetryEventHandler())
-            _logger.setLevel(INFO)
-
-            _TelemetryClient._initialized = True
-        except Exception:
-            pass
-
-    @staticmethod
-    def _track_method(name: str, attrs: Optional[Dict[str, Any]] = None):
-        """Track function invocations."""
-        if not _TelemetryClient._enabled:
-            return
-
-        _TelemetryClient._initialize()
-
-        _logger.info(f"Sdk.{name.capitalize()}", extra=attrs)
-
-
-def track(
-    name_or_func: Optional[Union[str, Callable[..., Any]]] = None,
-    *,
-    when: Optional[Union[bool, Callable[..., bool]]] = True,
-    extra: Optional[Dict[str, Any]] = None,
-):
-    """Decorator that will trace function invocations.
-
-    Args:
-        name_or_func: The name of the event to track or the function itself.
-        extra: Extra attributes to add to the telemetry event.
-    """
-
-    def decorator(func: Callable[..., Any]):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            event_name = (
-                name_or_func if isinstance(name_or_func, str) else func.__name__
-            )
-
-            should_track = when(*args, **kwargs) if callable(when) else when
-
-            if should_track:
-                _TelemetryClient._track_method(event_name, extra)
-
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    if callable(name_or_func):
-        return decorator(name_or_func)
-
-    return decorator
diff --git a/src/uipath/tracing/__init__.py b/src/uipath/tracing/__init__.py
deleted file mode 100644
index be604b196..000000000
--- a/src/uipath/tracing/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from ._otel_exporters import LlmOpsHttpExporter  # noqa: D104
-from ._traced import TracingManager, traced, wait_for_tracers  # noqa: D104
-
-__all__ = ["TracingManager", "traced", "wait_for_tracers", "LlmOpsHttpExporter"]
diff --git a/src/uipath/tracing/_otel_exporters.py b/src/uipath/tracing/_otel_exporters.py
deleted file mode 100644
index b6462abb9..000000000
--- a/src/uipath/tracing/_otel_exporters.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import json
-import logging
-import os
-import time
-from typing import Any, Dict, Sequence
-
-import httpx
-from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import (
-    SpanExporter,
-    SpanExportResult,
-)
-
-from uipath._utils._ssl_context import get_httpx_client_kwargs
-
-from ._utils import _SpanUtils
-
-logger = logging.getLogger(__name__)
-
-
-class LlmOpsHttpExporter(SpanExporter):
-    """An OpenTelemetry span exporter that sends spans to UiPath LLM Ops."""
-
-    def __init__(self, **client_kwargs):
-        """Initialize the exporter with the base URL and authentication token."""
-        super().__init__(**client_kwargs)
-        self.base_url = self._get_base_url()
-        self.auth_token = os.environ.get("UIPATH_ACCESS_TOKEN")
-        self.headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.auth_token}",
-        }
-
-        client_kwargs = get_httpx_client_kwargs()
-
-        self.http_client = httpx.Client(**client_kwargs, headers=self.headers)
-
-    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
-        """Export spans to UiPath LLM Ops."""
-        logger.debug(
-            f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
-        )
-
-        span_list = [
-            _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
-        ]
-        url = self._build_url(span_list)
-
-        logger.debug("Payload: %s", json.dumps(span_list))
-
-        return self._send_with_retries(url, span_list)
-
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush the exporter."""
-        return True
-
-    def _build_url(self, span_list: list[Dict[str, Any]]) -> str:
-        """Construct the URL for the API request."""
-        trace_id = str(span_list[0]["TraceId"])
-        return f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"
-
-    def _send_with_retries(
-        self, url: str, payload: list[Dict[str, Any]], max_retries: int = 4
-    ) -> SpanExportResult:
-        """Send the HTTP request with retry logic."""
-        for attempt in range(max_retries):
-            try:
-                response = self.http_client.post(url, json=payload)
-                if response.status_code == 200:
-                    return SpanExportResult.SUCCESS
-                else:
-                    logger.warning(
-                        f"Attempt {attempt + 1} failed with status code {response.status_code}: {response.text}"
-                    )
-            except Exception as e:
-                logger.error(f"Attempt {attempt + 1} failed with exception: {e}")
-
-            if attempt < max_retries - 1:
-                time.sleep(1.5**attempt)  # Exponential backoff
-
-        return SpanExportResult.FAILURE
-
-    def _get_base_url(self) -> str:
-        uipath_url = (
-            os.environ.get("UIPATH_URL")
-            or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
-        )
-
-        uipath_url = uipath_url.rstrip("/")
-
-        return uipath_url
diff --git a/src/uipath/tracing/_traced.py b/src/uipath/tracing/_traced.py
deleted file mode 100644
index 92bc768b0..000000000
--- a/src/uipath/tracing/_traced.py
+++ /dev/null
@@ -1,445 +0,0 @@
-import importlib
-import inspect
-import json
-import logging
-from functools import wraps
-from typing import Any, Callable, List, Optional, Tuple
-
-from opentelemetry import trace
-
-from ._utils import _SpanUtils
-
-logger = logging.getLogger(__name__)
-
-_tracer_instance: Optional[trace.Tracer] = None
-
-
-def get_tracer() -> trace.Tracer:
-    """Lazily initializes and returns the tracer instance."""
-    global _tracer_instance
-    if _tracer_instance is None:
-        logger.warning(
-            "Initializing tracer instance. This should only be done once per process."
-        )
-        _tracer_instance = trace.get_tracer(__name__)
-    return _tracer_instance
-
-
-class TracingManager:
-    """Static utility class to manage tracing implementations and decorated functions."""
-
-    # Registry to track original functions, decorated functions, and their parameters
-    # Each entry is (original_func, decorated_func, params)
-    _traced_registry: List[Tuple[Callable[..., Any], Callable[..., Any], Any]] = []
-
-    # Custom tracer implementation
-    _custom_tracer_implementation = None  # Custom span provider function
-    _current_span_provider: Optional[Callable[[], Any]] = None
-
-    @classmethod
-    def get_custom_tracer_implementation(cls):
-        """Get the currently set custom tracer implementation."""
-        return cls._custom_tracer_implementation
-
-    @classmethod
-    def register_current_span_provider(
-        cls, current_span_provider: Optional[Callable[[], Any]]
-    ):
-        """Register a custom current span provider function.
-
-        Args:
-            current_span_provider: A function that returns the current span from an external
-                                 tracing framework. If None, no custom span parenting will be used.
-        """
-        cls._current_span_provider = current_span_provider
-
-    @classmethod
-    def get_parent_context(cls):
-        """Get the parent context using the registered current span provider.
-
-        Returns:
-            Context object with the current span set, or None if no provider is registered.
-        """
-        if cls._current_span_provider is not None:
-            try:
-                current_span = cls._current_span_provider()
-                if current_span is not None:
-                    from opentelemetry.trace import set_span_in_context
-
-                    return set_span_in_context(current_span)
-            except Exception as e:
-                logger.warning(f"Error getting current span from provider: {e}")
-                return None
-        return None
-
-    @classmethod
-    def register_traced_function(cls, original_func, decorated_func, params):
-        """Register a function decorated with @traced and its parameters.
-
-        Args:
-            original_func: The original function before decoration
-            decorated_func: The function after decoration
-            params: The parameters used for tracing
-        """
-        cls._traced_registry.append((original_func, decorated_func, params))
-
-    @classmethod
-    def reapply_traced_decorator(cls, tracer_implementation):
-        """Reapply a different tracer implementation to all functions previously decorated with @traced.
-
-        Args:
-            tracer_implementation: A function that takes the same parameters as _opentelemetry_traced
-                                 and returns a decorator. If None, reverts to default implementation.
-        """
-        tracer_implementation = tracer_implementation or _opentelemetry_traced
-        cls._custom_tracer_implementation = tracer_implementation
-
-        # Work with a copy of the registry to avoid modifying it during iteration
-        registry_copy = cls._traced_registry.copy()
-
-        for original_func, decorated_func, params in registry_copy:
-            # Apply the new decorator with the same parameters
-            supported_params = _get_supported_params(tracer_implementation, params)
-            new_decorated_func = tracer_implementation(**supported_params)(
-                original_func
-            )
-
-            logger.debug(
-                f"Reapplying decorator to {original_func.__name__}, from {decorated_func.__name__}"
-            )
-
-            # If this is a method on a class, we need to update the class
-            if hasattr(original_func, "__self__") and hasattr(
-                original_func, "__func__"
-            ):
-                setattr(
-                    original_func.__self__.__class__,
-                    original_func.__name__,
-                    new_decorated_func.__get__(
-                        original_func.__self__, original_func.__self__.__class__
-                    ),
-                )
-            else:
-                # Replace the function in its module
-                if hasattr(original_func, "__module__") and hasattr(
-                    original_func, "__qualname__"
-                ):
-                    try:
-                        module = importlib.import_module(original_func.__module__)
-                        parts = original_func.__qualname__.split(".")
-
-                        # Handle nested objects
-                        obj = module
-                        for part in parts[:-1]:
-                            obj = getattr(obj, part)
-
-                        setattr(obj, parts[-1], new_decorated_func)
-
-                        # Update the registry entry for this function
-                        # Find the index and replace with updated entry
-                        for i, (orig, _dec, _p) in enumerate(cls._traced_registry):
-                            if orig is original_func:
-                                cls._traced_registry[i] = (
-                                    original_func,
-                                    new_decorated_func,
-                                    params,
-                                )
-                                break
-                    except (ImportError, AttributeError) as e:
-                        # Log the error but continue processing other functions
-                        logger.warning(f"Error reapplying decorator: {e}")
-                        continue
-
-
-def _default_input_processor(inputs):
-    """Default input processor that doesn't log any actual input data."""
-    return {"redacted": "Input data not logged for privacy/security"}
-
-
-def _default_output_processor(outputs):
-    """Default output processor that doesn't log any actual output data."""
-    return {"redacted": "Output data not logged for privacy/security"}
-
-
-def wait_for_tracers():
-    """Wait for all tracers to finish."""
-    trace.get_tracer_provider().shutdown()  # type: ignore
-
-
-def _opentelemetry_traced(
-    name: Optional[str] = None,
-    run_type: Optional[str] = None,
-    span_type: Optional[str] = None,
-    input_processor: Optional[Callable[..., Any]] = None,
-    output_processor: Optional[Callable[..., Any]] = None,
-):
-    """Default tracer implementation using OpenTelemetry."""
-
-    def decorator(func):
-        trace_name = name if name is not None else func.__name__
-
-        @wraps(func)
-        def sync_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_sync"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
-                if run_type is not None:
-                    span.set_attribute("run_type", run_type)
-
-                # Format arguments for tracing
-                inputs = _SpanUtils.format_args_for_trace_json(
-                    inspect.signature(func), *args, **kwargs
-                )
-                # Apply input processor if provided
-                if input_processor is not None:
-                    processed_inputs = input_processor(json.loads(inputs))
-                    inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
-                try:
-                    result = func(*args, **kwargs)
-                    # Process output if processor is provided
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
-
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_async"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
-                if run_type is not None:
-                    span.set_attribute("run_type", run_type)
-
-                # Format arguments for tracing
-                inputs = _SpanUtils.format_args_for_trace_json(
-                    inspect.signature(func), *args, **kwargs
-                )
-                # Apply input processor if provided
-                if input_processor is not None:
-                    processed_inputs = input_processor(json.loads(inputs))
-                    inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
-                try:
-                    result = await func(*args, **kwargs)
-                    # Process output if processor is provided
-                    output = result
-                    if output_processor is not None:
-                        output = output_processor(result)
-                    span.set_attribute("output", json.dumps(output, default=str))
-                    return result
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
-
-        @wraps(func)
-        def generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                span.get_span_context()
-                default_span_type = "function_call_generator_sync"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
-                if run_type is not None:
-                    span.set_attribute("run_type", run_type)
-
-                # Format arguments for tracing
-                inputs = _SpanUtils.format_args_for_trace_json(
-                    inspect.signature(func), *args, **kwargs
-                )
-                # Apply input processor if provided
-                if input_processor is not None:
-                    processed_inputs = input_processor(json.loads(inputs))
-                    inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
-                outputs = []
-                try:
-                    for item in func(*args, **kwargs):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
-
-        @wraps(func)
-        async def async_generator_wrapper(*args, **kwargs):
-            context = TracingManager.get_parent_context()
-
-            with get_tracer().start_as_current_span(
-                trace_name, context=context
-            ) as span:
-                default_span_type = "function_call_generator_async"
-                span.set_attribute(
-                    "span_type",
-                    span_type if span_type is not None else default_span_type,
-                )
-                if run_type is not None:
-                    span.set_attribute("run_type", run_type)
-
-                # Format arguments for tracing
-                inputs = _SpanUtils.format_args_for_trace_json(
-                    inspect.signature(func), *args, **kwargs
-                )
-                # Apply input processor if provided
-                if input_processor is not None:
-                    processed_inputs = input_processor(json.loads(inputs))
-                    inputs = json.dumps(processed_inputs, default=str)
-                span.set_attribute("inputs", inputs)
-                outputs = []
-                try:
-                    async for item in func(*args, **kwargs):
-                        outputs.append(item)
-                        span.add_event(f"Yielded: {item}")  # Add event for each yield
-                        yield item
-
-                    # Process output if processor is provided
-                    output_to_record = outputs
-                    if output_processor is not None:
-                        output_to_record = output_processor(outputs)
-                    span.set_attribute(
-                        "output", json.dumps(output_to_record, default=str)
-                    )
-                except Exception as e:
-                    span.record_exception(e)
-                    span.set_status(
-                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
-                    )
-                    raise
-
-        if inspect.iscoroutinefunction(func):
-            return async_wrapper
-        elif inspect.isgeneratorfunction(func):
-            return generator_wrapper
-        elif inspect.isasyncgenfunction(func):
-            return async_generator_wrapper
-        else:
-            return sync_wrapper
-
-    return decorator
-
-
-def _get_supported_params(tracer_impl, params):
-    """Extract the parameters supported by the tracer implementation.
-
-    Args:
-        tracer_impl: The tracer implementation function or callable
-        params: Dictionary of parameters to check
-
-    Returns:
-        Dictionary containing only parameters supported by the tracer implementation
-    """
-    supported_params = {}
-    if hasattr(tracer_impl, "__code__"):
-        # For regular functions
-        impl_signature = inspect.signature(tracer_impl)
-        for param_name, param_value in params.items():
-            if param_name in impl_signature.parameters and param_value is not None:
-                supported_params[param_name] = param_value
-    elif callable(tracer_impl):
-        # For callable objects
-        impl_signature = inspect.signature(tracer_impl.__call__)
-        for param_name, param_value in params.items():
-            if param_name in impl_signature.parameters and param_value is not None:
-                supported_params[param_name] = param_value
-    else:
-        # If we can't inspect, pass all parameters and let the function handle it
-        supported_params = params
-
-    return supported_params
-
-
-def traced(
-    name: Optional[str] = None,
-    run_type: Optional[str] = None,
-    span_type: Optional[str] = None,
-    input_processor: Optional[Callable[..., Any]] = None,
-    output_processor: Optional[Callable[..., Any]] = None,
-    hide_input: bool = False,
-    hide_output: bool = False,
-):
-    """Decorator that will trace function invocations.
-
-    Args:
-        run_type: Optional string to categorize the run type
-        span_type: Optional string to categorize the span type
-        input_processor: Optional function to process function inputs before recording
-            Should accept a dictionary of inputs and return a processed dictionary
-        output_processor: Optional function to process function outputs before recording
-            Should accept the function output and return a processed value
-        hide_input: If True, don't log any input data
-        hide_output: If True, don't log any output data
-    """
-    # Apply default processors selectively based on hide flags
-    if hide_input:
-        input_processor = _default_input_processor
-    if hide_output:
-        output_processor = _default_output_processor
-
-    # Store the parameters for later reapplication
-    params = {
-        "name": name,
-        "run_type": run_type,
-        "span_type": span_type,
-        "input_processor": input_processor,
-        "output_processor": output_processor,
-    }
-
-    # Check for custom implementation first
-    custom_implementation = TracingManager.get_custom_tracer_implementation()
-    tracer_impl: Any = (
-        custom_implementation if custom_implementation else _opentelemetry_traced
-    )
-
-    def decorator(func):
-        # Check which parameters are supported by the tracer_impl
-        supported_params = _get_supported_params(tracer_impl, params)
-
-        # Decorate the function with only supported parameters
-        decorated_func = tracer_impl(**supported_params)(func)
-
-        # Register both original and decorated function with parameters
-        TracingManager.register_traced_function(func, decorated_func, params)
-        return decorated_func
-
-    return decorator
diff --git a/src/uipath/tracing/_utils.py b/src/uipath/tracing/_utils.py
deleted file mode 100644
index 654a4a3bd..000000000
--- a/src/uipath/tracing/_utils.py
+++ /dev/null
@@ -1,273 +0,0 @@
-import inspect
-import json
-import logging
-import os
-import random
-import uuid
-from dataclasses import dataclass, field
-from datetime import datetime
-from os import environ as env
-from typing import Any, Dict, Optional
-
-from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.trace import StatusCode
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class UiPathSpan:
-    """Represents a span in the UiPath tracing system."""
-
-    id: uuid.UUID
-    trace_id: uuid.UUID
-    name: str
-    attributes: str
-    parent_id: Optional[uuid.UUID] = None
-    start_time: str = field(default_factory=lambda: datetime.now().isoformat())
-    end_time: str = field(default_factory=lambda: datetime.now().isoformat())
-    status: int = 1
-    created_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
-    updated_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
-    organization_id: Optional[str] = field(
-        default_factory=lambda: env.get("UIPATH_ORGANIZATION_ID", "")
-    )
-    tenant_id: Optional[str] = field(
-        default_factory=lambda: env.get("UIPATH_TENANT_ID", "")
-    )
-    expiry_time_utc: Optional[str] = None
-    folder_key: Optional[str] = field(
-        default_factory=lambda: env.get("UIPATH_FOLDER_KEY_XYZ", "")
-    )
-    source: Optional[str] = None
-    span_type: str = "Coded Agents"
-    process_key: Optional[str] = field(
-        default_factory=lambda: env.get("UIPATH_PROCESS_UUID")
-    )
-    job_key: Optional[str] = field(default_factory=lambda: env.get("UIPATH_JOB_KEY"))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert the Span to a dictionary suitable for JSON serialization."""
-        return {
-            "Id": str(self.id),
-            "TraceId": str(self.trace_id),
-            "ParentId": str(self.parent_id) if self.parent_id else None,
-            "Name": self.name,
-            "StartTime": self.start_time,
-            "EndTime": self.end_time,
-            "Attributes": self.attributes,
-            "Status": self.status,
-            "CreatedAt": self.created_at,
-            "UpdatedAt": self.updated_at,
-            "OrganizationId": self.organization_id,
-            "TenantId": self.tenant_id,
-            "ExpiryTimeUtc": self.expiry_time_utc,
-            "FolderKey": self.folder_key,
-            "Source": self.source,
-            "SpanType": self.span_type,
-            "ProcessKey": self.process_key,
-            "JobKey": self.job_key,
-        }
-
-
-class _SpanUtils:
-    @staticmethod
-    def span_id_to_uuid4(span_id: int) -> uuid.UUID:
-        """Convert a 64-bit span ID to a valid UUID4 format.
-
-        Creates a UUID where:
-        - The 64 least significant bits contain the span ID
-        - The UUID version (bits 48-51) is set to 4
-        - The UUID variant (bits 64-65) is set to binary 10
-        """
-        # Generate deterministic high bits using the span_id as seed
-        temp_random = random.Random(span_id)
-        high_bits = temp_random.getrandbits(64)
-
-        # Combine high bits and span ID into a 128-bit integer
-        combined = (high_bits << 64) | span_id
-
-        # Set version to 4 (UUID4)
-        combined = (combined & ~(0xF << 76)) | (0x4 << 76)
-
-        # Set variant to binary 10
-        combined = (combined & ~(0x3 << 62)) | (2 << 62)
-
-        # Convert to hex string in UUID format
-        hex_str = format(combined, "032x")
-        return uuid.UUID(hex_str)
-
-    @staticmethod
-    def trace_id_to_uuid4(trace_id: int) -> uuid.UUID:
-        """Convert a 128-bit trace ID to a valid UUID4 format.
-
-        Modifies the trace ID to conform to UUID4 requirements:
-        - The UUID version (bits 48-51) is set to 4
-        - The UUID variant (bits 64-65) is set to binary 10
-        """
-        # Set version to 4 (UUID4)
-        uuid_int = (trace_id & ~(0xF << 76)) | (0x4 << 76)
-
-        # Set variant to binary 10
-        uuid_int = (uuid_int & ~(0x3 << 62)) | (2 << 62)
-
-        # Convert to hex string in UUID format
-        hex_str = format(uuid_int, "032x")
-        return uuid.UUID(hex_str)
-
-    @staticmethod
-    def otel_span_to_uipath_span(otel_span: ReadableSpan) -> UiPathSpan:
-        """Convert an OpenTelemetry span to a UiPathSpan."""
-        # Extract the context information from the OTel span
-        span_context = otel_span.get_span_context()
-
-        # OTel uses hexadecimal strings, we need to convert to UUID
-        trace_id = _SpanUtils.trace_id_to_uuid4(span_context.trace_id)
-        span_id = _SpanUtils.span_id_to_uuid4(span_context.span_id)
-
-        trace_id_str = os.environ.get("UIPATH_TRACE_ID")
-        if trace_id_str:
-            trace_id = uuid.UUID(trace_id_str)
-
-        # Get parent span ID if it exists
-        parent_id = None
-        if otel_span.parent is not None:
-            parent_id = _SpanUtils.span_id_to_uuid4(otel_span.parent.span_id)
-
-        parent_span_id_str = env.get("UIPATH_PARENT_SPAN_ID")
-
-        if parent_span_id_str:
-            parent_id = uuid.UUID(parent_span_id_str)
-
-        # Convert attributes to a format compatible with UiPathSpan
-        attributes_dict: dict[str, Any] = (
-            dict(otel_span.attributes) if otel_span.attributes else {}
-        )
-
-        # Map status
-        status = 1  # Default to OK
-        if otel_span.status.status_code == StatusCode.ERROR:
-            status = 2  # Error
-            attributes_dict["error"] = otel_span.status.description
-
-        original_inputs = attributes_dict.get("inputs", None)
-        original_outputs = attributes_dict.get("outputs", None)
-
-        if original_inputs:
-            try:
-                if isinstance(original_inputs, str):
-                    json_inputs = json.loads(original_inputs)
-                    attributes_dict["inputs"] = json_inputs
-                else:
-                    attributes_dict["inputs"] = original_inputs
-            except Exception as e:
-                print(f"Error parsing inputs: {e}")
-                attributes_dict["inputs"] = str(original_inputs)
-
-        if original_outputs:
-            try:
-                if isinstance(original_outputs, str):
-                    json_outputs = json.loads(original_outputs)
-                    attributes_dict["outputs"] = json_outputs
-                else:
-                    attributes_dict["outputs"] = original_outputs
-            except Exception as e:
-                print(f"Error parsing outputs: {e}")
-                attributes_dict["outputs"] = str(original_outputs)
-
-        # Add events as additional attributes if they exist
-        if otel_span.events:
-            events_list = [
-                {
-                    "name": event.name,
-                    "timestamp": event.timestamp,
-                    "attributes": dict(event.attributes) if event.attributes else {},
-                }
-                for event in otel_span.events
-            ]
-            attributes_dict["events"] = events_list
-
-        # Add links as additional attributes if they exist
-        if hasattr(otel_span, "links") and otel_span.links:
-            links_list = [
-                {
-                    "trace_id": link.context.trace_id,
-                    "span_id": link.context.span_id,
-                    "attributes": dict(link.attributes) if link.attributes else {},
-                }
-                for link in otel_span.links
-            ]
-            attributes_dict["links"] = links_list
-
-        span_type_value = attributes_dict.get("span_type", "OpenTelemetry")
-        span_type = str(span_type_value)
-
-        # Create UiPathSpan from OpenTelemetry span
-        start_time = datetime.fromtimestamp(
-            (otel_span.start_time or 0) / 1e9
-        ).isoformat()
-
-        end_time_str = None
-        if otel_span.end_time is not None:
-            end_time_str = datetime.fromtimestamp(
-                (otel_span.end_time or 0) / 1e9
-            ).isoformat()
-        else:
-            end_time_str = datetime.now().isoformat()
-
-        return UiPathSpan(
-            id=span_id,
-            trace_id=trace_id,
-            parent_id=parent_id,
-            name=otel_span.name,
-            attributes=json.dumps(attributes_dict),
-            start_time=start_time,
-            end_time=end_time_str,
-            status=status,
-            span_type=span_type,
-        )
-
-    @staticmethod
-    def format_args_for_trace_json(
-        signature: inspect.Signature, *args: Any, **kwargs: Any
-    ) -> str:
-        """Return a JSON string of inputs from the function signature."""
-        result = _SpanUtils.format_args_for_trace(signature, *args, **kwargs)
-        return json.dumps(result, default=str)
-
-    @staticmethod
-    def format_args_for_trace(
-        signature: inspect.Signature, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
-        try:
-            """Return a dictionary of inputs from the function signature."""
-            # Create a parameter mapping by partially binding the arguments
-
-            parameter_binding = signature.bind_partial(*args, **kwargs)
-
-            # Fill in default values for any unspecified parameters
-            parameter_binding.apply_defaults()
-
-            # Extract the input parameters, skipping special Python parameters
-            result = {}
-            for name, value in parameter_binding.arguments.items():
-                # Skip class and instance references
-                if name in ("self", "cls"):
-                    continue
-
-                # Handle **kwargs parameters specially
-                param_info = signature.parameters.get(name)
-                if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
-                    # Flatten nested kwargs directly into the result
-                    if isinstance(value, dict):
-                        result.update(value)
-                else:
-                    # Regular parameter
-                    result[name] = value
-
-            return result
-        except Exception as e:
-            logger.warning(
-                f"Error formatting arguments for trace: {e}. Using args and kwargs directly."
-            )
-            return {"args": args, "kwargs": kwargs}
diff --git a/src/uipath/utils/__init__.py b/src/uipath/utils/__init__.py
deleted file mode 100644
index 9d67cad18..000000000
--- a/src/uipath/utils/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from ._endpoints_manager import EndpointManager  # noqa: D104
-
-__all__ = [
-    "EndpointManager",
-]
diff --git a/src/uipath/utils/_endpoints_manager.py b/src/uipath/utils/_endpoints_manager.py
deleted file mode 100644
index d856cc4d5..000000000
--- a/src/uipath/utils/_endpoints_manager.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import logging
-import os
-from enum import Enum
-from typing import Optional
-
-import httpx
-
-from uipath._utils._ssl_context import get_httpx_client_kwargs
-
-loggger = logging.getLogger(__name__)
-
-
-class UiPathEndpoints(Enum):
-    AH_NORMALIZED_COMPLETION_ENDPOINT = "agenthub_/llm/api/chat/completions"
-    AH_PASSTHROUGH_COMPLETION_ENDPOINT = "agenthub_/llm/openai/deployments/{model}/chat/completions?api-version={api_version}"
-    AH_EMBEDDING_ENDPOINT = (
-        "agenthub_/llm/openai/deployments/{model}/embeddings?api-version={api_version}"
-    )
-    AH_CAPABILITIES_ENDPOINT = "agenthub_/llm/api/capabilities"
-
-    NORMALIZED_COMPLETION_ENDPOINT = "llmgateway_/api/chat/completions"
-    PASSTHROUGH_COMPLETION_ENDPOINT = "llmgateway_/openai/deployments/{model}/chat/completions?api-version={api_version}"
-    EMBEDDING_ENDPOINT = (
-        "llmgateway_/openai/deployments/{model}/embeddings?api-version={api_version}"
-    )
-
-
-class EndpointManager:
-    """Manages and caches the UiPath endpoints.
-    This class provides functionality to determine which UiPath endpoints to use based on
-    the availability of AgentHub. It checks for AgentHub capabilities and caches the result
-    to avoid repeated network calls.
-    Class Attributes:
-        _base_url (str): The base URL for UiPath services, retrieved from the UIPATH_URL
-                         environment variable.
-        _agenthub_available (Optional[bool]): Cached result of AgentHub availability check.
-
-    Methods:
-        is_agenthub_available(): Checks if AgentHub is available, caching the result.
-        get_passthrough_endpoint(): Returns the appropriate passthrough completion endpoint.
-        get_normalized_endpoint(): Returns the appropriate normalized completion endpoint.
-        get_embeddings_endpoint(): Returns the appropriate embeddings endpoint.
-    All endpoint methods automatically select between AgentHub and standard endpoints
-    based on availability.
-    """  # noqa: D205
-
-    _base_url = os.getenv("UIPATH_URL", "")
-    _agenthub_available: Optional[bool] = None
-
-    @classmethod
-    def is_agenthub_available(cls) -> bool:
-        """Check if AgentHub is available and cache the result."""
-        if cls._agenthub_available is None:
-            cls._agenthub_available = cls._check_agenthub()
-        return cls._agenthub_available
-
-    @classmethod
-    def _check_agenthub(cls) -> bool:
-        """Perform the actual check for AgentHub capabilities."""
-        try:
-            with httpx.Client(**get_httpx_client_kwargs()) as http_client:
-                base_url = os.getenv("UIPATH_URL", "")
-                capabilities_url = f"{base_url.rstrip('/')}/{UiPathEndpoints.AH_CAPABILITIES_ENDPOINT.value}"
-                loggger.debug(f"Checking AgentHub capabilities at {capabilities_url}")
-                response = http_client.get(capabilities_url)
-
-                if response.status_code != 200:
-                    return False
-
-                capabilities = response.json()
-
-                # Validate structure and required fields
-                if not isinstance(capabilities, dict) or "version" not in capabilities:
-                    return False
-
-                return True
-
-        except Exception as e:
-            loggger.error(f"Error checking AgentHub capabilities: {e}", exc_info=True)
-            return False
-
-    @classmethod
-    def get_passthrough_endpoint(cls) -> str:
-        if cls.is_agenthub_available():
-            return UiPathEndpoints.AH_PASSTHROUGH_COMPLETION_ENDPOINT.value
-
-        return UiPathEndpoints.PASSTHROUGH_COMPLETION_ENDPOINT.value
-
-    @classmethod
-    def get_normalized_endpoint(cls) -> str:
-        if cls.is_agenthub_available():
-            return UiPathEndpoints.AH_NORMALIZED_COMPLETION_ENDPOINT.value
-
-        return UiPathEndpoints.NORMALIZED_COMPLETION_ENDPOINT.value
-
-    @classmethod
-    def get_embeddings_endpoint(cls) -> str:
-        if cls.is_agenthub_available():
-            return UiPathEndpoints.AH_EMBEDDING_ENDPOINT.value
-
-        return UiPathEndpoints.EMBEDDING_ENDPOINT.value
diff --git a/tests/cli/mocks/bindings_script.py b/tests/cli/mocks/bindings_script.py
deleted file mode 100644
index 4cfd721c5..000000000
--- a/tests/cli/mocks/bindings_script.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from uipath import UiPath
-
-uipath = UiPath()
-
-
-async def async_function() -> None:
-    await uipath.assets.retrieve_async("asset_from_retrieve_async")
-    await uipath.buckets.retrieve_async("bucket_from_retrieve_async")
-    await uipath.context_grounding.retrieve_async("index_from_retrieve_async")
-    await uipath.processes.invoke_async("process_name_from_invoke_async")
-
-
-def include_folder_path() -> None:
-    uipath.assets.retrieve("asset_with_folder_path", folder_path="asset_folder_path")
-    uipath.buckets.retrieve("bucket_with_folder_path", folder_path="bucket_folder_path")
-    uipath.context_grounding.retrieve(
-        "index_with_folder_path", folder_path="index_folder_path"
-    )
-    uipath.processes.invoke(
-        "process_with_folder_path", folder_path="process_folder_path"
-    )
-
-
-def main() -> None:
-    uipath.assets.retrieve("asset_from_retrieve")
-    uipath.buckets.retrieve("bucket_from_retrieve")
-    uipath.context_grounding.retrieve("index_from_retrieve")
-    uipath.processes.invoke("process_name_from_invoke")
diff --git a/tests/cli/test_hitl.py b/tests/cli/test_hitl.py
deleted file mode 100644
index 31c9744ad..000000000
--- a/tests/cli/test_hitl.py
+++ /dev/null
@@ -1,314 +0,0 @@
-import uuid
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._cli._runtime._contracts import (
-    UiPathApiTrigger,
-    UiPathResumeTrigger,
-    UiPathResumeTriggerType,
-    UiPathRuntimeError,
-    UiPathRuntimeStatus,
-)
-from uipath._cli._runtime._hitl import HitlProcessor, HitlReader
-from uipath.models import Action, CreateAction, InvokeProcess, Job, WaitAction, WaitJob
-from uipath.models.job import JobErrorInfo
-
-
-@pytest.fixture
-def base_url(mock_env_vars: dict[str, str]) -> str:
-    return mock_env_vars["UIPATH_URL"]
-
-
-@pytest.fixture
-def setup_test_env(
-    monkeypatch: pytest.MonkeyPatch, mock_env_vars: dict[str, str]
-) -> None:
-    """Setup test environment variables."""
-    for key, value in mock_env_vars.items():
-        monkeypatch.setenv(key, value)
-
-
-class TestHitlReader:
-    """Tests for the HitlReader class."""
-
-    @pytest.mark.anyio
-    async def test_read_action_trigger(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test reading an action trigger."""
-        action_key = "test-action-key"
-        action_data = {"answer": "test-action-data"}
-
-        mock_action = Action(key=action_key, data=action_data)
-
-        with patch(
-            "uipath._services.actions_service.ActionsService.retrieve_async"
-        ) as mock_action_retrieve_async:
-            mock_action_retrieve_async.return_value = mock_action
-
-            resume_trigger = UiPathResumeTrigger(
-                trigger_type=UiPathResumeTriggerType.ACTION,
-                item_key=action_key,
-                folder_key="test-folder",
-                folder_path="test-path",
-            )
-
-            result = await HitlReader.read(resume_trigger)
-            assert result == action_data
-            mock_action_retrieve_async.assert_called_once_with(
-                action_key, app_folder_key="test-folder", app_folder_path="test-path"
-            )
-
-    @pytest.mark.anyio
-    async def test_read_job_trigger_successful(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test reading a successful job trigger."""
-        job_key = "test-job-key"
-        job_id = 1234
-        output_args = str({"result": "success"})
-
-        mock_job = Job(
-            id=job_id,
-            key=job_key,
-            state=UiPathRuntimeStatus.SUCCESSFUL.value,
-            output_arguments=output_args,
-        )
-
-        with patch(
-            "uipath._services.jobs_service.JobsService.retrieve_async"
-        ) as mock_job_retrieve_async:
-            mock_job_retrieve_async.return_value = mock_job
-
-            resume_trigger = UiPathResumeTrigger(
-                trigger_type=UiPathResumeTriggerType.JOB,
-                item_key=job_key,
-                folder_key="test-folder",
-                folder_path="test-path",
-            )
-
-            result = await HitlReader.read(resume_trigger)
-            assert result == output_args
-            mock_job_retrieve_async.assert_called_once_with(
-                job_key, folder_key="test-folder", folder_path="test-path"
-            )
-
-    @pytest.mark.anyio
-    async def test_read_job_trigger_failed(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test reading a failed job trigger."""
-        job_key = "test-job-key"
-        job_error_info = JobErrorInfo(code="error code")
-        job_id = 1234
-
-        mock_job = Job(id=job_id, key=job_key, state="Failed", job_error=job_error_info)
-
-        with patch(
-            "uipath._services.jobs_service.JobsService.retrieve_async"
-        ) as mock_job_retrieve_async:
-            mock_job_retrieve_async.return_value = mock_job
-
-            resume_trigger = UiPathResumeTrigger(
-                trigger_type=UiPathResumeTriggerType.JOB,
-                item_key=job_key,
-                folder_key="test-folder",
-                folder_path="test-path",
-            )
-
-            with pytest.raises(UiPathRuntimeError) as exc_info:
-                await HitlReader.read(resume_trigger)
-            error_dict = exc_info.value.as_dict
-            assert error_dict["code"] == "Python.INVOKED_PROCESS_FAILURE"
-            assert error_dict["title"] == "Invoked process did not finish successfully."
-            assert job_error_info.code in error_dict["detail"]
-            mock_job_retrieve_async.assert_called_once_with(
-                job_key, folder_key="test-folder", folder_path="test-path"
-            )
-
-    @pytest.mark.anyio
-    async def test_read_api_trigger(
-        self,
-        httpx_mock: HTTPXMock,
-        base_url: str,
-        setup_test_env: None,
-    ) -> None:
-        """Test reading an API trigger."""
-        inbox_id = str(uuid.uuid4())
-        payload_data = {"key": "value"}
-
-        httpx_mock.add_response(
-            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
-            status_code=200,
-            json={"payload": payload_data},
-        )
-
-        resume_trigger = UiPathResumeTrigger(
-            trigger_type=UiPathResumeTriggerType.API,
-            api_resume=UiPathApiTrigger(inbox_id=inbox_id, request="test"),
-        )
-
-        result = await HitlReader.read(resume_trigger)
-        assert result == payload_data
-
-    @pytest.mark.anyio
-    async def test_read_api_trigger_failure(
-        self,
-        httpx_mock: HTTPXMock,
-        base_url: str,
-        setup_test_env: None,
-    ) -> None:
-        """Test reading an API trigger with a failed response."""
-        inbox_id = str(uuid.uuid4())
-
-        httpx_mock.add_response(
-            url=f"{base_url}/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}",
-            status_code=500,
-        )
-
-        resume_trigger = UiPathResumeTrigger(
-            trigger_type=UiPathResumeTriggerType.API,
-            api_resume=UiPathApiTrigger(inbox_id=inbox_id, request="test"),
-        )
-
-        with pytest.raises(UiPathRuntimeError) as exc_info:
-            await HitlReader.read(resume_trigger)
-        error_dict = exc_info.value.as_dict
-        assert error_dict["code"] == "Python.API_CONNECTION_ERROR"
-        assert error_dict["title"] == "Failed to get trigger payload"
-        assert "Server error '500 Internal Server Error'" in error_dict["detail"]
-
-
-class TestHitlProcessor:
-    """Tests for the HitlProcessor class."""
-
-    @pytest.mark.anyio
-    async def test_create_resume_trigger_create_action(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test creating a resume trigger for CreateAction."""
-        action_key = "test-action-key"
-        create_action = CreateAction(
-            title="Test Action",
-            app_name="TestApp",
-            app_folder_path="/test/path",
-            data={"input": "test-input"},
-        )
-
-        mock_action = Action(key=action_key)
-
-        with patch(
-            "uipath._services.actions_service.ActionsService.create_async"
-        ) as mock_action_create_async:
-            mock_action_create_async.return_value = mock_action
-
-            processor = HitlProcessor(create_action)
-            resume_trigger = await processor.create_resume_trigger()
-
-            assert resume_trigger is not None
-            assert resume_trigger.trigger_type == UiPathResumeTriggerType.ACTION
-            assert resume_trigger.item_key == action_key
-            assert resume_trigger.folder_path == create_action.app_folder_path
-            mock_action_create_async.assert_called_once_with(
-                title=create_action.title,
-                app_name=create_action.app_name,
-                app_folder_path=create_action.app_folder_path,
-                app_folder_key="",
-                app_key="",
-                app_version=1,
-                assignee="",
-                data=create_action.data,
-            )
-
-    @pytest.mark.anyio
-    async def test_create_resume_trigger_wait_action(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test creating a resume trigger for WaitAction."""
-        action_key = "test-action-key"
-        action = Action(key=action_key)
-        wait_action = WaitAction(action=action, app_folder_path="/test/path")
-
-        processor = HitlProcessor(wait_action)
-        resume_trigger = await processor.create_resume_trigger()
-
-        assert resume_trigger is not None
-        assert resume_trigger.trigger_type == UiPathResumeTriggerType.ACTION
-        assert resume_trigger.item_key == action_key
-        assert resume_trigger.folder_path == wait_action.app_folder_path
-
-    @pytest.mark.anyio
-    async def test_create_resume_trigger_invoke_process(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test creating a resume trigger for InvokeProcess."""
-        job_key = "test-job-key"
-        invoke_process = InvokeProcess(
-            name="TestProcess",
-            process_folder_path="/test/path",
-            input_arguments={"key": "value"},
-        )
-
-        mock_job = Job(id=1234, key=job_key)
-        mock_invoke = AsyncMock(return_value=mock_job)
-
-        with patch(
-            "uipath._services.processes_service.ProcessesService.invoke_async",
-            new=mock_invoke,
-        ) as mock_process_invoke_async:
-            processor = HitlProcessor(invoke_process)
-            resume_trigger = await processor.create_resume_trigger()
-
-            assert resume_trigger is not None
-            assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
-            assert resume_trigger.item_key == job_key
-            assert resume_trigger.folder_path == invoke_process.process_folder_path
-            mock_process_invoke_async.assert_called_once_with(
-                name=invoke_process.name,
-                input_arguments=invoke_process.input_arguments,
-                folder_path=invoke_process.process_folder_path,
-                folder_key=None,
-            )
-
-    @pytest.mark.anyio
-    async def test_create_resume_trigger_wait_job(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test creating a resume trigger for WaitJob."""
-        job_key = "test-job-key"
-        job = Job(id=1234, key=job_key)
-        wait_job = WaitJob(job=job, process_folder_path="/test/path")
-
-        processor = HitlProcessor(wait_job)
-        resume_trigger = await processor.create_resume_trigger()
-
-        assert resume_trigger is not None
-        assert resume_trigger.trigger_type == UiPathResumeTriggerType.JOB
-        assert resume_trigger.item_key == job_key
-        assert resume_trigger.folder_path == wait_job.process_folder_path
-
-    @pytest.mark.anyio
-    async def test_create_resume_trigger_api(
-        self,
-        setup_test_env: None,
-    ) -> None:
-        """Test creating a resume trigger for API type."""
-        api_input = "payload"
-
-        processor = HitlProcessor(api_input)
-        resume_trigger = await processor.create_resume_trigger()
-
-        assert resume_trigger is not None
-        assert resume_trigger.trigger_type == UiPathResumeTriggerType.API
-        assert resume_trigger.api_resume is not None
-        assert isinstance(resume_trigger.api_resume.inbox_id, str)
-        assert resume_trigger.api_resume.request == api_input
diff --git a/tests/cli/test_init.py b/tests/cli/test_init.py
deleted file mode 100644
index f208f66a0..000000000
--- a/tests/cli/test_init.py
+++ /dev/null
@@ -1,336 +0,0 @@
-import json
-import os
-import re
-from typing import Any
-from unittest.mock import patch
-
-import pytest
-from click.testing import CliRunner
-
-from uipath._cli.cli_init import init  # type: ignore
-from uipath._cli.middlewares import MiddlewareResult
-
-
-@pytest.fixture
-def bindings_script() -> str:
-    if os.path.isfile("mocks/bindings_script.py"):
-        with open("mocks/bindings_script.py", "r") as file:
-            data = file.read()
-    else:
-        with open("tests/cli/mocks/bindings_script.py", "r") as file:
-            data = file.read()
-    return data
-
-
-class TestInit:
-    def test_init_env_file_creation(self, runner: CliRunner, temp_dir: str) -> None:
-        """Test .env file creation scenarios."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("main.py", "w") as f:
-                f.write("def main(input): return input")
-            # Test creation of new .env
-            result = runner.invoke(init)
-            assert result.exit_code == 0
-            assert "Created '.env' file" in result.output
-
-            assert os.path.exists(".env")
-
-            # Test existing .env isn't overwritten
-            original_content = "EXISTING=CONFIG"
-            with open(".env", "w") as f:
-                f.write(original_content)
-
-            result = runner.invoke(init)
-            assert result.exit_code == 0
-            with open(".env", "r") as f:
-                assert f.read() == original_content
-
-    def test_init_script_detection(self, runner: CliRunner, temp_dir: str) -> None:
-        """Test Python script detection scenarios."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Test empty directory
-            result = runner.invoke(init)
-            assert result.exit_code == 1
-            assert "No python files found in the current directory" in result.output
-
-            # Test single Python file
-            with open("main.py", "w") as f:
-                f.write("def main(input): return input")
-
-            result = runner.invoke(init)
-            assert result.exit_code == 0
-            assert os.path.exists("uipath.json")
-
-            # Test multiple Python files
-            with open("second.py", "w") as f:
-                f.write("def main(input): return input")
-
-            result = runner.invoke(init)
-            assert result.exit_code == 1
-            assert (
-                "Multiple python files found in the current directory" in result.output
-            )
-            assert "Please specify the entrypoint" in result.output
-
-    def test_init_with_entrypoint(self, runner: CliRunner, temp_dir: str) -> None:
-        """Test init with specified entrypoint."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Test with non-existent file
-            result = runner.invoke(init, ["nonexistent.py"])
-            assert result.exit_code == 1
-            assert "does not exist in the current directory" in result.output
-
-            # Test with valid Python file
-            with open("script.py", "w") as f:
-                f.write("def main(input): return input")
-
-            result = runner.invoke(init, ["script.py"])
-            assert result.exit_code == 0
-            assert os.path.exists("uipath.json")
-
-            # Verify config content
-            with open("uipath.json", "r") as f:
-                config = json.load(f)
-                assert "entryPoints" in config
-                assert len(config["entryPoints"]) == 1
-                assert config["entryPoints"][0]["filePath"] == "script.py"
-                assert config["entryPoints"][0]["type"] == "agent"
-                assert "uniqueId" in config["entryPoints"][0]
-
-    def test_init_middleware_interaction(
-        self, runner: CliRunner, temp_dir: str
-    ) -> None:
-        """Test middleware integration."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
-                # Test middleware stopping execution with error
-                mock_middleware.return_value = MiddlewareResult(
-                    should_continue=False,
-                    error_message="Middleware error",
-                    should_include_stacktrace=False,
-                )
-
-                result = runner.invoke(init)
-                assert result.exit_code == 1
-                assert "Middleware error" in result.output
-                assert not os.path.exists("uipath.json")
-
-                # Test middleware allowing execution
-                mock_middleware.return_value = MiddlewareResult(
-                    should_continue=True,
-                    error_message=None,
-                    should_include_stacktrace=False,
-                )
-
-                with open("main.py", "w") as f:
-                    f.write("def main(input): return input")
-
-                result = runner.invoke(init)
-                assert result.exit_code == 0
-                assert os.path.exists("uipath.json")
-
-    def test_init_error_handling(self, runner: CliRunner, temp_dir: str) -> None:
-        """Test error handling in init command."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Test invalid Python syntax
-            with open("invalid.py", "w") as f:
-                f.write("def main(input: return input")  # Invalid syntax
-
-            # Mock middleware to allow execution
-            with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
-                mock_middleware.return_value = MiddlewareResult(should_continue=True)
-
-                result = runner.invoke(init, ["invalid.py"])
-                assert result.exit_code == 1
-                assert "Error creating configuration" in result.output
-                assert "invalid syntax" in result.output  # Should show stacktrace
-
-            # Test with generate_args raising exception
-            with patch("uipath._cli.cli_init.generate_args") as mock_generate:
-                mock_generate.side_effect = Exception("Generation error")
-                with open("script.py", "w") as f:
-                    f.write("def main(input): return input")
-
-                # Mock middleware to allow execution
-                with patch("uipath._cli.cli_init.Middlewares.next") as mock_middleware:
-                    mock_middleware.return_value = MiddlewareResult(
-                        should_continue=True
-                    )
-
-                    result = runner.invoke(init, ["script.py"])
-                    assert result.exit_code == 1
-                    # Use regex to match any spinner character followed by the expected message
-                    assert re.search(
-                        r"⠋|⠼|⠇|⠏|⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏ Initializing UiPath project \.\.\.❌ Error creating configuration file:\n Generation error\n",
-                        result.output,
-                    )
-
-    def test_init_config_generation(self, runner: CliRunner, temp_dir: str) -> None:
-        """Test configuration file generation with different input/output schemas."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Create test script with typed input/output
-            script_content = """
-from dataclasses import dataclass
-from typing import Optional
-
-@dataclass
-class Input:
-    message: str
-    count: Optional[int] = None
-
-@dataclass
-class Output:
-    result: str
-
-def main(input: Input) -> Output:
-    return Output(result=input.message)
-"""
-            with open("test.py", "w") as f:
-                f.write(script_content)
-
-            result = runner.invoke(init, ["test.py"])
-            assert result.exit_code == 0
-            assert os.path.exists("uipath.json")
-
-            with open("uipath.json", "r") as f:
-                config = json.load(f)
-                entry = config["entryPoints"][0]
-
-                # Verify input schema
-                assert "input" in entry
-                input_schema = entry["input"]
-                assert "message" in input_schema["properties"]
-                assert "count" in input_schema["properties"]
-                assert "message" in input_schema["required"]
-
-                # Verify output schema
-                assert "output" in entry
-                output_schema = entry["output"]
-                assert "result" in output_schema["properties"]
-
-    def test_bindings_inference(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        mock_env_vars: dict[str, str],
-        bindings_script: str,
-    ) -> None:
-        """Test the inference of UiPath bindings from the code."""
-
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open(".env", "w") as f:
-                for key, value in mock_env_vars.items():
-                    f.write(f"{key}={value}\n")
-
-            with open("bindings.py", "w") as f:
-                f.write(bindings_script)
-            print(1)
-            result = runner.invoke(init, ["bindings.py"])
-            assert result.exit_code == 0
-            assert "Created 'uipath.json' file" in result.output
-            assert os.path.exists("uipath.json")
-            with open("uipath.json", "r") as f:
-                config = json.load(f)
-                assert "bindings" in config
-                bindings = config["bindings"]
-                assert len(bindings) > 0
-                assert "resources" in config["bindings"]
-                resources = config["bindings"]["resources"]
-                assert len(resources) == 12
-
-                # Helper function to find resource by key
-                def find_resource(key: str) -> dict[str, Any]:
-                    return next((r for r in resources if r["key"] == key), {})
-
-                assert all(r["metadata"]["BindingsVersion"] == "2.2" for r in resources)
-
-                # Test resources with and without async for each type
-                retrieve_resource_types = ["asset", "bucket", "index"]
-                for resource_type in retrieve_resource_types:
-                    # Test async variant
-                    async_key = f"{resource_type}_from_retrieve_async"
-                    async_resource = find_resource(async_key)
-                    assert async_resource["resource"] == resource_type
-                    assert (
-                        async_resource["metadata"]["ActivityName"] == "retrieve_async"
-                    )
-                    assert async_resource["value"]["name"]["defaultValue"] == async_key
-                    assert "folderPath" not in async_resource["value"]
-
-                    # Test non-async variant
-                    non_async_key = f"{resource_type}_from_retrieve"
-                    non_async_resource = find_resource(non_async_key)
-                    assert non_async_resource["resource"] == resource_type
-                    assert non_async_resource["metadata"]["ActivityName"] == "retrieve"
-                    assert (
-                        non_async_resource["value"]["name"]["defaultValue"]
-                        == non_async_key
-                    )
-                    assert "folderPath" not in non_async_resource["value"]
-
-                    # Test folder path variant
-                    folder_key = (
-                        f"{resource_type}_folder_path.{resource_type}_with_folder_path"
-                    )
-                    folder_resource = find_resource(folder_key)
-                    assert folder_resource["resource"] == resource_type
-                    assert folder_resource["metadata"]["ActivityName"] == "retrieve"
-                    assert (
-                        folder_resource["value"]["folderPath"]["defaultValue"]
-                        == f"{resource_type}_folder_path"
-                    )
-                    assert (
-                        folder_resource["value"]["name"]["defaultValue"]
-                        == f"{resource_type}_with_folder_path"
-                    )
-
-                # Test process resources
-                # Test async variant
-                process_async = find_resource("process_name_from_invoke_async")
-                assert process_async["resource"] == "process"
-                assert process_async["metadata"]["ActivityName"] == "invoke_async"
-                assert (
-                    process_async["value"]["name"]["defaultValue"]
-                    == "process_name_from_invoke_async"
-                )
-                assert "folderPath" not in process_async["value"]
-
-                # Test non-async variant
-                process_non_async = find_resource("process_name_from_invoke")
-                assert process_non_async["resource"] == "process"
-                assert process_non_async["metadata"]["ActivityName"] == "invoke"
-                assert (
-                    process_non_async["value"]["name"]["defaultValue"]
-                    == "process_name_from_invoke"
-                )
-                assert "folderPath" not in process_non_async["value"]
-
-                # Test folder path variant
-                process_folder = find_resource(
-                    "process_folder_path.process_with_folder_path"
-                )
-                assert process_folder["resource"] == "process"
-                assert process_folder["metadata"]["ActivityName"] == "invoke"
-                assert (
-                    process_folder["value"]["folderPath"]["defaultValue"]
-                    == "process_folder_path"
-                )
-                assert (
-                    process_folder["value"]["name"]["defaultValue"]
-                    == "process_with_folder_path"
-                )
-
-                # Verify common metadata fields
-                for resource in resources:
-                    assert "metadata" in resource
-                    assert "DisplayLabel" in resource["metadata"]
-                    assert resource["metadata"]["DisplayLabel"] == "FullName"
-                    assert "value" in resource
-                    if "folderPath" in resource["value"]:
-                        assert (
-                            resource["value"]["folderPath"]["displayName"]
-                            == "Folder Path"
-                        )
-                        assert not resource["value"]["folderPath"]["isExpression"]
-                    assert resource["value"]["name"]["displayName"] == "Name"
-                    assert not resource["value"]["name"]["isExpression"]
diff --git a/tests/cli/test_pack.py b/tests/cli/test_pack.py
deleted file mode 100644
index 013d63912..000000000
--- a/tests/cli/test_pack.py
+++ /dev/null
@@ -1,473 +0,0 @@
-# type: ignore
-import json
-import os
-import zipfile
-
-from click.testing import CliRunner
-from utils.project_details import ProjectDetails
-from utils.uipath_json import UiPathJson
-
-import uipath._cli.cli_pack as cli_pack
-from uipath._cli.cli_pack import pack
-
-
-class TestPack:
-    """Test pack command."""
-
-    def test_pack_project_creation(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test project packing scenarios."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Create necessary files for packing
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 0
-            assert os.path.exists(
-                f".uipath/{project_details.name}.{project_details.version}.nupkg"
-            )
-
-    def test_pyproject_missing_description(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test project packing scenarios."""
-        project_details.description = None
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert (
-                "pyproject.toml is missing the required field: project.description."
-                in result.output
-            )
-
-    def test_pyproject_missing_authors(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test project packing scenarios."""
-        project_details.authors = None
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert (
-                """Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]"""
-                in result.output
-            )
-
-    def test_pyproject_missing_project_name(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        project_details.name = ""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert (
-                "Project name cannot be empty. Please specify a name in pyproject.toml."
-                in result.output
-            )
-
-    def test_pyproject_invalid_name(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        project_details.name = "project < name"
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert """Project name contains invalid character: '<'""" in result.output
-
-    def test_pyproject_invalid_description(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        project_details.description = "invalid project description &"
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert (
-                """Project description contains invalid character: '&'"""
-                in result.output
-            )
-
-    def test_pack_without_uipath_json(
-        self, runner: CliRunner, temp_dir: str, project_details: ProjectDetails
-    ) -> None:
-        """Test packing when uipath.json is missing."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert (
-                "uipath.json not found. Please run `uipath init` in the project directory."
-                in result.output
-            )
-
-    def test_pack_without_pyproject_toml(
-        self, runner: CliRunner, temp_dir: str, uipath_json: UiPathJson
-    ) -> None:
-        """Test packing when pyproject.toml is missing."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-
-            result = runner.invoke(pack, ["./"])
-            assert result.exit_code == 1
-            assert "pyproject.toml not found" in result.output
-
-    def test_generate_operate_file(
-        self, runner: CliRunner, temp_dir: str, uipath_json: UiPathJson
-    ) -> None:
-        """Test generating operate.json and its content."""
-
-        operate_data = cli_pack.generate_operate_file(
-            json.loads(uipath_json.to_json())["entryPoints"]
-        )
-        assert (
-            operate_data["$schema"]
-            == "https://cloud.uipath.com/draft/2024-12/entry-point"
-        )
-        assert operate_data["main"] == uipath_json.entry_points[0].file_path
-        assert operate_data["contentType"] == uipath_json.entry_points[0].type
-        assert operate_data["targetFramework"] == "Portable"
-        assert operate_data["targetRuntime"] == "python"
-        assert operate_data["runtimeOptions"] == {
-            "requiresUserInteraction": False,
-            "isAttended": False,
-        }
-
-    def test_generate_entrypoints_file(
-        self, runner: CliRunner, temp_dir: str, uipath_json: UiPathJson
-    ) -> None:
-        """Test generating operate.json and its content."""
-        bindings_data = cli_pack.generate_bindings_content()
-        assert bindings_data["version"] == "2.0"
-        assert bindings_data["resources"] == []
-
-    def test_generate_bindings_content(
-        self, runner: CliRunner, temp_dir: str, uipath_json: UiPathJson
-    ) -> None:
-        """Test generating operate.json and its content."""
-        entrypoints_data = cli_pack.generate_entrypoints_file(
-            json.loads(uipath_json.to_json())["entryPoints"]
-        )
-        assert (
-            entrypoints_data["$schema"]
-            == "https://cloud.uipath.com/draft/2024-12/entry-point"
-        )
-        assert entrypoints_data["$id"] == "entry-points.json"
-        assert (
-            entrypoints_data["entryPoints"]
-            == json.loads(uipath_json.to_json())["entryPoints"]
-        )
-
-    def test_package_descriptor_content(
-        self, runner: CliRunner, temp_dir: str, uipath_json: UiPathJson
-    ) -> None:
-        """Test generating operate.json and its content."""
-        expected_files = {
-            "operate.json": "content/operate.json",
-            "entry-points.json": "content/entry-points.json",
-            "bindings.json": "content/bindings_v2.json",
-        }
-        for entry in uipath_json.entry_points:
-            expected_files[entry.file_path] = entry.file_path
-        content = cli_pack.generate_package_descriptor_content(
-            json.loads(uipath_json.to_json())["entryPoints"]
-        )
-        assert (
-            content["$schema"]
-            == "https://cloud.uipath.com/draft/2024-12/package-descriptor"
-        )
-        assert len(content["files"]) == 3 + len(uipath_json.entry_points)
-        assert content["files"] == expected_files
-
-    def test_include_file_extensions(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test generating operate.json and its content."""
-        xml_file_name = "test.xml"
-        sh_file_name = "test.sh"
-        uipath_json.settings.file_extensions_included = [".xml"]
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-            with open(xml_file_name, "w") as f:
-                f.write("<root><child>text</child></root>")
-            with open(sh_file_name, "w") as f:
-                f.write("#bin/sh\n echo 1")
-            result = runner.invoke(pack, ["./"])
-
-            assert result.exit_code == 0
-            with zipfile.ZipFile(
-                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
-            ) as z:
-                assert f"content/{xml_file_name}" in z.namelist()
-                assert f"content/{sh_file_name}" not in z.namelist()
-
-    def test_include_files(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test generating operate.json and its content."""
-        file_to_add = "file_to_add.xml"
-        random_file = "random_file.xml"
-        uipath_json.settings.files_included = [f"{file_to_add}"]
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-            with open(file_to_add, "w") as f:
-                f.write("<root><child>text</child></root>")
-            with open(random_file, "w") as f:
-                f.write("<root><child>text</child></root>")
-            result = runner.invoke(pack, ["./"])
-
-            assert result.exit_code == 0
-            with zipfile.ZipFile(
-                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
-            ) as z:
-                assert f"content/{file_to_add}" in z.namelist()
-                assert f"content/{random_file}" not in z.namelist()
-
-    def test_successful_pack(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test error handling in pack command."""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-            for entry in uipath_json.entry_points:
-                with open(f"{entry.file_path}.py", "w") as f:
-                    f.write("#agent content")
-            result = runner.invoke(pack, ["./"])
-
-            assert result.exit_code == 0
-            with zipfile.ZipFile(
-                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
-            ) as z:
-                assert result.exit_code == 0
-                for entry in uipath_json.entry_points:
-                    assert f"content/{entry.file_path}.py" in z.namelist()
-                assert "Packaging project" in result.output
-                assert f"Name       : {project_details.name}" in result.output
-                assert f"Version    : {project_details.version}" in result.output
-                assert f"Description: {project_details.description}" in result.output
-                authors_dict = {
-                    author["name"]: author for author in project_details.authors
-                }
-                assert f"Authors    : {', '.join(authors_dict.keys())}" in result.output
-                assert "Project successfully packaged." in result.output
-
-    def test_dependencies_version_formats(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        project_details: ProjectDetails,
-        uipath_json: UiPathJson,
-    ) -> None:
-        """Test that all dependency version formats are parsed correctly and included in operate.json."""
-
-        # Update project details with comprehensive dependency examples
-        project_details.dependencies = [
-            # Simple package name
-            "click",
-            # Single version constraints
-            "django>=4.0",
-            "flask==2.3.0",
-            "numpy>1.20.0",
-            "pandas<=2.0.0",
-            "scipy<1.11.0",
-            "matplotlib~=3.5.0",
-            "pytest!=7.1.0",
-            # Complex version constraints
-            "tensorflow>=2.10.0,<2.13.0",
-            "torch>=1.12.0,<=1.13.1",
-            # Package with extras
-            "requests[security]>=2.28.0",
-            "sqlalchemy[postgresql,mysql]>=1.4.0",
-            # Environment markers (should be stripped)
-            "pywin32>=227; sys_platform=='win32'",
-            "uvloop>=0.17.0; python_version>='3.8' and sys_platform!='win32'",
-            # Complex combination
-            "cryptography[ssh]>=3.4.8,<4.0.0; python_version>='3.7'",
-            # Edge cases
-            "some-package_with.dots_and-dashes>=1.0.0",
-            "CamelCasePackage==2.1.0",
-        ]
-
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # Create necessary files
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with open("pyproject.toml", "w") as f:
-                f.write(project_details.to_toml())
-
-            # Create entry point files
-            for entry in uipath_json.entry_points:
-                with open(f"{entry.file_path}.py", "w") as f:
-                    f.write("# agent content")
-
-            # Run pack command
-            result = runner.invoke(pack, ["./"])
-
-            # Assert pack was successful
-            assert result.exit_code == 0, f"Pack failed with output: {result.output}"
-            assert "Project successfully packaged." in result.output
-
-            # Verify package was created
-            package_path = (
-                f".uipath/{project_details.name}.{project_details.version}.nupkg"
-            )
-            assert os.path.exists(package_path)
-
-            # Extract and verify operate.json content
-            with zipfile.ZipFile(package_path, "r") as z:
-                # Read operate.json
-                operate_content = z.read("content/operate.json").decode("utf-8")
-                operate_data = json.loads(operate_content)
-
-                # Verify dependencies exist in operate.json
-                assert "dependencies" in operate_data, (
-                    "Dependencies should be present in operate.json"
-                )
-
-                dependencies = operate_data["dependencies"]
-
-                # Expected parsed dependencies (name -> version_spec)
-                expected_dependencies = {
-                    # Simple package name
-                    "click": "*",
-                    # Single version constraints
-                    "django": ">=4.0",
-                    "flask": "==2.3.0",
-                    "numpy": ">1.20.0",
-                    "pandas": "<=2.0.0",
-                    "scipy": "<1.11.0",
-                    "matplotlib": "~=3.5.0",
-                    "pytest": "!=7.1.0",
-                    # Complex version constraints
-                    "tensorflow": ">=2.10.0,<2.13.0",
-                    "torch": ">=1.12.0,<=1.13.1",
-                    # Package with extras (extras should be stripped)
-                    "requests": ">=2.28.0",
-                    "sqlalchemy": ">=1.4.0",
-                    # Environment markers (markers should be stripped)
-                    "pywin32": ">=227",
-                    "uvloop": ">=0.17.0",
-                    # Complex combination (extras and markers stripped)
-                    "cryptography": ">=3.4.8,<4.0.0",
-                    # Edge cases
-                    "some-package_with.dots_and-dashes": ">=1.0.0",
-                    "CamelCasePackage": "==2.1.0",
-                }
-
-                # Verify all expected dependencies are present
-                for package_name, expected_version in expected_dependencies.items():
-                    assert package_name in dependencies, (
-                        f"Package '{package_name}' should be in dependencies"
-                    )
-                    actual_version = dependencies[package_name]
-                    assert actual_version == expected_version, (
-                        f"Package '{package_name}' should have version '{expected_version}', "
-                        f"but got '{actual_version}'"
-                    )
-
-                # Verify no unexpected dependencies
-                for package_name in dependencies:
-                    assert package_name in expected_dependencies, (
-                        f"Unexpected package '{package_name}' found in dependencies"
-                    )
-
-                # Verify specific edge cases
-                assert len(dependencies) == len(expected_dependencies), (
-                    f"Expected {len(expected_dependencies)} dependencies, "
-                    f"but got {len(dependencies)}"
-                )
-
-                # Test that environment markers were properly stripped
-                assert "pywin32" in dependencies
-                assert dependencies["pywin32"] == ">=227"
-
-                # Test that extras were properly stripped but version preserved
-                assert "sqlalchemy" in dependencies
-                assert dependencies["sqlalchemy"] == ">=1.4.0"
-
-                # Test complex version constraints are preserved
-                assert "tensorflow" in dependencies
-                assert dependencies["tensorflow"] == ">=2.10.0,<2.13.0"
-
-                # Verify operate.json structure is still correct
-                assert (
-                    operate_data["$schema"]
-                    == "https://cloud.uipath.com/draft/2024-12/entry-point"
-                )
-                assert "projectId" in operate_data
-                assert operate_data["targetRuntime"] == "python"
-                assert operate_data["targetFramework"] == "Portable"
diff --git a/tests/cli/test_run.py b/tests/cli/test_run.py
deleted file mode 100644
index fd37e4488..000000000
--- a/tests/cli/test_run.py
+++ /dev/null
@@ -1,257 +0,0 @@
-# type: ignore
-import os
-from unittest import mock
-from unittest.mock import patch
-
-import pytest
-from click.testing import CliRunner
-
-from tests.cli.utils.uipath_json import UiPathJson
-from uipath._cli.cli_run import run  # type: ignore
-from uipath._cli.middlewares import MiddlewareResult
-
-
-@pytest.fixture
-def entrypoint():
-    return "entrypoint.py"
-
-
-@pytest.fixture
-def simple_script() -> str:
-    if os.path.isfile("mocks/simple_script.py"):
-        with open("mocks/simple_script.py", "r") as file:
-            data = file.read()
-    else:
-        with open("tests/cli/mocks/simple_script.py", "r") as file:
-            data = file.read()
-    return data
-
-
-@pytest.fixture
-def mock_env_vars():
-    return {
-        "UIPATH_CONFIG_PATH": "test_config.json",
-        "UIPATH_JOB_KEY": "test-job-id",
-        "UIPATH_TRACE_ID": "test-trace-id",
-        "UIPATH_TRACING_ENABLED": "true",
-        "UIPATH_PARENT_SPAN_ID": "test-parent-span",
-        "UIPATH_ROOT_SPAN_ID": "test-root-span",
-        "UIPATH_ORGANIZATION_ID": "test-org-id",
-        "UIPATH_TENANT_ID": "test-tenant-id",
-        "UIPATH_PROCESS_UUID": "test-process-id",
-        "UIPATH_FOLDER_KEY": "test-folder-key",
-        "LOG_LEVEL": "DEBUG",
-    }
-
-
-class TestRun:
-    class TestFileInput:
-        def test_run_input_file_not_found(
-            self,
-            runner: CliRunner,
-            temp_dir: str,
-            entrypoint: str,
-        ):
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                file_path = os.path.join(temp_dir, entrypoint)
-                with open(file_path, "w") as f:
-                    f.write("script content")
-                result = runner.invoke(run, [entrypoint, "--file", "not-here.json"])
-                assert result.exit_code != 0
-                assert "Error: Invalid value for '-f' / '--file'" in result.output
-
-        def test_run_invalid_input_file(
-            self,
-            runner: CliRunner,
-            temp_dir: str,
-            entrypoint: str,
-        ):
-            file_name = "not-json.txt"
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                script_file_path = os.path.join(temp_dir, entrypoint)
-                with open(script_file_path, "w") as f:
-                    f.write("script content")
-                file_path = os.path.join(temp_dir, file_name)
-                with open(file_path, "w") as f:
-                    f.write("file content")
-                result = runner.invoke(run, [script_file_path, "--file", file_path])
-                assert result.exit_code == 1
-                assert "Invalid Input File Extension" in result.output
-
-        def test_run_input_file_success(
-            self,
-            runner: CliRunner,
-            temp_dir: str,
-            entrypoint: str,
-        ):
-            file_name = "input.json"
-            json_content = """
-            {
-                "input_key": "input_value"
-            }"""
-
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                file_path = os.path.join(temp_dir, file_name)
-                with open(file_path, "w") as f:
-                    f.write(json_content)
-                with patch("uipath._cli.cli_run.Middlewares.next") as mock_middleware:
-                    mock_middleware.return_value = MiddlewareResult(
-                        should_continue=False,
-                        info_message="Execution succeeded",
-                        error_message=None,
-                        should_include_stacktrace=False,
-                    )
-                    result = runner.invoke(run, [entrypoint, "--file", file_path])
-                    assert result.exit_code == 0
-                    assert "Successful execution." in result.output
-                    assert mock_middleware.call_count == 1
-                    assert mock_middleware.call_args == mock.call(
-                        "run",
-                        entrypoint,
-                        "{}",
-                        False,
-                        debug=False,
-                        debug_port=5678,
-                        input_file=file_path,
-                        execution_output_file=None,
-                    )
-
-    class TestMiddleware:
-        def test_no_entrypoint(self, runner: CliRunner, temp_dir: str):
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                result = runner.invoke(run)
-                assert result.exit_code == 1
-                assert (
-                    "No entrypoint specified. Please provide a path to a Python script."
-                    in result.output
-                )
-
-        def test_script_not_found(
-            self, runner: CliRunner, temp_dir: str, entrypoint: str
-        ):
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                result = runner.invoke(run, [entrypoint])
-                assert result.exit_code == 1
-                assert f"Script not found at path {entrypoint}" in result.output
-
-        @pytest.mark.parametrize(
-            "uipath_json", ["uipath-simple-script-mock.json"], indirect=True
-        )
-        def test_successful_execution(
-            self,
-            runner: CliRunner,
-            temp_dir: str,
-            entrypoint: str,
-            mock_env_vars: dict,
-            uipath_json: UiPathJson,
-            simple_script: str,
-        ):
-            input_file_name = "input.json"
-            output_file_name = "output.json"
-            input_json_content = """
-            {
-                "message": "Hello world",
-                "repeat": 2
-            }"""
-            with runner.isolated_filesystem(temp_dir=temp_dir):
-                # create input file
-                input_file_path = os.path.join(temp_dir, input_file_name)
-                output_file_path = os.path.join(temp_dir, output_file_name)
-                with open(input_file_path, "w") as f:
-                    f.write(input_json_content)
-                # Create test script
-                script_file_path = os.path.join(temp_dir, entrypoint)
-                with open(script_file_path, "w") as f:
-                    f.write(simple_script)
-                # create uipath.json
-                with open("uipath.json", "w") as f:
-                    f.write(uipath_json.to_json())
-                result = runner.invoke(
-                    run,
-                    [
-                        script_file_path,
-                        "--input-file",
-                        input_file_path,
-                        "--output-file",
-                        output_file_path,
-                    ],
-                )
-                assert result.exit_code == 0
-                assert "Successful execution." in result.output
-                assert result.output.count("Hello world") == 2
-                assert os.path.exists(output_file_path)
-                with open(output_file_path, "r") as f:
-                    output = f.read()
-                    assert output.count("Hello world") == 2
-
-    def test_no_main_function_found(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        entrypoint: str,
-        mock_env_vars: dict,
-        uipath_json: UiPathJson,
-    ):
-        input_file_name = "input.json"
-        input_json_content = """
-                {
-                    "message": "Hello world",
-                    "repeat": 2
-                }"""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # create input file
-            input_file_path = os.path.join(temp_dir, input_file_name)
-            with open(input_file_path, "w") as f:
-                f.write(input_json_content)
-            # Create test script
-            script_file_path = os.path.join(temp_dir, entrypoint)
-            with open(script_file_path, "w") as f:
-                f.write("print(0)")
-            # create uipath.json
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            result = runner.invoke(run, [script_file_path, "{}"])
-            assert result.exit_code == 1
-            assert (
-                "No entry function found - No main function (main, run, or execute)"
-                in result.output
-            )
-            assert "Successful execution." not in result.output
-
-    def test_middleware_error(
-        self,
-        runner: CliRunner,
-        temp_dir: str,
-        entrypoint: str,
-        mock_env_vars: dict,
-        uipath_json: UiPathJson,
-    ):
-        input_file_name = "input.json"
-        input_json_content = """
-                {
-                    "message": "Hello world",
-                    "repeat": 2
-                }"""
-        with runner.isolated_filesystem(temp_dir=temp_dir):
-            # create input file
-            input_file_path = os.path.join(temp_dir, input_file_name)
-            with open(input_file_path, "w") as f:
-                f.write(input_json_content)
-            # Create test script
-            script_file_path = os.path.join(temp_dir, entrypoint)
-            with open(script_file_path, "w") as f:
-                f.write("print(0)")
-            # create uipath.json
-            with open("uipath.json", "w") as f:
-                f.write(uipath_json.to_json())
-            with patch("uipath._cli.cli_run.Middlewares.next") as mock_middleware:
-                mock_middleware.return_value = MiddlewareResult(
-                    should_continue=False,
-                    info_message="Execution failed",
-                    error_message="some error message",
-                    should_include_stacktrace=True,
-                )
-                result = runner.invoke(run, [script_file_path, "{}"])
-            assert result.exit_code == 1
-            assert "some error message" in result.output
-            assert "Successful execution." not in result.output
diff --git a/tests/cli/utils/uipath_json.py b/tests/cli/utils/uipath_json.py
deleted file mode 100644
index d6ef1e217..000000000
--- a/tests/cli/utils/uipath_json.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import json
-
-import inflection
-
-
-def _convert_to_snake_case(old_dict):
-    new_dict = {}
-    for key, value in old_dict.items():
-        new_key = inflection.underscore(key)
-        new_dict[new_key] = value
-    return new_dict
-
-
-def _convert_to_camel_case(old_dict):
-    new_dict = {}
-    for key, value in old_dict.items():
-        if isinstance(value, list):
-            new_value = [
-                _convert_to_camel_case(v.__dict__) if hasattr(v, "__dict__") else v
-                for v in value
-            ]
-        elif hasattr(value, "__dict__"):
-            new_value = _convert_to_camel_case(value.__dict__)
-        else:
-            new_value = value
-        new_key = inflection.camelize(key, False)
-        new_dict[new_key] = new_value
-    return new_dict
-
-
-class InputOutput:
-    def __init__(self, type=None, properties=None, required=None):
-        self.type = type
-        self.properties = properties if properties else {}
-        self.required = required if required else []
-
-
-class EntryPoint:
-    def __init__(
-        self, file_path=None, unique_id=None, type=None, input=None, output=None
-    ):
-        self.file_path = file_path
-        self.unique_id = unique_id
-        self.type = type
-        self.input = (
-            InputOutput(**_convert_to_snake_case(input))
-            if isinstance(input, dict)
-            else input
-        )
-        self.output = (
-            InputOutput(**_convert_to_snake_case(output))
-            if isinstance(output, dict)
-            else output
-        )
-
-    def __str__(self):
-        data = self.__dict__
-        camel_cased_data = _convert_to_camel_case(data)
-        return json.dumps(camel_cased_data, separators=(",", ":"))
-
-
-class Bindings:
-    def __init__(self, version=None, resources=None):
-        self.version = version
-        self.resources = resources if resources else []
-
-
-class Settings:
-    def __init__(self, file_extensions_included=None, files_included=None):
-        self.file_extensions_included = (
-            file_extensions_included if file_extensions_included else []
-        )
-        self.files_included = files_included if files_included else []
-
-
-class UiPathJson:
-    def __init__(self, entry_points=None, bindings=None, settings=None):
-        self.entry_points = (
-            [EntryPoint(**ep) if isinstance(ep, dict) else ep for ep in entry_points]
-            if entry_points
-            else []
-        )
-        self.bindings = (
-            Bindings(**bindings)
-            if isinstance(bindings, dict)
-            else bindings
-            if bindings
-            else []
-        )
-        self.settings = (
-            Settings(**settings)
-            if isinstance(settings, dict)
-            else settings
-            if settings
-            else []
-        )
-
-    @classmethod
-    def from_json(cls, json_str):
-        data = json.loads(json_str)
-        entry_points = [
-            _convert_to_snake_case(ep) for ep in data.get("entryPoints", [])
-        ]
-        bindings = _convert_to_snake_case(data.get("bindings", {}))
-        settings = _convert_to_snake_case(data.get("settings", {}))
-        return cls(entry_points, bindings, settings)
-
-    def to_json(self):
-        data = self.__dict__
-        camel_cased_data = _convert_to_camel_case(data)
-        return json.dumps(camel_cased_data, separators=(",", ":"))
diff --git a/tests/sdk/services/conftest.py b/tests/sdk/services/conftest.py
deleted file mode 100644
index ddf1fe82d..000000000
--- a/tests/sdk/services/conftest.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import importlib
-from functools import wraps
-
-import pytest
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath.tracing._traced import TracingManager
-
-
-@pytest.fixture
-def base_url() -> str:
-    return "https://test.uipath.com"
-
-
-@pytest.fixture
-def org() -> str:
-    return "/org"
-
-
-@pytest.fixture
-def tenant() -> str:
-    return "/tenant"
-
-
-@pytest.fixture
-def secret() -> str:
-    return "secret"
-
-
-@pytest.fixture
-def config(base_url: str, org: str, tenant: str, secret: str) -> Config:
-    return Config(base_url=f"{base_url}{org}{tenant}", secret=secret)
-
-
-@pytest.fixture
-def version(monkeypatch: pytest.MonkeyPatch) -> str:
-    test_version = "1.0.0"
-    monkeypatch.setattr(importlib.metadata, "version", lambda _: test_version)
-    return test_version
-
-
-@pytest.fixture
-def execution_context(monkeypatch: pytest.MonkeyPatch) -> ExecutionContext:
-    monkeypatch.setenv("UIPATH_ROBOT_KEY", "test-robot-key")
-    return ExecutionContext()
-
-
-@pytest.fixture(autouse=True)
-def mock_tracer():
-    def mock_tracer_impl(**kwargs):
-        def decorator(func):
-            @wraps(func)
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    TracingManager.reapply_traced_decorator(mock_tracer_impl)
-    yield
-    TracingManager.reapply_traced_decorator(None)
diff --git a/tests/sdk/services/test_actions_service.py b/tests/sdk/services/test_actions_service.py
deleted file mode 100644
index 9ca03e807..000000000
--- a/tests/sdk/services/test_actions_service.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.actions_service import ActionsService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models import Action
-
-
-@pytest.fixture
-def service(
-    config: Config, execution_context: ExecutionContext, monkeypatch: pytest.MonkeyPatch
-) -> ActionsService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-
-    return ActionsService(config=config, execution_context=execution_context)
-
-
-class TestActionsService:
-    def test_retrieve(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ActionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id",
-            status_code=200,
-            json={"id": 1, "title": "Test Action"},
-        )
-
-        action = service.retrieve(
-            action_key="test-id",
-            app_folder_path="test-folder",
-        )
-
-        assert isinstance(action, Action)
-        assert action.id == 1
-        assert action.title == "Test Action"
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ActionsService.retrieve/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_retrieve_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ActionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id",
-            status_code=200,
-            json={"id": 1, "title": "Test Action"},
-        )
-
-        action = await service.retrieve_async(
-            action_key="test-id",
-            app_folder_path="test-folder",
-        )
-
-        assert isinstance(action, Action)
-        assert action.id == 1
-        assert action.title == "Test Action"
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/tasks/GenericTasks/GetTaskDataByKey?taskKey=test-id"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ActionsService.retrieve_async/{version}"
-        )
-
-    def test_create_with_app_key(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ActionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
-            status_code=200,
-            json={"id": 1, "title": "Test Action"},
-        )
-
-        action = service.create(
-            title="Test Action",
-            app_key="test-app-key",
-            data={"test": "data"},
-        )
-
-        assert isinstance(action, Action)
-        assert action.id == 1
-        assert action.title == "Test Action"
-
-    def test_create_with_assignee(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ActionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        monkeypatch: pytest.MonkeyPatch,
-    ) -> None:
-        monkeypatch.setenv("UIPATH_TENANT_ID", "test-tenant-id")
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}/apps_/default/api/v1/default/deployed-action-apps-schemas?search=test-app",
-            status_code=200,
-            json={
-                "deployed": [
-                    {
-                        "systemName": "test-app",
-                        "actionSchema": {
-                            "key": "test-key",
-                            "inputs": [],
-                            "outputs": [],
-                            "inOuts": [],
-                            "outcomes": [],
-                        },
-                        "deploymentFolder": {"fullyQualifiedName": "test-folder-path"},
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/tasks/AppTasks/CreateAppTask",
-            status_code=200,
-            json={"id": 1, "title": "Test Action"},
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks",
-            status_code=200,
-            json={},
-        )
-
-        action = service.create(
-            title="Test Action",
-            app_name="test-app",
-            data={"test": "data"},
-            assignee="test@example.com",
-        )
-
-        assert isinstance(action, Action)
-        assert action.id == 1
-        assert action.title == "Test Action"
diff --git a/tests/sdk/services/test_assets_service.py b/tests/sdk/services/test_assets_service.py
deleted file mode 100644
index 748613e31..000000000
--- a/tests/sdk/services/test_assets_service.py
+++ /dev/null
@@ -1,279 +0,0 @@
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.assets_service import AssetsService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models import UserAsset
-from uipath.models.assets import Asset
-
-
-@pytest.fixture
-def service(
-    config: Config, execution_context: ExecutionContext, monkeypatch: pytest.MonkeyPatch
-) -> AssetsService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-    return AssetsService(config=config, execution_context=execution_context)
-
-
-class TestAssetsService:
-    class TestRetrieveAsset:
-        def test_retrieve_robot_asset(
-            self,
-            httpx_mock: HTTPXMock,
-            service: AssetsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-            version: str,
-        ) -> None:
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
-                status_code=200,
-                json={"id": 1, "name": "Test Asset", "value": "test-value"},
-            )
-
-            asset = service.retrieve(name="Test Asset")
-
-            assert isinstance(asset, UserAsset)
-            assert asset.id == 1
-            assert asset.name == "Test Asset"
-            assert asset.value == "test-value"
-
-            sent_request = httpx_mock.get_request()
-            if sent_request is None:
-                raise Exception("No request was sent")
-
-            assert sent_request.method == "POST"
-            assert (
-                sent_request.url
-                == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
-            )
-
-            assert HEADER_USER_AGENT in sent_request.headers
-            assert (
-                sent_request.headers[HEADER_USER_AGENT]
-                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve/{version}"
-            )
-
-        def test_retrieve_asset(
-            self,
-            httpx_mock: HTTPXMock,
-            base_url: str,
-            org: str,
-            tenant: str,
-            version: str,
-            config: Config,
-            monkeypatch: pytest.MonkeyPatch,
-        ) -> None:
-            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
-            service = AssetsService(
-                config=config,
-                execution_context=ExecutionContext(),
-            )
-
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?$filter=Name eq 'Test Asset'&$top=1",
-                status_code=200,
-                json={
-                    "value": [
-                        {
-                            "key": "asset-key",
-                            "name": "Test Asset",
-                            "value": "test-value",
-                        }
-                    ]
-                },
-            )
-
-            asset = service.retrieve(name="Test Asset")
-
-            assert isinstance(asset, Asset)
-            assert asset.key == "asset-key"
-            assert asset.name == "Test Asset"
-            assert asset.value == "test-value"
-
-            sent_request = httpx_mock.get_request()
-            if sent_request is None:
-                raise Exception("No request was sent")
-
-            assert sent_request.method == "GET"
-            assert (
-                sent_request.url
-                == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered?%24filter=Name+eq+%27Test+Asset%27&%24top=1"
-            )
-
-            assert HEADER_USER_AGENT in sent_request.headers
-            assert (
-                sent_request.headers[HEADER_USER_AGENT]
-                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve/{version}"
-            )
-
-    def test_retrieve_credential(
-        self,
-        httpx_mock: HTTPXMock,
-        service: AssetsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
-            status_code=200,
-            json={
-                "id": 1,
-                "name": "Test Credential",
-                "credential_username": "test-user",
-                "credential_password": "test-password",
-            },
-        )
-
-        credential = service.retrieve_credential(name="Test Credential")
-
-        assert credential == "test-password"
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve_credential/{version}"
-        )
-
-    def test_retrieve_credential_user_asset(
-        self,
-        service: AssetsService,
-        monkeypatch: pytest.MonkeyPatch,
-        config: Config,
-    ) -> None:
-        with pytest.raises(ValueError):
-            monkeypatch.delenv("UIPATH_ROBOT_KEY", raising=False)
-            service = AssetsService(
-                config=config,
-                execution_context=ExecutionContext(),
-            )
-            service.retrieve_credential(name="Test Credential")
-
-    async def test_retrieve_credential_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: AssetsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        """Test asynchronously retrieving a credential asset."""
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey",
-            status_code=200,
-            json={
-                "id": 1,
-                "name": "Test Credential",
-                "credential_username": "test-user",
-                "credential_password": "test-password",
-            },
-        )
-
-        credential = await service.retrieve_credential_async(name="Test Credential")
-
-        assert credential == "test-password"
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.retrieve_credential_async/{version}"
-        )
-
-    def test_update(
-        self,
-        httpx_mock: HTTPXMock,
-        service: AssetsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey",
-            status_code=200,
-            json={"id": 1, "name": "Test Asset", "value": "updated-value"},
-        )
-
-        asset = UserAsset(name="Test Asset", value="updated-value")
-        response = service.update(robot_asset=asset)
-
-        assert response == {"id": 1, "name": "Test Asset", "value": "updated-value"}
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.update/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_update_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: AssetsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey",
-            status_code=200,
-            json={"id": 1, "name": "Test Asset", "value": "updated-value"},
-        )
-
-        asset = UserAsset(name="Test Asset", value="updated-value")
-        response = await service.update_async(robot_asset=asset)
-
-        assert response == {"id": 1, "name": "Test Asset", "value": "updated-value"}
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.AssetsService.update_async/{version}"
-        )
diff --git a/tests/sdk/services/test_base_service.py b/tests/sdk/services/test_base_service.py
deleted file mode 100644
index 378bdfbe5..000000000
--- a/tests/sdk/services/test_base_service.py
+++ /dev/null
@@ -1,102 +0,0 @@
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services._base_service import BaseService
-from uipath._utils.constants import HEADER_USER_AGENT
-
-
-@pytest.fixture
-def service(config: Config, execution_context: ExecutionContext) -> BaseService:
-    return BaseService(config=config, execution_context=execution_context)
-
-
-class TestBaseService:
-    def test_init_base_service(self, service: BaseService):
-        assert service is not None
-
-    def test_base_service_default_headers(self, service: BaseService, secret: str):
-        assert service.default_headers == {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {secret}",
-        }
-
-    class TestRequest:
-        def test_simple_request(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BaseService,
-            base_url: str,
-            org: str,
-            tenant: str,
-            version: str,
-            secret: str,
-        ):
-            endpoint = "/endpoint"
-
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}{endpoint}",
-                status_code=200,
-                json={"test": "test"},
-            )
-
-            response = service.request("GET", endpoint)
-
-            sent_request = httpx_mock.get_request()
-            if sent_request is None:
-                raise Exception("No request was sent")
-
-            assert sent_request.method == "GET"
-            assert sent_request.url == f"{base_url}{org}{tenant}{endpoint}"
-
-            assert HEADER_USER_AGENT in sent_request.headers
-            assert (
-                sent_request.headers[HEADER_USER_AGENT]
-                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TestRequest.test_simple_request/{version}"
-            )
-            assert sent_request.headers["Authorization"] == f"Bearer {secret}"
-
-            assert response is not None
-            assert response.status_code == 200
-            assert response.json() == {"test": "test"}
-
-    class TestRequestAsync:
-        @pytest.mark.anyio
-        async def test_simple_request_async(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BaseService,
-            base_url: str,
-            org: str,
-            tenant: str,
-            version: str,
-            secret: str,
-        ):
-            endpoint = "/endpoint"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}{endpoint}",
-                status_code=200,
-                json={"test": "test"},
-            )
-
-            response = await service.request_async("GET", endpoint)
-
-            sent_request = httpx_mock.get_request()
-            if sent_request is None:
-                raise Exception("No request was sent")
-
-            assert sent_request.method == "GET"
-            assert sent_request.url == f"{base_url}{org}{tenant}{endpoint}"
-
-            assert HEADER_USER_AGENT in sent_request.headers
-            assert (
-                sent_request.headers[HEADER_USER_AGENT]
-                == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.TestRequestAsync.test_simple_request_async/{version}"
-            )
-            assert sent_request.headers["Authorization"] == f"Bearer {secret}"
-
-            assert response is not None
-            assert response.status_code == 200
-            assert response.json() == {"test": "test"}
diff --git a/tests/sdk/services/test_buckets_service.py b/tests/sdk/services/test_buckets_service.py
deleted file mode 100644
index 251dc2e62..000000000
--- a/tests/sdk/services/test_buckets_service.py
+++ /dev/null
@@ -1,275 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.buckets_service import BucketsService
-
-
-@pytest.fixture
-def service(
-    config: Config, execution_context: ExecutionContext, monkeypatch: pytest.MonkeyPatch
-) -> BucketsService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-    return BucketsService(config=config, execution_context=execution_context)
-
-
-@pytest.fixture
-def temp_file(tmp_path):
-    """Create a temporary file for testing."""
-    file_path = tmp_path / "test.txt"
-    file_path.write_text("test content")
-    return str(file_path)
-
-
-class TestBucketsService:
-    class TestRetrieve:
-        def test_retrieve_by_key(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-        ):
-            bucket_key = "bucket-key"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={bucket_key})",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            bucket = service.retrieve(key=bucket_key)
-            assert bucket.id == 123
-            assert bucket.name == "test-bucket"
-            assert bucket.identifier == "bucket-key"
-
-        def test_retrieve_by_name(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-        ):
-            bucket_name = "test-bucket"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq '{bucket_name}'&$top=1",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            bucket = service.retrieve(name=bucket_name)
-            assert bucket.id == 123
-            assert bucket.name == "test-bucket"
-            assert bucket.identifier == "bucket-key"
-
-        @pytest.mark.asyncio
-        async def test_retrieve_by_key_async(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-        ):
-            bucket_key = "bucket-key"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={bucket_key})",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            bucket = await service.retrieve_async(key=bucket_key)
-            assert bucket.id == 123
-            assert bucket.name == "test-bucket"
-            assert bucket.identifier == "bucket-key"
-
-        @pytest.mark.asyncio
-        async def test_retrieve_by_name_async(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-        ):
-            bucket_name = "test-bucket"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets?$filter=Name eq '{bucket_name}'&$top=1",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            bucket = await service.retrieve_async(name=bucket_name)
-            assert bucket.id == 123
-            assert bucket.name == "test-bucket"
-            assert bucket.identifier == "bucket-key"
-
-    class TestDownload:
-        def test_download(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-            tmp_path: Path,
-        ):
-            bucket_key = "bucket-key"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={bucket_key})",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetReadUri?path=test-file.txt",
-                status_code=200,
-                json={
-                    "Uri": "https://test-storage.com/test-file.txt",
-                    "Headers": {"Keys": [], "Values": []},
-                    "RequiresAuth": False,
-                },
-            )
-
-            httpx_mock.add_response(
-                url="https://test-storage.com/test-file.txt",
-                status_code=200,
-                content=b"test content",
-            )
-
-            destination_path = str(tmp_path / "downloaded.txt")
-            service.download(
-                key=bucket_key,
-                blob_file_path="test-file.txt",
-                destination_path=destination_path,
-            )
-
-            assert os.path.exists(destination_path)
-            with open(destination_path, "rb") as f:
-                assert f.read() == b"test content"
-
-    class TestUpload:
-        def test_upload_from_path(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-            temp_file: str,
-        ):
-            bucket_key = "bucket-key"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={bucket_key})",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetWriteUri?path=test-file.txt&contentType=text/plain",
-                status_code=200,
-                json={
-                    "Uri": "https://test-storage.com/test-file.txt",
-                    "Headers": {"Keys": [], "Values": []},
-                    "RequiresAuth": False,
-                },
-            )
-
-            httpx_mock.add_response(
-                url="https://test-storage.com/test-file.txt",
-                status_code=200,
-                content=b"test content",
-            )
-
-            service.upload(
-                key=bucket_key,
-                blob_file_path="test-file.txt",
-                content_type="text/plain",
-                source_path=temp_file,
-            )
-
-            sent_requests = httpx_mock.get_requests()
-            assert len(sent_requests) == 3
-
-            assert sent_requests[2].method == "PUT"
-            assert sent_requests[2].url == "https://test-storage.com/test-file.txt"
-
-            assert b"test content" in sent_requests[2].content
-
-        def test_upload_from_memory(
-            self,
-            httpx_mock: HTTPXMock,
-            service: BucketsService,
-            base_url: str,
-            org: str,
-            tenant: str,
-        ):
-            bucket_key = "bucket-key"
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={bucket_key})",
-                status_code=200,
-                json={
-                    "value": [
-                        {"Id": 123, "Name": "test-bucket", "Identifier": "bucket-key"}
-                    ]
-                },
-            )
-
-            httpx_mock.add_response(
-                url=f"{base_url}{org}{tenant}/orchestrator_/odata/Buckets(123)/UiPath.Server.Configuration.OData.GetWriteUri?path=test-file.txt&contentType=text/plain",
-                status_code=200,
-                json={
-                    "Uri": "https://test-storage.com/test-file.txt",
-                    "Headers": {"Keys": [], "Values": []},
-                    "RequiresAuth": False,
-                },
-            )
-
-            httpx_mock.add_response(
-                url="https://test-storage.com/test-file.txt",
-                status_code=200,
-                content=b"test content",
-            )
-
-            service.upload(
-                key=bucket_key,
-                blob_file_path="test-file.txt",
-                content_type="text/plain",
-                content="test content",
-            )
-
-            sent_requests = httpx_mock.get_requests()
-            assert len(sent_requests) == 3
-
-            assert sent_requests[2].method == "PUT"
-            assert sent_requests[2].url == "https://test-storage.com/test-file.txt"
-            assert sent_requests[2].content == b"test content"
diff --git a/tests/sdk/services/test_connections_service.py b/tests/sdk/services/test_connections_service.py
deleted file mode 100644
index 274f93af3..000000000
--- a/tests/sdk/services/test_connections_service.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.connections_service import ConnectionsService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models import Connection, ConnectionToken
-
-
-@pytest.fixture
-def service(
-    config: Config, execution_context: ExecutionContext, monkeypatch: pytest.MonkeyPatch
-) -> ConnectionsService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-    return ConnectionsService(config=config, execution_context=execution_context)
-
-
-class TestConnectionsService:
-    def test_retrieve(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ConnectionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        connection_key = "test-connection"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}",
-            status_code=200,
-            json={
-                "id": "test-id",
-                "name": "Test Connection",
-                "state": "active",
-                "elementInstanceId": 123,
-            },
-        )
-
-        connection = service.retrieve(key=connection_key)
-
-        assert isinstance(connection, Connection)
-        assert connection.id == "test-id"
-        assert connection.name == "Test Connection"
-        assert connection.state == "active"
-        assert connection.element_instance_id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_retrieve_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ConnectionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        connection_key = "test-connection"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}",
-            status_code=200,
-            json={
-                "id": "test-id",
-                "name": "Test Connection",
-                "state": "active",
-                "elementInstanceId": 123,
-            },
-        )
-
-        connection = await service.retrieve_async(key=connection_key)
-
-        assert isinstance(connection, Connection)
-        assert connection.id == "test-id"
-        assert connection.name == "Test Connection"
-        assert connection.state == "active"
-        assert connection.element_instance_id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_async/{version}"
-        )
-
-    def test_retrieve_token(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ConnectionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        connection_key = "test-connection"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?type=direct",
-            status_code=200,
-            json={
-                "accessToken": "test-token",
-                "tokenType": "Bearer",
-                "expiresIn": 3600,
-            },
-        )
-
-        token = service.retrieve_token(key=connection_key)
-
-        assert isinstance(token, ConnectionToken)
-        assert token.access_token == "test-token"
-        assert token.token_type == "Bearer"
-        assert token.expires_in == 3600
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?type=direct"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_token/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_retrieve_token_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ConnectionsService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        connection_key = "test-connection"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?type=direct",
-            status_code=200,
-            json={
-                "accessToken": "test-token",
-                "tokenType": "Bearer",
-                "expiresIn": 3600,
-            },
-        )
-
-        token = await service.retrieve_token_async(key=connection_key)
-
-        assert isinstance(token, ConnectionToken)
-        assert token.access_token == "test-token"
-        assert token.token_type == "Bearer"
-        assert token.expires_in == 3600
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "GET"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/connections_/api/v1/Connections/{connection_key}/token?type=direct"
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ConnectionsService.retrieve_token_async/{version}"
-        )
diff --git a/tests/sdk/services/test_context_grounding_service.py b/tests/sdk/services/test_context_grounding_service.py
deleted file mode 100644
index eb7c80e1c..000000000
--- a/tests/sdk/services/test_context_grounding_service.py
+++ /dev/null
@@ -1,334 +0,0 @@
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.buckets_service import BucketsService
-from uipath._services.context_grounding_service import ContextGroundingService
-from uipath._services.folder_service import FolderService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models import ContextGroundingIndex, ContextGroundingQueryResponse
-
-
-@pytest.fixture
-def service(
-    config: Config,
-    execution_context: ExecutionContext,
-    monkeypatch: pytest.MonkeyPatch,
-) -> ContextGroundingService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-    folders_service = FolderService(config=config, execution_context=execution_context)
-    buckets_service = BucketsService(config=config, execution_context=execution_context)
-    return ContextGroundingService(
-        config=config,
-        execution_context=execution_context,
-        folders_service=folders_service,
-        buckets_service=buckets_service,
-    )
-
-
-class TestContextGroundingService:
-    def test_search(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ContextGroundingService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v1/search",
-            status_code=200,
-            json=[
-                {
-                    "source": "test-source",
-                    "page_number": "1",
-                    "content": "Test content",
-                    "metadata": {
-                        "operation_id": "test-op",
-                        "strategy": "test-strategy",
-                    },
-                    "score": 0.95,
-                }
-            ],
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "id": "test-index-id",
-                        "name": "test-index",
-                        "lastIngestionStatus": "Completed",
-                    }
-                ]
-            },
-        )
-
-        response = service.search(
-            name="test-index", query="test query", number_of_results=1
-        )
-
-        assert isinstance(response, list)
-        assert len(response) == 1
-        assert isinstance(response[0], ContextGroundingQueryResponse)
-        assert response[0].source == "test-source"
-        assert response[0].page_number == "1"
-        assert response[0].content == "Test content"
-        assert response[0].metadata.operation_id == "test-op"
-        assert response[0].metadata.strategy == "test-strategy"
-        assert response[0].score == 0.95
-
-        sent_requests = httpx_mock.get_requests()
-        if sent_requests is None:
-            raise Exception("No request was sent")
-
-        assert sent_requests[3].method == "POST"
-        assert sent_requests[3].url == f"{base_url}{org}{tenant}/ecs_/v1/search"
-
-        assert HEADER_USER_AGENT in sent_requests[3].headers
-        assert (
-            sent_requests[3].headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.search/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_search_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ContextGroundingService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v1/search",
-            status_code=200,
-            json=[
-                {
-                    "source": "test-source",
-                    "page_number": "1",
-                    "content": "Test content",
-                    "metadata": {
-                        "operation_id": "test-op",
-                        "strategy": "test-strategy",
-                    },
-                    "score": 0.95,
-                }
-            ],
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "id": "test-index-id",
-                        "name": "test-index",
-                        "lastIngestionStatus": "Completed",
-                    }
-                ]
-            },
-        )
-
-        response = await service.search_async(
-            name="test-index", query="test query", number_of_results=1
-        )
-
-        assert isinstance(response, list)
-        assert len(response) == 1
-        assert isinstance(response[0], ContextGroundingQueryResponse)
-        assert response[0].source == "test-source"
-        assert response[0].page_number == "1"
-        assert response[0].content == "Test content"
-        assert response[0].metadata.operation_id == "test-op"
-        assert response[0].metadata.strategy == "test-strategy"
-        assert response[0].score == 0.95
-
-        sent_requests = httpx_mock.get_requests()
-        if sent_requests is None:
-            raise Exception("No request was sent")
-
-        assert sent_requests[3].method == "POST"
-        assert sent_requests[3].url == f"{base_url}{org}{tenant}/ecs_/v1/search"
-
-        assert HEADER_USER_AGENT in sent_requests[3].headers
-        assert (
-            sent_requests[3].headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.search_async/{version}"
-        )
-
-    def test_retrieve(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ContextGroundingService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "id": "test-index-id",
-                        "name": "test-index",
-                        "lastIngestionStatus": "Completed",
-                    }
-                ]
-            },
-        )
-
-        index = service.retrieve(name="test-index")
-
-        assert isinstance(index, ContextGroundingIndex)
-        assert index.id == "test-index-id"
-        assert index.name == "test-index"
-        assert index.last_ingestion_status == "Completed"
-
-        sent_requests = httpx_mock.get_requests()
-        if sent_requests is None:
-            raise Exception("No request was sent")
-
-        assert sent_requests[1].method == "GET"
-        assert (
-            sent_requests[1].url
-            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24filter=Name+eq+%27test-index%27&%24expand=dataSource"
-        )
-
-        assert HEADER_USER_AGENT in sent_requests[1].headers
-        assert (
-            sent_requests[1].headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve/{version}"
-        )
-
-    @pytest.mark.anyio
-    async def test_retrieve_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ContextGroundingService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser?searchText=test-folder-path&skip=0&take=20",
-            status_code=200,
-            json={
-                "PageItems": [
-                    {
-                        "Key": "test-folder-key",
-                        "FullyQualifiedName": "test-folder-path",
-                    }
-                ]
-            },
-        )
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/ecs_/v2/indexes?$filter=Name eq 'test-index'&$expand=dataSource",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "id": "test-index-id",
-                        "name": "test-index",
-                        "lastIngestionStatus": "Completed",
-                    }
-                ]
-            },
-        )
-
-        index = await service.retrieve_async(name="test-index")
-
-        assert isinstance(index, ContextGroundingIndex)
-        assert index.id == "test-index-id"
-        assert index.name == "test-index"
-        assert index.last_ingestion_status == "Completed"
-
-        sent_requests = httpx_mock.get_requests()
-        if sent_requests is None:
-            raise Exception("No request was sent")
-
-        assert sent_requests[1].method == "GET"
-        assert (
-            sent_requests[1].url
-            == f"{base_url}{org}{tenant}/ecs_/v2/indexes?%24filter=Name+eq+%27test-index%27&%24expand=dataSource"
-        )
-
-        assert HEADER_USER_AGENT in sent_requests[1].headers
-        assert (
-            sent_requests[1].headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ContextGroundingService.retrieve_async/{version}"
-        )
diff --git a/tests/sdk/services/test_llm_service.py b/tests/sdk/services/test_llm_service.py
deleted file mode 100644
index 7df9a4d42..000000000
--- a/tests/sdk/services/test_llm_service.py
+++ /dev/null
@@ -1,83 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.llm_gateway_service import (
-    EmbeddingModels,
-    UiPathOpenAIService,
-)
-from uipath.models.llm_gateway import TextEmbedding
-
-
-class TestOpenAIService:
-    @pytest.fixture
-    def config(self):
-        return Config(base_url="https://example.com", secret="test_secret")
-
-    @pytest.fixture
-    def execution_context(self):
-        return ExecutionContext()
-
-    @pytest.fixture
-    def openai_service(self, config, execution_context):
-        return UiPathOpenAIService(config=config, execution_context=execution_context)
-
-    def test_init(self, config, execution_context):
-        service = UiPathOpenAIService(
-            config=config, execution_context=execution_context
-        )
-        assert service._config == config
-        assert service._execution_context == execution_context
-
-    @patch.object(UiPathOpenAIService, "request_async")
-    @pytest.mark.asyncio
-    async def test_embeddings(self, mock_request, openai_service):
-        # Mock response
-        mock_response = MagicMock()
-        mock_response.json.return_value = {
-            "data": [{"embedding": [0.1, 0.2, 0.3], "index": 0, "object": "embedding"}],
-            "model": "text-embedding-ada-002",
-            "object": "list",
-            "usage": {"prompt_tokens": 4, "total_tokens": 4},
-        }
-        mock_request.return_value = mock_response
-
-        # Call the method
-        result = await openai_service.embeddings(input="Test input")
-
-        # Assertions
-        mock_request.assert_called_once()
-        assert isinstance(result, TextEmbedding)
-        assert result.data[0].embedding == [0.1, 0.2, 0.3]
-        assert result.model == "text-embedding-ada-002"
-        assert result.usage.prompt_tokens == 4
-
-    @patch.object(UiPathOpenAIService, "request_async")
-    @pytest.mark.asyncio
-    async def test_embeddings_with_custom_model(self, mock_request, openai_service):
-        # Mock response
-        mock_response = MagicMock()
-        mock_response.json.return_value = {
-            "data": [{"embedding": [0.1, 0.2, 0.3], "index": 0, "object": "embedding"}],
-            "model": "text-embedding-3-large",
-            "object": "list",
-            "usage": {"prompt_tokens": 4, "total_tokens": 4},
-        }
-        mock_request.return_value = mock_response
-
-        # Call the method with custom model
-        result = await openai_service.embeddings(
-            input="Test input", embedding_model=EmbeddingModels.text_embedding_3_large
-        )
-
-        # Assertions for the result
-        mock_request.assert_called_once()
-        assert result.model == "text-embedding-3-large"
-        assert len(result.data) == 1
-        assert result.data[0].embedding == [0.1, 0.2, 0.3]
-        assert result.data[0].index == 0
-        assert result.object == "list"
-        assert result.usage.prompt_tokens == 4
-        assert result.usage.total_tokens == 4
diff --git a/tests/sdk/services/test_processes_service.py b/tests/sdk/services/test_processes_service.py
deleted file mode 100644
index ea4731cbe..000000000
--- a/tests/sdk/services/test_processes_service.py
+++ /dev/null
@@ -1,254 +0,0 @@
-import json
-
-import pytest
-from pytest_httpx import HTTPXMock
-
-from uipath._config import Config
-from uipath._execution_context import ExecutionContext
-from uipath._services.processes_service import ProcessesService
-from uipath._utils.constants import HEADER_USER_AGENT
-from uipath.models.job import Job
-
-
-@pytest.fixture
-def service(
-    config: Config,
-    execution_context: ExecutionContext,
-    monkeypatch: pytest.MonkeyPatch,
-) -> ProcessesService:
-    monkeypatch.setenv("UIPATH_FOLDER_PATH", "test-folder-path")
-    return ProcessesService(config=config, execution_context=execution_context)
-
-
-class TestProcessesService:
-    def test_invoke(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ProcessesService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        process_name = "test-process"
-        input_arguments = {"key": "value"}
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "Key": "test-job-key",
-                        "State": "Running",
-                        "StartTime": "2024-01-01T00:00:00Z",
-                        "Id": 123,
-                    }
-                ]
-            },
-        )
-
-        job = service.invoke(process_name, input_arguments)
-
-        assert isinstance(job, Job)
-        assert job.key == "test-job-key"
-        assert job.state == "Running"
-        assert job.start_time == "2024-01-01T00:00:00Z"
-        assert job.id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-        )
-        assert sent_request.content.decode("utf-8") == str(
-            {
-                "startInfo": {
-                    "ReleaseName": process_name,
-                    "InputArguments": json.dumps(input_arguments),
-                }
-            }
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke/{version}"
-        )
-
-    def test_invoke_without_input_arguments(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ProcessesService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        process_name = "test-process"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "Key": "test-job-key",
-                        "State": "Running",
-                        "StartTime": "2024-01-01T00:00:00Z",
-                        "Id": 123,
-                    }
-                ]
-            },
-        )
-
-        job = service.invoke(process_name)
-
-        assert isinstance(job, Job)
-        assert job.key == "test-job-key"
-        assert job.state == "Running"
-        assert job.start_time == "2024-01-01T00:00:00Z"
-        assert job.id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-        )
-        assert sent_request.content.decode("utf-8") == str(
-            {
-                "startInfo": {
-                    "ReleaseName": process_name,
-                    "InputArguments": "{}",
-                }
-            }
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke/{version}"
-        )
-
-    @pytest.mark.asyncio
-    async def test_invoke_async(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ProcessesService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        process_name = "test-process"
-        input_arguments = {"key": "value"}
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "Key": "test-job-key",
-                        "State": "Running",
-                        "StartTime": "2024-01-01T00:00:00Z",
-                        "Id": 123,
-                    }
-                ]
-            },
-        )
-
-        job = await service.invoke_async(process_name, input_arguments)
-
-        assert isinstance(job, Job)
-        assert job.key == "test-job-key"
-        assert job.state == "Running"
-        assert job.start_time == "2024-01-01T00:00:00Z"
-        assert job.id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-        )
-        assert sent_request.content.decode("utf-8") == str(
-            {
-                "startInfo": {
-                    "ReleaseName": process_name,
-                    "InputArguments": json.dumps(input_arguments),
-                }
-            }
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke_async/{version}"
-        )
-
-    @pytest.mark.asyncio
-    async def test_invoke_async_without_input_arguments(
-        self,
-        httpx_mock: HTTPXMock,
-        service: ProcessesService,
-        base_url: str,
-        org: str,
-        tenant: str,
-        version: str,
-    ) -> None:
-        process_name = "test-process"
-        httpx_mock.add_response(
-            url=f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs",
-            status_code=200,
-            json={
-                "value": [
-                    {
-                        "Key": "test-job-key",
-                        "State": "Running",
-                        "StartTime": "2024-01-01T00:00:00Z",
-                        "Id": 123,
-                    }
-                ]
-            },
-        )
-
-        job = await service.invoke_async(process_name)
-
-        assert isinstance(job, Job)
-        assert job.key == "test-job-key"
-        assert job.state == "Running"
-        assert job.start_time == "2024-01-01T00:00:00Z"
-        assert job.id == 123
-
-        sent_request = httpx_mock.get_request()
-        if sent_request is None:
-            raise Exception("No request was sent")
-
-        assert sent_request.method == "POST"
-        assert (
-            sent_request.url
-            == f"{base_url}{org}{tenant}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-        )
-        assert sent_request.content.decode("utf-8") == str(
-            {
-                "startInfo": {
-                    "ReleaseName": process_name,
-                    "InputArguments": "{}",
-                }
-            }
-        )
-
-        assert HEADER_USER_AGENT in sent_request.headers
-        assert (
-            sent_request.headers[HEADER_USER_AGENT]
-            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.ProcessesService.invoke_async/{version}"
-        )
diff --git a/tests/sdk/test_bindings_inference.py b/tests/sdk/test_bindings_inference.py
deleted file mode 100644
index c86ad6990..000000000
--- a/tests/sdk/test_bindings_inference.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from uipath._utils._infer_bindings import infer_bindings
-
-
-@pytest.fixture
-def mock_read_resource_overwrites():
-    with patch("uipath._utils._infer_bindings.read_resource_overwrites") as mock:
-        yield mock
-
-
-class TestBindingsInference:
-    def test_infer_bindings_overwrites_name_and_folder_path(
-        self, mock_read_resource_overwrites
-    ):
-        mock_cm = MagicMock()
-        mock_cm.__enter__.return_value = ("new_name", "new_folder")
-        mock_read_resource_overwrites.return_value = mock_cm
-
-        @infer_bindings(resource_type="bucket")
-        def dummy_func(name, folder_path):
-            return name, folder_path
-
-        result = dummy_func("old_name", "old_folder")
-        assert result == ("new_name", "new_folder")
-        mock_read_resource_overwrites.assert_called_once_with(
-            "bucket", "old_name", "old_folder"
-        )
-
-    def test_infer_bindings_skips_when_no_name_and_folder_path(
-        self, mock_read_resource_overwrites
-    ):
-        @infer_bindings(resource_type="bucket")
-        def dummy_func(other_arg):
-            return other_arg
-
-        result = dummy_func("some_value")
-        assert result == "some_value"
-        mock_read_resource_overwrites.assert_not_called()
-
-    def test_infer_bindings_only_name_present(self, mock_read_resource_overwrites):
-        mock_cm = MagicMock()
-        mock_cm.__enter__.return_value = ("new_name", None)
-        mock_read_resource_overwrites.return_value = mock_cm
-
-        @infer_bindings(resource_type="asset")
-        def dummy_func(name, folder_path=None):
-            return name, folder_path
-
-        result = dummy_func("old_name")
-        assert result == ("new_name", None)
-        mock_read_resource_overwrites.assert_called_once_with("asset", "old_name", None)
diff --git a/tests/sdk/test_overwrites.py b/tests/sdk/test_overwrites.py
deleted file mode 100644
index bd3b8e67d..000000000
--- a/tests/sdk/test_overwrites.py
+++ /dev/null
@@ -1,121 +0,0 @@
-import json
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import pytest
-
-from uipath._utils._read_overwrites import OverwritesManager
-
-if TYPE_CHECKING:
-    from pytest_mock.plugin import MockerFixture
-
-
-@pytest.fixture
-def mock_overwrites_file(tmp_path: Path) -> Path:
-    overwrites_data = {
-        "runtime": {
-            "outputFile": "output.json",
-            "internalArguments": {
-                "resourceOverwrites": {
-                    "asset.MyAsset": {
-                        "name": "NewAssetName",
-                        "folderPath": "Root/Dev/Assets",
-                    },
-                    "process.MyProcess": {
-                        "name": "NewProcessName",
-                        "folderPath": "Root/Dev/Processes",
-                    },
-                    "library.MyLibrary": {
-                        "name": "NewLibraryName",
-                        "folderPath": "Root/Dev/Libraries",
-                    },
-                }
-            },
-        }
-    }
-
-    file_path = tmp_path / "uipath.json"
-    with open(file_path, "w") as f:
-        json.dump(overwrites_data, f)
-
-    return file_path
-
-
-def test_get_overwrite_asset(
-    mock_overwrites_file: Path, mocker: "MockerFixture"
-) -> None:
-    """Test getting an asset overwrite value.
-
-    Args:
-        mock_overwrites_file: Path to the mock overwrites file.
-        mocker: Pytest mocker fixture.
-    """
-    print(f"Mock overwrites file: {mock_overwrites_file}")
-    manager = OverwritesManager(mock_overwrites_file)
-    result = manager.get_overwrite("asset", "MyAsset")
-    assert result == ("NewAssetName", "Root/Dev/Assets")
-
-
-def test_get_overwrite_process(mock_overwrites_file: Path) -> None:
-    """Test getting a process overwrite value.
-
-    Args:
-        mock_overwrites_file: Path to the mock overwrites file.
-        mocker: Pytest mocker fixture.
-    """
-    manager = OverwritesManager(mock_overwrites_file)
-    result = manager.get_overwrite("process", "MyProcess")
-    assert result == ("NewProcessName", "Root/Dev/Processes")
-
-
-def test_get_overwrite_library(mock_overwrites_file: Path) -> None:
-    """Test getting a library overwrite value.
-
-    Args:
-        mock_overwrites_file: Path to the mock overwrites file.
-        mocker: Pytest mocker fixture.
-    """
-    manager = OverwritesManager(mock_overwrites_file)
-    result = manager.get_overwrite("library", "MyLibrary")
-    assert result == ("NewLibraryName", "Root/Dev/Libraries")
-
-
-def test_get_overwrite_not_found(mock_overwrites_file: Path) -> None:
-    """Test getting an overwrite value that doesn't exist.
-
-    Args:
-        mock_overwrites_file: Path to the mock overwrites file.
-        mocker: Pytest mocker fixture.
-    """
-    manager = OverwritesManager(mock_overwrites_file)
-    result = manager.get_overwrite("process", "NonexistentProcess")
-    assert result is None
-
-
-def test_get_overwrite_empty_file(tmp_path: Path) -> None:
-    """Test getting an overwrite value from an empty file.
-
-    Args:
-        mocker: Pytest mocker fixture.
-        tmp_path: Pytest temporary path fixture.
-    """
-    file_path = tmp_path / "uipath.json"
-    with open(file_path, "w") as f:
-        json.dump({}, f)
-
-    manager = OverwritesManager(file_path)
-    result = manager.get_overwrite("process", "MyProcess")
-    assert result is None
-
-
-def test_get_overwrite_missing_file(tmp_path: Path) -> None:
-    """Test getting an overwrite value when file doesn't exist.
-
-    Args:
-        mocker: Pytest mocker fixture.
-        tmp_path: Pytest temporary path fixture.
-    """
-    file_path = tmp_path / "nonexistent.json"
-    manager = OverwritesManager(file_path)
-    result = manager.get_overwrite("process", "MyProcess")
-    assert result is None
diff --git a/tests/tracing/test_otel_exporters.py b/tests/tracing/test_otel_exporters.py
deleted file mode 100644
index 06620c720..000000000
--- a/tests/tracing/test_otel_exporters.py
+++ /dev/null
@@ -1,190 +0,0 @@
-import os
-from unittest.mock import MagicMock, patch
-
-import pytest
-from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import SpanExportResult
-
-from uipath.tracing._otel_exporters import LlmOpsHttpExporter
-
-
-@pytest.fixture
-def mock_env_vars():
-    """Fixture to set and clean up environment variables for testing."""
-    original_values = {}
-
-    # Save original values
-    for var in ["UIPATH_URL", "UIPATH_ACCESS_TOKEN"]:
-        original_values[var] = os.environ.get(var)
-
-    # Set test values
-    os.environ["UIPATH_URL"] = "https://test.uipath.com/org/tenant/"
-    os.environ["UIPATH_ACCESS_TOKEN"] = "test-token"
-
-    yield
-
-    # Restore original values
-    for var, value in original_values.items():
-        if value is None:
-            if var in os.environ:
-                del os.environ[var]
-        else:
-            os.environ[var] = value
-
-
-@pytest.fixture
-def mock_span():
-    """Create a mock ReadableSpan for testing."""
-    span = MagicMock(spec=ReadableSpan)
-    return span
-
-
-@pytest.fixture
-def exporter(mock_env_vars):
-    """Create an exporter instance for testing."""
-    with patch("uipath.tracing._otel_exporters.httpx.Client"):
-        exporter = LlmOpsHttpExporter()
-        # Mock _build_url to include query parameters as in the actual implementation
-        exporter._build_url = MagicMock(  # type: ignore
-            return_value="https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots"
-        )
-        yield exporter
-
-
-def test_init_with_env_vars(mock_env_vars):
-    """Test initialization with environment variables."""
-    with patch("uipath.tracing._otel_exporters.httpx.Client"):
-        exporter = LlmOpsHttpExporter()
-
-        assert exporter.base_url == "https://test.uipath.com/org/tenant"
-        assert exporter.auth_token == "test-token"
-        assert exporter.headers == {
-            "Content-Type": "application/json",
-            "Authorization": "Bearer test-token",
-        }
-
-
-def test_init_with_default_url():
-    """Test initialization with default URL when environment variable is not set."""
-    with (
-        patch("uipath.tracing._otel_exporters.httpx.Client"),
-        patch.dict(os.environ, {"UIPATH_ACCESS_TOKEN": "test-token"}, clear=True),
-    ):
-        exporter = LlmOpsHttpExporter()
-
-        assert exporter.base_url == "https://cloud.uipath.com/dummyOrg/dummyTennant"
-        assert exporter.auth_token == "test-token"
-
-
-def test_export_success(exporter, mock_span):
-    """Test successful export of spans."""
-    mock_uipath_span = MagicMock()
-    mock_uipath_span.to_dict.return_value = {"span": "data", "TraceId": "test-trace-id"}
-
-    with patch(
-        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
-        return_value=mock_uipath_span,
-    ):
-        mock_response = MagicMock()
-        mock_response.status_code = 200
-        exporter.http_client.post.return_value = mock_response
-
-        result = exporter.export([mock_span])
-
-        assert result == SpanExportResult.SUCCESS
-        exporter._build_url.assert_called_once_with(
-            [{"span": "data", "TraceId": "test-trace-id"}]
-        )
-        exporter.http_client.post.assert_called_once_with(
-            "https://test.uipath.com/org/tenant/llmopstenant_/api/Traces/spans?traceId=test-trace-id&source=Robots",
-            json=[{"span": "data", "TraceId": "test-trace-id"}],
-        )
-
-
-def test_export_failure(exporter, mock_span):
-    """Test export failure with multiple retries."""
-    mock_uipath_span = MagicMock()
-    mock_uipath_span.to_dict.return_value = {"span": "data"}
-
-    with patch(
-        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
-        return_value=mock_uipath_span,
-    ):
-        mock_response = MagicMock()
-        mock_response.status_code = 500
-        mock_response.text = "Internal Server Error"
-        exporter.http_client.post.return_value = mock_response
-
-        with patch("uipath.tracing._otel_exporters.time.sleep") as mock_sleep:
-            result = exporter.export([mock_span])
-
-        assert result == SpanExportResult.FAILURE
-        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
-        assert (
-            mock_sleep.call_count == 3
-        )  # Should sleep between retries (except after the last one)
-
-
-def test_export_exception(exporter, mock_span):
-    """Test export with exceptions during HTTP request."""
-    mock_uipath_span = MagicMock()
-    mock_uipath_span.to_dict.return_value = {"span": "data"}
-
-    with patch(
-        "uipath.tracing._otel_exporters._SpanUtils.otel_span_to_uipath_span",
-        return_value=mock_uipath_span,
-    ):
-        exporter.http_client.post.side_effect = Exception("Connection error")
-
-        with patch("uipath.tracing._otel_exporters.time.sleep"):
-            result = exporter.export([mock_span])
-
-        assert result == SpanExportResult.FAILURE
-        assert exporter.http_client.post.call_count == 4  # Default max_retries is 3
-
-
-def test_force_flush(exporter):
-    """Test force_flush returns True."""
-    assert exporter.force_flush() is True
-
-
-def test_get_base_url():
-    """Test _get_base_url method with different environment configurations."""
-    # Test with environment variable set
-    with patch.dict(
-        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"}, clear=True
-    ):
-        with patch("uipath.tracing._otel_exporters.httpx.Client"):
-            exporter = LlmOpsHttpExporter()
-            assert exporter.base_url == "https://custom.uipath.com/org/tenant"
-
-    # Test with environment variable set but with no trailing slash
-    with patch.dict(
-        os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant"}, clear=True
-    ):
-        with patch("uipath.tracing._otel_exporters.httpx.Client"):
-            exporter = LlmOpsHttpExporter()
-            assert exporter.base_url == "https://custom.uipath.com/org/tenant"
-
-    # Test with no environment variable
-    with patch.dict(os.environ, {}, clear=True):
-        with patch("uipath.tracing._otel_exporters.httpx.Client"):
-            exporter = LlmOpsHttpExporter()
-            assert exporter.base_url == "https://cloud.uipath.com/dummyOrg/dummyTennant"
-
-
-def test_send_with_retries_success():
-    """Test _send_with_retries method with successful response."""
-    with patch("uipath.tracing._otel_exporters.httpx.Client"):
-        exporter = LlmOpsHttpExporter()
-
-        mock_response = MagicMock()
-        mock_response.status_code = 200
-        exporter.http_client.post.return_value = mock_response  # type: ignore
-
-        result = exporter._send_with_retries("http://example.com", [{"span": "data"}])
-
-        assert result == SpanExportResult.SUCCESS
-        exporter.http_client.post.assert_called_once_with(  # type: ignore
-            "http://example.com", json=[{"span": "data"}]
-        )
diff --git a/tests/tracing/test_span_utils.py b/tests/tracing/test_span_utils.py
deleted file mode 100644
index ae9a2b71a..000000000
--- a/tests/tracing/test_span_utils.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import inspect
-import json
-import os
-import uuid
-from datetime import datetime
-from unittest.mock import Mock, patch
-
-from opentelemetry.sdk.trace import Span as OTelSpan
-from opentelemetry.trace import SpanContext, StatusCode
-
-from uipath.tracing._utils import UiPathSpan, _SpanUtils
-
-
-class TestUUIDMapper:
-    def test_trace_id_to_uuid4(self):
-        """Test that trace_id_to_uuid4 converts trace IDs to valid UUID4 format."""
-        trace_id = int("1234567890ABCDEF1234567890ABCDEF", 16)  # 128-bit trace ID
-
-        # Convert to UUID
-        uuid_obj = _SpanUtils.trace_id_to_uuid4(trace_id)
-
-        # Check that it's a valid UUID4
-        assert uuid_obj.version == 4
-        assert uuid_obj.variant == uuid.RFC_4122
-
-        # Check that the same trace_id always maps to the same UUID
-        uuid_obj2 = _SpanUtils.trace_id_to_uuid4(trace_id)
-        assert uuid_obj == uuid_obj2
-
-    def test_span_id_to_uuid4_deterministic(self):
-        """Test that span_id_to_uuid4 is deterministic for the same span_id."""
-        span_id = 0x1234567890ABCDEF  # 64-bit span ID
-
-        # Convert to UUID twice
-        uuid_obj1 = _SpanUtils.span_id_to_uuid4(span_id)
-        uuid_obj2 = _SpanUtils.span_id_to_uuid4(span_id)
-
-        # They should be the same
-        assert uuid_obj1 == uuid_obj2
-
-        # Check that it's a valid UUID4
-        assert uuid_obj1.version == 4
-        assert uuid_obj1.variant == uuid.RFC_4122
-
-    def test_span_id_to_uuid4_different_ids(self):
-        """Test that different span_ids map to different UUIDs."""
-        span_id1 = 0x1234567890ABCDEF  # 64-bit span ID
-        span_id2 = 0x2345678901BCDEF0  # Different 64-bit span ID
-
-        # Convert to UUIDs
-        uuid_obj1 = _SpanUtils.span_id_to_uuid4(span_id1)
-        uuid_obj2 = _SpanUtils.span_id_to_uuid4(span_id2)
-
-        # They should be different
-        assert uuid_obj1 != uuid_obj2
-
-        # But both should be valid UUID4
-        assert uuid_obj1.version == 4
-        assert uuid_obj1.variant == uuid.RFC_4122
-        assert uuid_obj2.version == 4
-        assert uuid_obj2.variant == uuid.RFC_4122
-
-
-class TestSpanUtils:
-    @patch.dict(
-        os.environ,
-        {
-            "UIPATH_ORGANIZATION_ID": "test-org",
-            "UIPATH_TENANT_ID": "test-tenant",
-            "UIPATH_FOLDER_KEY": "test-folder",
-            "UIPATH_PROCESS_UUID": "test-process",
-            "UIPATH_JOB_KEY": "test-job",
-        },
-    )
-    def test_otel_span_to_uipath_span(self):
-        # Create a mock OTel span
-        mock_span = Mock(spec=OTelSpan)
-
-        # Set span context
-        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
-        span_id = 0x0123456789ABCDEF
-        mock_context = SpanContext(trace_id=trace_id, span_id=span_id, is_remote=False)
-        mock_span.get_span_context.return_value = mock_context
-
-        # Set span properties
-        mock_span.name = "test-span"
-        mock_span.parent = None
-        mock_span.status.status_code = StatusCode.OK
-        mock_span.attributes = {
-            "key1": "value1",
-            "key2": 123,
-            "span_type": "CustomSpanType",
-        }
-        mock_span.events = []
-        mock_span.links = []
-
-        # Set times
-        current_time_ns = int(datetime.now().timestamp() * 1e9)
-        mock_span.start_time = current_time_ns
-        mock_span.end_time = current_time_ns + 1000000  # 1ms later
-
-        # Convert to UiPath span
-        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
-
-        # Verify the conversion
-        assert isinstance(uipath_span, UiPathSpan)
-        assert uipath_span.name == "test-span"
-        assert uipath_span.status == 1  # OK
-        assert uipath_span.span_type == "CustomSpanType"
-
-        # Verify attributes
-        attributes = json.loads(uipath_span.attributes)
-        assert attributes["key1"] == "value1"
-        assert attributes["key2"] == 123
-
-        # Test with error status
-        mock_span.status.description = "Test error description"
-        mock_span.status.status_code = StatusCode.ERROR
-        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
-        assert uipath_span.status == 2  # Error
-
-    @patch.dict(os.environ, {"UIPATH_TRACE_ID": "00000000-0000-4000-8000-000000000000"})
-    def test_otel_span_to_uipath_span_with_env_trace_id(self):
-        # Create a mock OTel span
-        mock_span = Mock(spec=OTelSpan)
-
-        # Set span context
-        trace_id = 0x123456789ABCDEF0123456789ABCDEF0
-        span_id = 0x0123456789ABCDEF
-        mock_context = SpanContext(
-            trace_id=trace_id,
-            span_id=span_id,
-            is_remote=False,
-        )
-        mock_span.get_span_context.return_value = mock_context
-
-        # Set span properties
-        mock_span.name = "test-span"
-        mock_span.parent = None
-        mock_span.status.status_code = StatusCode.OK
-        mock_span.attributes = {}
-        mock_span.events = []
-        mock_span.links = []
-
-        # Set times
-        current_time_ns = int(datetime.now().timestamp() * 1e9)
-        mock_span.start_time = current_time_ns
-        mock_span.end_time = current_time_ns + 1000000  # 1ms later
-
-        # Convert to UiPath span
-        uipath_span = _SpanUtils.otel_span_to_uipath_span(mock_span)
-
-        # Verify the trace ID is taken from environment
-        assert str(uipath_span.trace_id) == "00000000-0000-4000-8000-000000000000"
-
-    def test_format_args_for_trace(self):
-        # Simple function signature
-        def func1(a, b, c=3):
-            pass
-
-        sig = inspect.signature(func1)
-        result = _SpanUtils.format_args_for_trace(sig, 1, 2)
-        assert result == {"a": 1, "b": 2, "c": 3}
-
-        # Test with kwargs
-        result = _SpanUtils.format_args_for_trace(sig, 1, c=4, b=5)
-        assert result == {"a": 1, "b": 5, "c": 4}
-
-        # Function with self parameter
-        class TestClass:
-            def method(self, x, y):
-                pass
-
-        sig = inspect.signature(TestClass.method)
-        result = _SpanUtils.format_args_for_trace(sig, TestClass(), 10, 20)
-        assert result == {"x": 10, "y": 20}
-
-        # Function with **kwargs
-        def func2(a, **kwargs):
-            pass
-
-        sig = inspect.signature(func2)
-        result = _SpanUtils.format_args_for_trace(sig, 1, b=2, c=3)
-        assert result == {"a": 1, "b": 2, "c": 3}
-
-    def test_format_args_for_trace_json(self):
-        def sample_func(a, b=None):
-            pass
-
-        sig = inspect.signature(sample_func)
-
-        # Test with simple args
-        json_result = _SpanUtils.format_args_for_trace_json(sig, 1, b="test")
-        parsed = json.loads(json_result)
-        assert parsed == {"a": 1, "b": "test"}
-
-        # Test with non-serializable object
-        class NonSerializable:
-            pass
-
-        json_result = _SpanUtils.format_args_for_trace_json(sig, 1, b=NonSerializable())
-        # Should not raise exception
-        parsed = json.loads(json_result)
-        assert parsed["a"] == 1
-        assert "b" in parsed  # The value will be a string representation
diff --git a/tests/tracing/test_traced.py b/tests/tracing/test_traced.py
deleted file mode 100644
index 252cf4afd..000000000
--- a/tests/tracing/test_traced.py
+++ /dev/null
@@ -1,574 +0,0 @@
-import json
-from asyncio import sleep
-from dataclasses import asdict, dataclass
-from typing import Any, Dict, List, Sequence
-
-import pytest
-from opentelemetry import trace
-from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
-from opentelemetry.sdk.trace.export import (
-    SimpleSpanProcessor,
-    SpanExporter,
-    SpanExportResult,
-)
-
-from uipath.tracing._traced import traced
-
-
-class InMemorySpanExporter(SpanExporter):
-    """An OpenTelemetry span exporter that stores spans in memory for testing."""
-
-    def __init__(self):
-        self.spans = []
-        self.is_shutdown = False
-
-    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
-        if self.is_shutdown:
-            return SpanExportResult.FAILURE
-
-        self.spans.extend(spans)
-        return SpanExportResult.SUCCESS
-
-    def get_exported_spans(self) -> List[ReadableSpan]:
-        return self.spans
-
-    def clear_exported_spans(self) -> None:
-        self.spans = []
-
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
-        return not self.is_shutdown
-
-    def shutdown(self) -> None:
-        self.is_shutdown = True
-
-
-@pytest.fixture
-def setup_tracer():
-    # Setup InMemorySpanExporter and TracerProvider
-    exporter = InMemorySpanExporter()
-    provider = TracerProvider()
-    trace.set_tracer_provider(provider)
-    trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(exporter))  # type: ignore
-
-    yield exporter, provider
-
-
-def test_traced_sync_function(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced()
-    def sample_function(x, y):
-        return x + y
-
-    result = sample_function(2, 3)
-    assert result == 5
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-    assert span.name == "sample_function"
-    assert span.attributes["span_type"] == "function_call_sync"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "5"
-
-
-@pytest.mark.asyncio
-async def test_traced_async_function(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced()
-    async def sample_async_function(x, y):
-        return x * y
-
-    result = await sample_async_function(2, 3)
-    assert result == 6
-
-    provider.shutdown()  # Ensure spans are flushed
-
-    await sleep(1)
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-    assert span.name == "sample_async_function"
-    assert span.attributes["span_type"] == "function_call_async"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "6"
-
-
-def test_traced_generator_function(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced()
-    def sample_generator_function(n):
-        for i in range(n):
-            yield i
-
-    results = list(sample_generator_function(3))
-    assert results == [0, 1, 2]
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-    assert span.name == "sample_generator_function"
-    assert span.attributes["span_type"] == "function_call_generator_sync"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "[0, 1, 2]"
-
-
-@pytest.mark.asyncio
-async def test_traced_async_generator_function(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced()
-    async def sample_async_generator_function(n):
-        for i in range(n):
-            yield i
-
-    results = [item async for item in sample_async_generator_function(3)]
-    assert results == [0, 1, 2]
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-    assert span.name == "sample_async_generator_function"
-    assert span.attributes["span_type"] == "function_call_generator_async"
-    assert "inputs" in span.attributes
-    assert "output" in span.attributes
-    assert span.attributes["output"] == "[0, 1, 2]"
-
-
-def test_traced_with_basic_processors(setup_tracer):
-    """Test traced decorator with basic input and output processors."""
-    exporter, provider = setup_tracer
-
-    def double_input(inputs):
-        """Double numeric inputs."""
-        result = inputs.copy()
-        for key, value in result.items():
-            if isinstance(value, (int, float)):
-                result[key] = value * 2
-        return result
-
-    def format_output(output):
-        """Format the output as a string."""
-        return {"result": str(output)}
-
-    @traced(input_processor=double_input, output_processor=format_output)
-    def multiply(x, y):
-        return x * y
-
-    # Original function behavior should be unchanged
-    result = multiply(3, 4)
-    assert result == 12
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Check that input processor was applied (doubles the inputs)
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs["x"] == 6  # 3 doubled to 6
-    assert inputs["y"] == 8  # 4 doubled to 8
-
-    # Check that output processor was applied (formatted as string in dict)
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert output == {"result": "12"}  # Result wrapped in dict with string conversion
-
-
-@pytest.mark.asyncio
-async def test_traced_async_with_basic_processors(setup_tracer):
-    """Test traced decorator with basic processors for async functions."""
-    exporter, provider = setup_tracer
-
-    def add_context(inputs):
-        """Add context to inputs."""
-        result = inputs.copy()
-        result["context"] = "test"
-        return result
-
-    def add_timestamp(output):
-        """Add a timestamp to output."""
-        if isinstance(output, dict):
-            result = output.copy()
-            result["processed"] = True
-            return result
-        return {"value": output, "processed": True}
-
-    @traced(input_processor=add_context, output_processor=add_timestamp)
-    async def async_operation(message):
-        await sleep(0.1)
-        return {"status": "completed", "message": message}
-
-    # Original function behavior should be unchanged
-    result = await async_operation("hello")
-    assert result == {"status": "completed", "message": "hello"}
-
-    provider.shutdown()  # Ensure spans are flushed
-    await sleep(0.1)  # Give time for spans to be processed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Check that input processor was applied
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs["message"] == "hello"
-    assert inputs["context"] == "test"  # Added by processor
-
-    # Check that output processor was applied
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert output["status"] == "completed"
-    assert output["message"] == "hello"
-    assert output["processed"] is True  # Added by processor
-
-
-def mask_credit_card(inputs: Dict[str, Any]) -> Dict[str, Any]:
-    """Process inputs to mask credit card information."""
-    processed = inputs.copy()
-    if "card_number" in processed:
-        if len(processed["card_number"]) >= 4:
-            # Keep only the last 4 digits
-            processed["card_number"] = "**** **** **** " + processed["card_number"][-4:]
-        else:
-            processed["card_number"] = "****"
-    return processed
-
-
-def anonymize_single_user_data(output_dict: Dict[str, Any]) -> Dict[str, Any]:
-    """Process a single dictionary to anonymize user information."""
-    processed = output_dict.copy()
-    if "user_info" in processed and isinstance(processed["user_info"], dict):
-        user_info = processed["user_info"].copy()
-        if "name" in user_info:
-            user_info["name"] = "Anonymous User"
-        if "email" in user_info:
-            user_info["email"] = "anonymous@example.com"
-        processed["user_info"] = user_info
-    return processed
-
-
-def anonymize_user_data(output: Any) -> Any:
-    """Process outputs to anonymize user information."""
-    # Handle list of outputs (from generators)
-    if isinstance(output, list):
-        processed_outputs = []
-        for item in output:
-            if isinstance(item, dict):
-                processed_outputs.append(anonymize_single_user_data(item))
-            else:
-                processed_outputs.append(item)
-        return processed_outputs
-
-    # Handle single dictionary output
-    if not isinstance(output, dict):
-        return output
-
-    return anonymize_single_user_data(output)
-
-
-def dataclass_to_dict(obj):
-    """Convert a dataclass instance or list of dataclass instances to dict(s)."""
-    if isinstance(obj, list):
-        return [dataclass_to_dict(item) for item in obj]
-
-    # Check if object is a dataclass (has __dataclass_fields__ attribute)
-    if hasattr(obj, "__dataclass_fields__"):
-        return asdict(obj)
-
-    return obj
-
-
-# Example of a processor that handles dataclasses
-def process_dataclass_output(output):
-    """Process output that might be a dataclass or contain dataclasses."""
-    # First convert to dict if it's a dataclass
-    data = dataclass_to_dict(output)
-
-    # Now apply regular dict processing
-    if isinstance(data, dict):
-        # Apply your masking/anonymization logic
-        if "sensitive_field" in data:
-            data["sensitive_field"] = "***MASKED***"
-
-        # Check for direct email field (for UserProfile dataclass)
-        if "email" in data:
-            data["email"] = "anonymous@example.com"
-
-        # Process nested user_info if present
-        if "user_info" in data and isinstance(data["user_info"], dict):
-            if "email" in data["user_info"]:
-                data["user_info"]["email"] = "anonymous@example.com"
-
-    return data
-
-
-# Example of using with a dataclass
-@dataclass
-class UserProfile:
-    user_id: int
-    name: str
-    email: str
-    access_level: str
-
-
-def test_traced_with_input_processor(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(input_processor=mask_credit_card)
-    def process_payment(name, card_number, amount):
-        return {"transaction_id": "tx_12345", "amount": amount, "status": "approved"}
-
-    result = process_payment("John Doe", "4111111111111111", 99.99)
-    assert result["transaction_id"] == "tx_12345"
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-    assert span.name == "process_payment"
-
-    # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert "card_number" in inputs
-    assert inputs["card_number"] == "**** **** **** 1111"  # Should be masked
-    assert inputs["name"] == "John Doe"  # Should be unchanged
-
-    # Verify original function output is returned
-    assert result["transaction_id"] == "tx_12345"
-    assert result["amount"] == 99.99
-
-
-def test_traced_with_output_processor(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(output_processor=anonymize_user_data)
-    def get_user_profile(user_id):
-        # Return sensitive user data
-        return {
-            "user_id": user_id,
-            "user_info": {"name": "Jane Smith", "email": "jane@example.com", "age": 32},
-            "subscription": "premium",
-        }
-
-    result = get_user_profile(12345)
-
-    # Original function should return unmodified data
-    assert result["user_info"]["name"] == "Jane Smith"
-    assert result["user_info"]["email"] == "jane@example.com"
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Verify output was processed for tracing
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert output["user_info"]["name"] == "Anonymous User"
-    assert output["user_info"]["email"] == "anonymous@example.com"
-    assert output["user_info"]["age"] == 32  # Non-sensitive data preserved
-    assert output["subscription"] == "premium"  # Non-sensitive data preserved
-
-
-def test_traced_with_dataclass_output(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(output_processor=process_dataclass_output)
-    def get_user_profile(user_id):
-        # Return a dataclass with sensitive data
-        return UserProfile(
-            user_id=user_id,
-            name="John Doe",
-            email="john.doe@example.com",
-            access_level="admin",
-        )
-
-    result = get_user_profile(12345)
-
-    # Verify original result is unchanged
-    assert result.name == "John Doe"
-    assert result.email == "john.doe@example.com"
-
-    provider.shutdown()
-    spans = exporter.get_exported_spans()
-
-    # Verify the output was processed for tracing
-    output_json = spans[0].attributes["output"]
-    output = json.loads(output_json)
-    assert "email" in output
-    assert output["email"] == "anonymous@example.com"  # Masked in the trace
-
-
-@pytest.mark.asyncio
-async def test_traced_async_with_processors(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
-    async def async_payment_with_user_data(name, card_number, amount):
-        await sleep(0.1)  # Simulate async operation
-        return {
-            "transaction_id": "tx_async_12345",
-            "amount": amount,
-            "status": "approved",
-            "user_info": {
-                "name": name,
-                "email": f"{name.lower().replace(' ', '.')}@example.com",
-            },
-        }
-
-    result = await async_payment_with_user_data("John Doe", "5555555555554444", 199.99)
-
-    # Original function should return unmodified data
-    assert result["transaction_id"] == "tx_async_12345"
-    assert result["user_info"]["name"] == "John Doe"
-    assert result["user_info"]["email"] == "john.doe@example.com"
-
-    provider.shutdown()  # Ensure spans are flushed
-    await sleep(0.1)  # Give time for spans to be processed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs["card_number"] == "**** **** **** 4444"
-
-    # Verify outputs were processed
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert output["user_info"]["name"] == "Anonymous User"
-    assert output["user_info"]["email"] == "anonymous@example.com"
-    assert output["amount"] == 199.99  # Non-sensitive data preserved
-
-
-def test_traced_generator_with_processors(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
-    def generate_user_transactions(card_number, count):
-        for i in range(count):
-            yield {
-                "transaction_id": f"tx_{i}",
-                "amount": 10.0 * (i + 1),
-                "user_info": {"name": "Jane Smith", "email": "jane@example.com"},
-            }
-
-    results = list(generate_user_transactions("4111111111111111", 3))
-
-    # Original function should return unmodified data
-    assert len(results) == 3
-    assert results[0]["user_info"]["name"] == "Jane Smith"
-    assert results[0]["user_info"]["email"] == "jane@example.com"
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs["card_number"] == "**** **** **** 1111"
-
-    # Verify outputs were processed
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert len(output) == 3
-    for transaction in output:
-        assert transaction["user_info"]["name"] == "Anonymous User"
-        assert transaction["user_info"]["email"] == "anonymous@example.com"
-
-
-@pytest.mark.asyncio
-async def test_traced_async_generator_with_processors(setup_tracer):
-    exporter, provider = setup_tracer
-
-    @traced(input_processor=mask_credit_card, output_processor=anonymize_user_data)
-    async def generate_async_transactions(card_number, count):
-        for i in range(count):
-            await sleep(0.05)  # Simulate async operation
-            yield {
-                "transaction_id": f"tx_async_{i}",
-                "amount": 20.0 * (i + 1),
-                "user_info": {"name": "Bob Johnson", "email": "bob@example.com"},
-            }
-
-    results = [
-        item async for item in generate_async_transactions("5555555555554444", 2)
-    ]
-
-    # Original function should return unmodified data
-    assert len(results) == 2
-    assert results[0]["user_info"]["name"] == "Bob Johnson"
-    assert results[0]["user_info"]["email"] == "bob@example.com"
-
-    provider.shutdown()  # Ensure spans are flushed
-    await sleep(0.1)  # Give time for spans to be processed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Verify inputs were processed
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs["card_number"] == "**** **** **** 4444"
-
-    # Verify outputs were processed
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert len(output) == 2
-    for transaction in output:
-        assert transaction["user_info"]["name"] == "Anonymous User"
-        assert transaction["user_info"]["email"] == "anonymous@example.com"
-
-
-def test_traced_with_hide_input_outputs(setup_tracer):
-    """Test that hide_input=True and hide_output=True redacts all data."""
-    exporter, provider = setup_tracer
-
-    @traced(hide_input=True, hide_output=True)
-    def fully_private_function(sensitive_input):
-        return {"sensitive_output": f"Processed {sensitive_input}"}
-
-    result = fully_private_function("confidential_data")
-
-    # Original function should return unmodified data
-    assert result["sensitive_output"] == "Processed confidential_data"
-
-    provider.shutdown()  # Ensure spans are flushed
-    spans = exporter.get_exported_spans()
-
-    assert len(spans) == 1
-    span = spans[0]
-
-    # Verify both inputs and outputs were redacted
-    inputs_json = span.attributes["inputs"]
-    inputs = json.loads(inputs_json)
-    assert inputs == {"redacted": "Input data not logged for privacy/security"}
-
-    output_json = span.attributes["output"]
-    output = json.loads(output_json)
-    assert output == {"redacted": "Output data not logged for privacy/security"}
diff --git a/tests/tracing/test_tracing_manager.py b/tests/tracing/test_tracing_manager.py
deleted file mode 100644
index 1f5669b2a..000000000
--- a/tests/tracing/test_tracing_manager.py
+++ /dev/null
@@ -1,219 +0,0 @@
-from functools import wraps
-
-from uipath.tracing._traced import TracingManager, traced
-
-
-# Custom wrapper that does nothing
-def donothing_custom_tracer(**kwargs):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Simple implementation that just adds a marker to the result
-            result = func(*args, **kwargs)
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-# Helper function for testing custom tracer
-def simple_custom_tracer(**kwargs):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Simple implementation that just adds a marker to the result
-            result = func(*args, **kwargs)
-            if isinstance(result, dict):
-                result["custom_tracer_used"] = True
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-# Helper function for testing custom tracer with method
-def custom_method_tracer(**kwargs):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            result = func(*args, **kwargs)
-            if isinstance(result, dict):
-                result["custom_method_tracer_used"] = True
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-# Helper function for testing with counter
-def custom_tracer_with_counter(call_counter, **kwargs):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            call_counter["count"] += 1
-            result = func(*args, **kwargs)
-            if isinstance(result, dict):
-                result["custom_tracer_id"] = call_counter["count"]
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-# Helper function for testing custom tracer without name parameter
-def custom_tracer_without_name_param(
-    run_type=None,
-    span_type=None,
-    input_processor=None,
-    output_processor=None,
-):
-    """Custom tracer implementation that doesn't accept the 'name' parameter."""
-
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            result = func(*args, **kwargs)
-            if isinstance(result, dict):
-                result["custom_tracer_without_name"] = True
-                if run_type:
-                    result["run_type"] = run_type
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-# Define the test classes
-class TestClassForMethodTest:
-    @traced()
-    def sample_method(self, x, y):
-        return {"product": x * y}
-
-
-# Module level functions for function test
-@traced()
-def func1_for_test(x):
-    return {"result": x * 2}
-
-
-@traced()
-def func2_for_test(x):
-    return {"result": x * 3}
-
-
-# Define a function with @traced
-@traced()
-def sample_function():
-    return {"status": "success"}
-
-
-def test_tracing_manager_custom_implementation():
-    """Test setting and getting a custom tracer implementation."""
-    # Set the custom implementation
-    TracingManager.reapply_traced_decorator(simple_custom_tracer)
-
-    # Get the implementation and verify it's the same one
-    impl = TracingManager.get_custom_tracer_implementation()
-    assert impl is simple_custom_tracer
-
-
-def test_traced_with_custom_implementation():
-    """Test that @traced uses a custom implementation when provided."""
-    # Set the custom implementation
-    TracingManager.reapply_traced_decorator(simple_custom_tracer)
-
-    # Call the function and verify the custom implementation was used
-    result = sample_function()
-    assert "custom_tracer_used" in result
-    assert result["custom_tracer_used"] is True
-
-
-def test_reapply_traced_decorator_to_class_method():
-    """Test reapply_traced_decorator with class methods."""
-    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
-
-    # Create instance and call with default implementation
-    instance = TestClassForMethodTest()
-    result1 = instance.sample_method(2, 3)
-    assert result1 == {"product": 6}
-
-    # Apply our custom implementation
-    TracingManager.reapply_traced_decorator(custom_method_tracer)
-
-    # Create a NEW instance which will use the updated class method
-    new_instance = TestClassForMethodTest()
-    result2 = new_instance.sample_method(2, 3)
-
-    # Verify the result
-    assert "product" in result2
-    assert result2["product"] == 6
-    assert "custom_method_tracer_used" in result2
-
-
-def test_reapply_to_module_level_functions():
-    """Test reapply_traced_decorator with module level functions."""
-
-    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
-
-    # First call with default implementation
-    assert func1_for_test(5) == {"result": 10}
-    assert func2_for_test(5) == {"result": 15}
-
-    # Counter to track custom tracer calls
-    call_counter = {"count": 0}
-
-    # Reapply with the custom implementation
-    TracingManager.reapply_traced_decorator(
-        lambda **kwargs: custom_tracer_with_counter(call_counter, **kwargs)
-    )
-
-    # Call the functions directly - they should now use the updated implementation
-    result1 = func1_for_test(5)
-    result2 = func2_for_test(5)
-
-    # Verify the custom implementation was applied
-    assert "result" in result1
-    assert result1["result"] == 10
-    assert "custom_tracer_id" in result1
-
-    assert "result" in result2
-    assert result2["result"] == 15
-    assert "custom_tracer_id" in result2
-
-    # Verify both functions were processed
-    assert call_counter["count"] == 2
-
-
-def test_custom_tracer_without_name_param():
-    """Test that a custom tracer without the 'name' parameter works correctly."""
-    TracingManager.reapply_traced_decorator(donothing_custom_tracer)
-
-    # Create a function with @traced
-    @traced(name="explicit_name")
-    def function_with_name():
-        return {"status": "original"}
-
-    # Initial call with default implementation
-    result1 = function_with_name()
-    assert result1 == {"status": "original"}
-
-    # Apply custom implementation that doesn't support 'name'
-    TracingManager.reapply_traced_decorator(custom_tracer_without_name_param)
-
-    # Create a new function with the same decorator
-    # This tests that new decorations use the custom implementation properly
-    @traced(name="this_will_be_ignored", run_type="special_run")
-    def another_function():
-        return {"status": "success"}
-
-    result3 = another_function()
-
-    # Verify parameters are correctly filtered
-    assert "custom_tracer_without_name" in result3
-    assert "run_type" in result3
-    assert result3["run_type"] == "special_run"
diff --git a/uv.lock b/uv.lock
deleted file mode 100644
index c3686eac9..000000000
--- a/uv.lock
+++ /dev/null
@@ -1,2246 +0,0 @@
-version = 1
-revision = 1
-requires-python = ">=3.10"
-resolution-markers = [
-    "python_full_version >= '3.12.4'",
-    "python_full_version < '3.12.4'",
-]
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
-]
-
-[[package]]
-name = "anyio"
-version = "4.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "idna" },
-    { name = "sniffio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/73/199a98fc2dae33535d6b8e8e6ec01f8c1d76c9adb096c6b7d64823038cde/anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a", size = 181126 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 },
-]
-
-[[package]]
-name = "asgiref"
-version = "3.8.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/29/38/b3395cc9ad1b56d2ddac9970bc8f4141312dbaec28bc7c218b0dfafd0f42/asgiref-3.8.1.tar.gz", hash = "sha256:c343bd80a0bec947a9860adb4c432ffa7db769836c64238fc34bdc3fec84d590", size = 35186 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/e3/893e8757be2612e6c266d9bb58ad2e3651524b5b40cf56761e985a28b13e/asgiref-3.8.1-py3-none-any.whl", hash = "sha256:3e1e3ecc849832fe52ccf2cb6686b7a55f82bb1d6aee72a58826471390335e47", size = 23828 },
-]
-
-[[package]]
-name = "attrs"
-version = "25.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 },
-]
-
-[[package]]
-name = "azure-core"
-version = "1.34.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "requests" },
-    { name = "six" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/29/ff7a519a315e41c85bab92a7478c6acd1cf0b14353139a08caee4c691f77/azure_core-1.34.0.tar.gz", hash = "sha256:bdb544989f246a0ad1c85d72eeb45f2f835afdcbc5b45e43f0dbde7461c81ece", size = 297999 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/9e/5c87b49f65bb16571599bc789857d0ded2f53014d3392bc88a5d1f3ad779/azure_core-1.34.0-py3-none-any.whl", hash = "sha256:0615d3b756beccdb6624d1c0ae97284f38b78fb59a2a9839bf927c66fbbdddd6", size = 207409 },
-]
-
-[[package]]
-name = "azure-core-tracing-opentelemetry"
-version = "1.0.0b12"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "opentelemetry-api" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/7f/5de13a331a5f2919417819cc37dcf7c897018f02f83aa82b733e6629a6a6/azure_core_tracing_opentelemetry-1.0.0b12.tar.gz", hash = "sha256:bb454142440bae11fd9d68c7c1d67ae38a1756ce808c5e4d736730a7b4b04144", size = 26010 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/5e/97a471f66935e7f89f521d0e11ae49c7f0871ca38f5c319dccae2155c8d8/azure_core_tracing_opentelemetry-1.0.0b12-py3-none-any.whl", hash = "sha256:38fd42709f1cc4bbc4f2797008b1c30a6a01617e49910c05daa3a0d0c65053ac", size = 11962 },
-]
-
-[[package]]
-name = "azure-identity"
-version = "1.22.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "cryptography" },
-    { name = "msal" },
-    { name = "msal-extensions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/58/8e/1b5916f5e1696bf05b009cf7d41383cea54aa8536d4a4f6f88cca15eb6a4/azure_identity-1.22.0.tar.gz", hash = "sha256:c8f5ef23e5295c2fa300c984dd9f5e1fe43503fc25c121c37ff6a15e39b800b9", size = 263346 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/1a/6f13d7f95f68f37303c0e00e011d498e4524e70d354b2e11ef5ae89e0ce0/azure_identity-1.22.0-py3-none-any.whl", hash = "sha256:26d6c63f2ca453c77c3e74be8613941ad074e05d0c8be135247573752c249ad8", size = 185524 },
-]
-
-[[package]]
-name = "azure-monitor-opentelemetry"
-version = "1.6.8"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "azure-core-tracing-opentelemetry" },
-    { name = "azure-monitor-opentelemetry-exporter" },
-    { name = "opentelemetry-instrumentation-django" },
-    { name = "opentelemetry-instrumentation-fastapi" },
-    { name = "opentelemetry-instrumentation-flask" },
-    { name = "opentelemetry-instrumentation-psycopg2" },
-    { name = "opentelemetry-instrumentation-requests" },
-    { name = "opentelemetry-instrumentation-urllib" },
-    { name = "opentelemetry-instrumentation-urllib3" },
-    { name = "opentelemetry-resource-detector-azure" },
-    { name = "opentelemetry-sdk" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/48/dc/ca94c8edd56f09f36979ca9583934b91e3b5ffd8c8ebeb9d80e4fd265044/azure_monitor_opentelemetry-1.6.8.tar.gz", hash = "sha256:d6098ca82a0b067bf342fd1d0b23ffacb45410276e0b7e12beafcd4a6c3b77a3", size = 47060 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/92/f7f08eb539d7b27a0cc71067c748e121ab055ad103228a259ab719b7507b/azure_monitor_opentelemetry-1.6.8-py3-none-any.whl", hash = "sha256:227b3caaaf1a86bbd71d5f4443ef3d64e42dddfcaeb7aade1d3d4a9a8059309d", size = 23644 },
-]
-
-[[package]]
-name = "azure-monitor-opentelemetry-exporter"
-version = "1.0.0b36"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "azure-identity" },
-    { name = "fixedint" },
-    { name = "msrest" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-sdk" },
-    { name = "psutil" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/38/34/4a545d8613262361e83125df8108806584853f60cc054c675d87efb06c93/azure_monitor_opentelemetry_exporter-1.0.0b36.tar.gz", hash = "sha256:82977b9576a694362ea9c6a9eec6add6e56314da759dbc543d02f50962d4b72d", size = 189364 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/d9/e1130395b3575544b6dce87b414452ec9c8d3b2c3f75d515c3c4cd391159/azure_monitor_opentelemetry_exporter-1.0.0b36-py2.py3-none-any.whl", hash = "sha256:8b669deae6a247246944495f519fd93dbdfa9c0150d1222cfc780de098338546", size = 154118 },
-]
-
-[[package]]
-name = "babel"
-version = "2.17.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 },
-]
-
-[[package]]
-name = "backports-asyncio-runner"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313 },
-]
-
-[[package]]
-name = "backrefs"
-version = "5.8"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6c/46/caba1eb32fa5784428ab401a5487f73db4104590ecd939ed9daaf18b47e0/backrefs-5.8.tar.gz", hash = "sha256:2cab642a205ce966af3dd4b38ee36009b31fa9502a35fd61d59ccc116e40a6bd", size = 6773994 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/cb/d019ab87fe70e0fe3946196d50d6a4428623dc0c38a6669c8cae0320fbf3/backrefs-5.8-py310-none-any.whl", hash = "sha256:c67f6638a34a5b8730812f5101376f9d41dc38c43f1fdc35cb54700f6ed4465d", size = 380337 },
-    { url = "https://files.pythonhosted.org/packages/a9/86/abd17f50ee21b2248075cb6924c6e7f9d23b4925ca64ec660e869c2633f1/backrefs-5.8-py311-none-any.whl", hash = "sha256:2e1c15e4af0e12e45c8701bd5da0902d326b2e200cafcd25e49d9f06d44bb61b", size = 392142 },
-    { url = "https://files.pythonhosted.org/packages/b3/04/7b415bd75c8ab3268cc138c76fa648c19495fcc7d155508a0e62f3f82308/backrefs-5.8-py312-none-any.whl", hash = "sha256:bbef7169a33811080d67cdf1538c8289f76f0942ff971222a16034da88a73486", size = 398021 },
-    { url = "https://files.pythonhosted.org/packages/04/b8/60dcfb90eb03a06e883a92abbc2ab95c71f0d8c9dd0af76ab1d5ce0b1402/backrefs-5.8-py313-none-any.whl", hash = "sha256:e3a63b073867dbefd0536425f43db618578528e3896fb77be7141328642a1585", size = 399915 },
-    { url = "https://files.pythonhosted.org/packages/0c/37/fb6973edeb700f6e3d6ff222400602ab1830446c25c7b4676d8de93e65b8/backrefs-5.8-py39-none-any.whl", hash = "sha256:a66851e4533fb5b371aa0628e1fee1af05135616b86140c9d787a2ffdf4b8fdc", size = 380336 },
-]
-
-[[package]]
-name = "bandit"
-version = "1.8.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "pyyaml" },
-    { name = "rich" },
-    { name = "stevedore" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1a/a5/144a45f8e67df9d66c3bc3f7e69a39537db8bff1189ab7cff4e9459215da/bandit-1.8.3.tar.gz", hash = "sha256:f5847beb654d309422985c36644649924e0ea4425c76dec2e89110b87506193a", size = 4232005 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/85/db74b9233e0aa27ec96891045c5e920a64dd5cbccd50f8e64e9460f48d35/bandit-1.8.3-py3-none-any.whl", hash = "sha256:28f04dc0d258e1dd0f99dee8eefa13d1cb5e3fde1a5ab0c523971f97b289bcd8", size = 129078 },
-]
-
-[[package]]
-name = "cairocffi"
-version = "1.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/70/c5/1a4dc131459e68a173cbdab5fad6b524f53f9c1ef7861b7698e998b837cc/cairocffi-1.7.1.tar.gz", hash = "sha256:2e48ee864884ec4a3a34bfa8c9ab9999f688286eb714a15a43ec9d068c36557b", size = 88096 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/93/d8/ba13451aa6b745c49536e87b6bf8f629b950e84bd0e8308f7dc6883b67e2/cairocffi-1.7.1-py3-none-any.whl", hash = "sha256:9803a0e11f6c962f3b0ae2ec8ba6ae45e957a146a004697a1ac1bbf16b073b3f", size = 75611 },
-]
-
-[[package]]
-name = "cairosvg"
-version = "2.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cairocffi" },
-    { name = "cssselect2" },
-    { name = "defusedxml" },
-    { name = "pillow" },
-    { name = "tinycss2" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/e6/ec5900b724e3c44af7f6f51f719919137284e5da4aabe96508baec8a1b40/CairoSVG-2.7.1.tar.gz", hash = "sha256:432531d72347291b9a9ebfb6777026b607563fd8719c46ee742db0aef7271ba0", size = 8399085 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/a5/1866b42151f50453f1a0d28fc4c39f5be5f412a2e914f33449c42daafdf1/CairoSVG-2.7.1-py3-none-any.whl", hash = "sha256:8a5222d4e6c3f86f1f7046b63246877a63b49923a1cd202184c3a634ef546b3b", size = 43235 },
-]
-
-[[package]]
-name = "certifi"
-version = "2025.1.31"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 },
-]
-
-[[package]]
-name = "cffi"
-version = "1.17.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pycparser" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 },
-    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 },
-    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 },
-    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 },
-    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 },
-    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 },
-    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 },
-    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 },
-    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 },
-    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 },
-    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 },
-    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 },
-    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 },
-    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 },
-    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 },
-    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 },
-    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 },
-    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 },
-    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 },
-    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 },
-    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 },
-    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 },
-    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 },
-    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 },
-    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
-    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
-    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
-    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
-    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
-    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
-    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
-    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
-    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
-    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
-    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
-    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
-    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
-    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
-    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
-    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
-    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
-    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
-    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
-    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
-]
-
-[[package]]
-name = "cfgv"
-version = "3.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249 },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 },
-    { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 },
-    { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 },
-    { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 },
-    { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 },
-    { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 },
-    { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 },
-    { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 },
-    { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 },
-    { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 },
-    { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 },
-    { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 },
-    { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 },
-    { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 },
-    { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 },
-    { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 },
-    { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 },
-    { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 },
-    { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 },
-    { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 },
-    { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 },
-    { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 },
-    { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 },
-    { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 },
-    { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 },
-    { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 },
-    { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 },
-    { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 },
-    { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 },
-    { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 },
-    { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 },
-    { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 },
-    { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 },
-    { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 },
-    { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 },
-    { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 },
-    { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 },
-    { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 },
-    { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 },
-    { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 },
-    { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 },
-    { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 },
-    { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 },
-    { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 },
-    { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 },
-    { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 },
-    { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 },
-    { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 },
-    { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 },
-    { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 },
-    { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 },
-    { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 },
-    { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 },
-]
-
-[[package]]
-name = "click"
-version = "8.1.8"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 },
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
-]
-
-[[package]]
-name = "coverage"
-version = "7.6.12"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0c/d6/2b53ab3ee99f2262e6f0b8369a43f6d66658eab45510331c0b3d5c8c4272/coverage-7.6.12.tar.gz", hash = "sha256:48cfc4641d95d34766ad41d9573cc0f22a48aa88d22657a1fe01dca0dbae4de2", size = 805941 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/67/81dc41ec8f548c365d04a29f1afd492d3176b372c33e47fa2a45a01dc13a/coverage-7.6.12-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:704c8c8c6ce6569286ae9622e534b4f5b9759b6f2cd643f1c1a61f666d534fe8", size = 208345 },
-    { url = "https://files.pythonhosted.org/packages/33/43/17f71676016c8829bde69e24c852fef6bd9ed39f774a245d9ec98f689fa0/coverage-7.6.12-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ad7525bf0241e5502168ae9c643a2f6c219fa0a283001cee4cf23a9b7da75879", size = 208775 },
-    { url = "https://files.pythonhosted.org/packages/86/25/c6ff0775f8960e8c0840845b723eed978d22a3cd9babd2b996e4a7c502c6/coverage-7.6.12-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06097c7abfa611c91edb9e6920264e5be1d6ceb374efb4986f38b09eed4cb2fe", size = 237925 },
-    { url = "https://files.pythonhosted.org/packages/b0/3d/5f5bd37046243cb9d15fff2c69e498c2f4fe4f9b42a96018d4579ed3506f/coverage-7.6.12-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:220fa6c0ad7d9caef57f2c8771918324563ef0d8272c94974717c3909664e674", size = 235835 },
-    { url = "https://files.pythonhosted.org/packages/b5/f1/9e6b75531fe33490b910d251b0bf709142e73a40e4e38a3899e6986fe088/coverage-7.6.12-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3688b99604a24492bcfe1c106278c45586eb819bf66a654d8a9a1433022fb2eb", size = 236966 },
-    { url = "https://files.pythonhosted.org/packages/4f/bc/aef5a98f9133851bd1aacf130e754063719345d2fb776a117d5a8d516971/coverage-7.6.12-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d1a987778b9c71da2fc8948e6f2656da6ef68f59298b7e9786849634c35d2c3c", size = 236080 },
-    { url = "https://files.pythonhosted.org/packages/eb/d0/56b4ab77f9b12aea4d4c11dc11cdcaa7c29130b837eb610639cf3400c9c3/coverage-7.6.12-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:cec6b9ce3bd2b7853d4a4563801292bfee40b030c05a3d29555fd2a8ee9bd68c", size = 234393 },
-    { url = "https://files.pythonhosted.org/packages/0d/77/28ef95c5d23fe3dd191a0b7d89c82fea2c2d904aef9315daf7c890e96557/coverage-7.6.12-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ace9048de91293e467b44bce0f0381345078389814ff6e18dbac8fdbf896360e", size = 235536 },
-    { url = "https://files.pythonhosted.org/packages/29/62/18791d3632ee3ff3f95bc8599115707d05229c72db9539f208bb878a3d88/coverage-7.6.12-cp310-cp310-win32.whl", hash = "sha256:ea31689f05043d520113e0552f039603c4dd71fa4c287b64cb3606140c66f425", size = 211063 },
-    { url = "https://files.pythonhosted.org/packages/fc/57/b3878006cedfd573c963e5c751b8587154eb10a61cc0f47a84f85c88a355/coverage-7.6.12-cp310-cp310-win_amd64.whl", hash = "sha256:676f92141e3c5492d2a1596d52287d0d963df21bf5e55c8b03075a60e1ddf8aa", size = 211955 },
-    { url = "https://files.pythonhosted.org/packages/64/2d/da78abbfff98468c91fd63a73cccdfa0e99051676ded8dd36123e3a2d4d5/coverage-7.6.12-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e18aafdfb3e9ec0d261c942d35bd7c28d031c5855dadb491d2723ba54f4c3015", size = 208464 },
-    { url = "https://files.pythonhosted.org/packages/31/f2/c269f46c470bdabe83a69e860c80a82e5e76840e9f4bbd7f38f8cebbee2f/coverage-7.6.12-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:66fe626fd7aa5982cdebad23e49e78ef7dbb3e3c2a5960a2b53632f1f703ea45", size = 208893 },
-    { url = "https://files.pythonhosted.org/packages/47/63/5682bf14d2ce20819998a49c0deadb81e608a59eed64d6bc2191bc8046b9/coverage-7.6.12-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ef01d70198431719af0b1f5dcbefc557d44a190e749004042927b2a3fed0702", size = 241545 },
-    { url = "https://files.pythonhosted.org/packages/6a/b6/6b6631f1172d437e11067e1c2edfdb7238b65dff965a12bce3b6d1bf2be2/coverage-7.6.12-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e92ae5a289a4bc4c0aae710c0948d3c7892e20fd3588224ebe242039573bf0", size = 239230 },
-    { url = "https://files.pythonhosted.org/packages/c7/01/9cd06cbb1be53e837e16f1b4309f6357e2dfcbdab0dd7cd3b1a50589e4e1/coverage-7.6.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e695df2c58ce526eeab11a2e915448d3eb76f75dffe338ea613c1201b33bab2f", size = 241013 },
-    { url = "https://files.pythonhosted.org/packages/4b/26/56afefc03c30871326e3d99709a70d327ac1f33da383cba108c79bd71563/coverage-7.6.12-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d74c08e9aaef995f8c4ef6d202dbd219c318450fe2a76da624f2ebb9c8ec5d9f", size = 239750 },
-    { url = "https://files.pythonhosted.org/packages/dd/ea/88a1ff951ed288f56aa561558ebe380107cf9132facd0b50bced63ba7238/coverage-7.6.12-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e995b3b76ccedc27fe4f477b349b7d64597e53a43fc2961db9d3fbace085d69d", size = 238462 },
-    { url = "https://files.pythonhosted.org/packages/6e/d4/1d9404566f553728889409eff82151d515fbb46dc92cbd13b5337fa0de8c/coverage-7.6.12-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b1f097878d74fe51e1ddd1be62d8e3682748875b461232cf4b52ddc6e6db0bba", size = 239307 },
-    { url = "https://files.pythonhosted.org/packages/12/c1/e453d3b794cde1e232ee8ac1d194fde8e2ba329c18bbf1b93f6f5eef606b/coverage-7.6.12-cp311-cp311-win32.whl", hash = "sha256:1f7ffa05da41754e20512202c866d0ebfc440bba3b0ed15133070e20bf5aeb5f", size = 211117 },
-    { url = "https://files.pythonhosted.org/packages/d5/db/829185120c1686fa297294f8fcd23e0422f71070bf85ef1cc1a72ecb2930/coverage-7.6.12-cp311-cp311-win_amd64.whl", hash = "sha256:e216c5c45f89ef8971373fd1c5d8d1164b81f7f5f06bbf23c37e7908d19e8558", size = 212019 },
-    { url = "https://files.pythonhosted.org/packages/e2/7f/4af2ed1d06ce6bee7eafc03b2ef748b14132b0bdae04388e451e4b2c529b/coverage-7.6.12-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b172f8e030e8ef247b3104902cc671e20df80163b60a203653150d2fc204d1ad", size = 208645 },
-    { url = "https://files.pythonhosted.org/packages/dc/60/d19df912989117caa95123524d26fc973f56dc14aecdec5ccd7d0084e131/coverage-7.6.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:641dfe0ab73deb7069fb972d4d9725bf11c239c309ce694dd50b1473c0f641c3", size = 208898 },
-    { url = "https://files.pythonhosted.org/packages/bd/10/fecabcf438ba676f706bf90186ccf6ff9f6158cc494286965c76e58742fa/coverage-7.6.12-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e549f54ac5f301e8e04c569dfdb907f7be71b06b88b5063ce9d6953d2d58574", size = 242987 },
-    { url = "https://files.pythonhosted.org/packages/4c/53/4e208440389e8ea936f5f2b0762dcd4cb03281a7722def8e2bf9dc9c3d68/coverage-7.6.12-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:959244a17184515f8c52dcb65fb662808767c0bd233c1d8a166e7cf74c9ea985", size = 239881 },
-    { url = "https://files.pythonhosted.org/packages/c4/47/2ba744af8d2f0caa1f17e7746147e34dfc5f811fb65fc153153722d58835/coverage-7.6.12-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bda1c5f347550c359f841d6614fb8ca42ae5cb0b74d39f8a1e204815ebe25750", size = 242142 },
-    { url = "https://files.pythonhosted.org/packages/e9/90/df726af8ee74d92ee7e3bf113bf101ea4315d71508952bd21abc3fae471e/coverage-7.6.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1ceeb90c3eda1f2d8c4c578c14167dbd8c674ecd7d38e45647543f19839dd6ea", size = 241437 },
-    { url = "https://files.pythonhosted.org/packages/f6/af/995263fd04ae5f9cf12521150295bf03b6ba940d0aea97953bb4a6db3e2b/coverage-7.6.12-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f16f44025c06792e0fb09571ae454bcc7a3ec75eeb3c36b025eccf501b1a4c3", size = 239724 },
-    { url = "https://files.pythonhosted.org/packages/1c/8e/5bb04f0318805e190984c6ce106b4c3968a9562a400180e549855d8211bd/coverage-7.6.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b076e625396e787448d27a411aefff867db2bffac8ed04e8f7056b07024eed5a", size = 241329 },
-    { url = "https://files.pythonhosted.org/packages/9e/9d/fa04d9e6c3f6459f4e0b231925277cfc33d72dfab7fa19c312c03e59da99/coverage-7.6.12-cp312-cp312-win32.whl", hash = "sha256:00b2086892cf06c7c2d74983c9595dc511acca00665480b3ddff749ec4fb2a95", size = 211289 },
-    { url = "https://files.pythonhosted.org/packages/53/40/53c7ffe3c0c3fff4d708bc99e65f3d78c129110d6629736faf2dbd60ad57/coverage-7.6.12-cp312-cp312-win_amd64.whl", hash = "sha256:7ae6eabf519bc7871ce117fb18bf14e0e343eeb96c377667e3e5dd12095e0288", size = 212079 },
-    { url = "https://files.pythonhosted.org/packages/76/89/1adf3e634753c0de3dad2f02aac1e73dba58bc5a3a914ac94a25b2ef418f/coverage-7.6.12-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:488c27b3db0ebee97a830e6b5a3ea930c4a6e2c07f27a5e67e1b3532e76b9ef1", size = 208673 },
-    { url = "https://files.pythonhosted.org/packages/ce/64/92a4e239d64d798535c5b45baac6b891c205a8a2e7c9cc8590ad386693dc/coverage-7.6.12-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d1095bbee1851269f79fd8e0c9b5544e4c00c0c24965e66d8cba2eb5bb535fd", size = 208945 },
-    { url = "https://files.pythonhosted.org/packages/b4/d0/4596a3ef3bca20a94539c9b1e10fd250225d1dec57ea78b0867a1cf9742e/coverage-7.6.12-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0533adc29adf6a69c1baa88c3d7dbcaadcffa21afbed3ca7a225a440e4744bf9", size = 242484 },
-    { url = "https://files.pythonhosted.org/packages/1c/ef/6fd0d344695af6718a38d0861408af48a709327335486a7ad7e85936dc6e/coverage-7.6.12-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53c56358d470fa507a2b6e67a68fd002364d23c83741dbc4c2e0680d80ca227e", size = 239525 },
-    { url = "https://files.pythonhosted.org/packages/0c/4b/373be2be7dd42f2bcd6964059fd8fa307d265a29d2b9bcf1d044bcc156ed/coverage-7.6.12-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64cbb1a3027c79ca6310bf101014614f6e6e18c226474606cf725238cf5bc2d4", size = 241545 },
-    { url = "https://files.pythonhosted.org/packages/a6/7d/0e83cc2673a7790650851ee92f72a343827ecaaea07960587c8f442b5cd3/coverage-7.6.12-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:79cac3390bfa9836bb795be377395f28410811c9066bc4eefd8015258a7578c6", size = 241179 },
-    { url = "https://files.pythonhosted.org/packages/ff/8c/566ea92ce2bb7627b0900124e24a99f9244b6c8c92d09ff9f7633eb7c3c8/coverage-7.6.12-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:9b148068e881faa26d878ff63e79650e208e95cf1c22bd3f77c3ca7b1d9821a3", size = 239288 },
-    { url = "https://files.pythonhosted.org/packages/7d/e4/869a138e50b622f796782d642c15fb5f25a5870c6d0059a663667a201638/coverage-7.6.12-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8bec2ac5da793c2685ce5319ca9bcf4eee683b8a1679051f8e6ec04c4f2fd7dc", size = 241032 },
-    { url = "https://files.pythonhosted.org/packages/ae/28/a52ff5d62a9f9e9fe9c4f17759b98632edd3a3489fce70154c7d66054dd3/coverage-7.6.12-cp313-cp313-win32.whl", hash = "sha256:200e10beb6ddd7c3ded322a4186313d5ca9e63e33d8fab4faa67ef46d3460af3", size = 211315 },
-    { url = "https://files.pythonhosted.org/packages/bc/17/ab849b7429a639f9722fa5628364c28d675c7ff37ebc3268fe9840dda13c/coverage-7.6.12-cp313-cp313-win_amd64.whl", hash = "sha256:2b996819ced9f7dbb812c701485d58f261bef08f9b85304d41219b1496b591ef", size = 212099 },
-    { url = "https://files.pythonhosted.org/packages/d2/1c/b9965bf23e171d98505eb5eb4fb4d05c44efd256f2e0f19ad1ba8c3f54b0/coverage-7.6.12-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:299cf973a7abff87a30609879c10df0b3bfc33d021e1adabc29138a48888841e", size = 209511 },
-    { url = "https://files.pythonhosted.org/packages/57/b3/119c201d3b692d5e17784fee876a9a78e1b3051327de2709392962877ca8/coverage-7.6.12-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4b467a8c56974bf06e543e69ad803c6865249d7a5ccf6980457ed2bc50312703", size = 209729 },
-    { url = "https://files.pythonhosted.org/packages/52/4e/a7feb5a56b266304bc59f872ea07b728e14d5a64f1ad3a2cc01a3259c965/coverage-7.6.12-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2458f275944db8129f95d91aee32c828a408481ecde3b30af31d552c2ce284a0", size = 253988 },
-    { url = "https://files.pythonhosted.org/packages/65/19/069fec4d6908d0dae98126aa7ad08ce5130a6decc8509da7740d36e8e8d2/coverage-7.6.12-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a9d8be07fb0832636a0f72b80d2a652fe665e80e720301fb22b191c3434d924", size = 249697 },
-    { url = "https://files.pythonhosted.org/packages/1c/da/5b19f09ba39df7c55f77820736bf17bbe2416bbf5216a3100ac019e15839/coverage-7.6.12-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14d47376a4f445e9743f6c83291e60adb1b127607a3618e3185bbc8091f0467b", size = 252033 },
-    { url = "https://files.pythonhosted.org/packages/1e/89/4c2750df7f80a7872267f7c5fe497c69d45f688f7b3afe1297e52e33f791/coverage-7.6.12-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b95574d06aa9d2bd6e5cc35a5bbe35696342c96760b69dc4287dbd5abd4ad51d", size = 251535 },
-    { url = "https://files.pythonhosted.org/packages/78/3b/6d3ae3c1cc05f1b0460c51e6f6dcf567598cbd7c6121e5ad06643974703c/coverage-7.6.12-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:ecea0c38c9079570163d663c0433a9af4094a60aafdca491c6a3d248c7432827", size = 249192 },
-    { url = "https://files.pythonhosted.org/packages/6e/8e/c14a79f535ce41af7d436bbad0d3d90c43d9e38ec409b4770c894031422e/coverage-7.6.12-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2251fabcfee0a55a8578a9d29cecfee5f2de02f11530e7d5c5a05859aa85aee9", size = 250627 },
-    { url = "https://files.pythonhosted.org/packages/cb/79/b7cee656cfb17a7f2c1b9c3cee03dd5d8000ca299ad4038ba64b61a9b044/coverage-7.6.12-cp313-cp313t-win32.whl", hash = "sha256:eb5507795caabd9b2ae3f1adc95f67b1104971c22c624bb354232d65c4fc90b3", size = 212033 },
-    { url = "https://files.pythonhosted.org/packages/b6/c3/f7aaa3813f1fa9a4228175a7bd368199659d392897e184435a3b66408dd3/coverage-7.6.12-cp313-cp313t-win_amd64.whl", hash = "sha256:f60a297c3987c6c02ffb29effc70eadcbb412fe76947d394a1091a3615948e2f", size = 213240 },
-    { url = "https://files.pythonhosted.org/packages/7a/7f/05818c62c7afe75df11e0233bd670948d68b36cdbf2a339a095bc02624a8/coverage-7.6.12-pp39.pp310-none-any.whl", hash = "sha256:7e39e845c4d764208e7b8f6a21c541ade741e2c41afabdfa1caa28687a3c98cf", size = 200558 },
-    { url = "https://files.pythonhosted.org/packages/fb/b2/f655700e1024dec98b10ebaafd0cedbc25e40e4abe62a3c8e2ceef4f8f0a/coverage-7.6.12-py3-none-any.whl", hash = "sha256:eb8668cfbc279a536c633137deeb9435d2962caec279c3f8cf8b91fff6ff8953", size = 200552 },
-]
-
-[package.optional-dependencies]
-toml = [
-    { name = "tomli", marker = "python_full_version <= '3.11'" },
-]
-
-[[package]]
-name = "cryptography"
-version = "44.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/53/d6/1411ab4d6108ab167d06254c5be517681f1e331f90edf1379895bcb87020/cryptography-44.0.3.tar.gz", hash = "sha256:fe19d8bc5536a91a24a8133328880a41831b6c5df54599a8417b62fe015d3053", size = 711096 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/53/c776d80e9d26441bb3868457909b4e74dd9ccabd182e10b2b0ae7a07e265/cryptography-44.0.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:962bc30480a08d133e631e8dfd4783ab71cc9e33d5d7c1e192f0b7c06397bb88", size = 6670281 },
-    { url = "https://files.pythonhosted.org/packages/6a/06/af2cf8d56ef87c77319e9086601bef621bedf40f6f59069e1b6d1ec498c5/cryptography-44.0.3-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffc61e8f3bf5b60346d89cd3d37231019c17a081208dfbbd6e1605ba03fa137", size = 3959305 },
-    { url = "https://files.pythonhosted.org/packages/ae/01/80de3bec64627207d030f47bf3536889efee8913cd363e78ca9a09b13c8e/cryptography-44.0.3-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58968d331425a6f9eedcee087f77fd3c927c88f55368f43ff7e0a19891f2642c", size = 4171040 },
-    { url = "https://files.pythonhosted.org/packages/bd/48/bb16b7541d207a19d9ae8b541c70037a05e473ddc72ccb1386524d4f023c/cryptography-44.0.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e28d62e59a4dbd1d22e747f57d4f00c459af22181f0b2f787ea83f5a876d7c76", size = 3963411 },
-    { url = "https://files.pythonhosted.org/packages/42/b2/7d31f2af5591d217d71d37d044ef5412945a8a8e98d5a2a8ae4fd9cd4489/cryptography-44.0.3-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af653022a0c25ef2e3ffb2c673a50e5a0d02fecc41608f4954176f1933b12359", size = 3689263 },
-    { url = "https://files.pythonhosted.org/packages/25/50/c0dfb9d87ae88ccc01aad8eb93e23cfbcea6a6a106a9b63a7b14c1f93c75/cryptography-44.0.3-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:157f1f3b8d941c2bd8f3ffee0af9b049c9665c39d3da9db2dc338feca5e98a43", size = 4196198 },
-    { url = "https://files.pythonhosted.org/packages/66/c9/55c6b8794a74da652690c898cb43906310a3e4e4f6ee0b5f8b3b3e70c441/cryptography-44.0.3-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:c6cd67722619e4d55fdb42ead64ed8843d64638e9c07f4011163e46bc512cf01", size = 3966502 },
-    { url = "https://files.pythonhosted.org/packages/b6/f7/7cb5488c682ca59a02a32ec5f975074084db4c983f849d47b7b67cc8697a/cryptography-44.0.3-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b424563394c369a804ecbee9b06dfb34997f19d00b3518e39f83a5642618397d", size = 4196173 },
-    { url = "https://files.pythonhosted.org/packages/d2/0b/2f789a8403ae089b0b121f8f54f4a3e5228df756e2146efdf4a09a3d5083/cryptography-44.0.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c91fc8e8fd78af553f98bc7f2a1d8db977334e4eea302a4bfd75b9461c2d8904", size = 4087713 },
-    { url = "https://files.pythonhosted.org/packages/1d/aa/330c13655f1af398fc154089295cf259252f0ba5df93b4bc9d9c7d7f843e/cryptography-44.0.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:25cd194c39fa5a0aa4169125ee27d1172097857b27109a45fadc59653ec06f44", size = 4299064 },
-    { url = "https://files.pythonhosted.org/packages/10/a8/8c540a421b44fd267a7d58a1fd5f072a552d72204a3f08194f98889de76d/cryptography-44.0.3-cp37-abi3-win32.whl", hash = "sha256:3be3f649d91cb182c3a6bd336de8b61a0a71965bd13d1a04a0e15b39c3d5809d", size = 2773887 },
-    { url = "https://files.pythonhosted.org/packages/b9/0d/c4b1657c39ead18d76bbd122da86bd95bdc4095413460d09544000a17d56/cryptography-44.0.3-cp37-abi3-win_amd64.whl", hash = "sha256:3883076d5c4cc56dbef0b898a74eb6992fdac29a7b9013870b34efe4ddb39a0d", size = 3209737 },
-    { url = "https://files.pythonhosted.org/packages/34/a3/ad08e0bcc34ad436013458d7528e83ac29910943cea42ad7dd4141a27bbb/cryptography-44.0.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:5639c2b16764c6f76eedf722dbad9a0914960d3489c0cc38694ddf9464f1bb2f", size = 6673501 },
-    { url = "https://files.pythonhosted.org/packages/b1/f0/7491d44bba8d28b464a5bc8cc709f25a51e3eac54c0a4444cf2473a57c37/cryptography-44.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3ffef566ac88f75967d7abd852ed5f182da252d23fac11b4766da3957766759", size = 3960307 },
-    { url = "https://files.pythonhosted.org/packages/f7/c8/e5c5d0e1364d3346a5747cdcd7ecbb23ca87e6dea4f942a44e88be349f06/cryptography-44.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:192ed30fac1728f7587c6f4613c29c584abdc565d7417c13904708db10206645", size = 4170876 },
-    { url = "https://files.pythonhosted.org/packages/73/96/025cb26fc351d8c7d3a1c44e20cf9a01e9f7cf740353c9c7a17072e4b264/cryptography-44.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7d5fe7195c27c32a64955740b949070f21cba664604291c298518d2e255931d2", size = 3964127 },
-    { url = "https://files.pythonhosted.org/packages/01/44/eb6522db7d9f84e8833ba3bf63313f8e257729cf3a8917379473fcfd6601/cryptography-44.0.3-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3f07943aa4d7dad689e3bb1638ddc4944cc5e0921e3c227486daae0e31a05e54", size = 3689164 },
-    { url = "https://files.pythonhosted.org/packages/68/fb/d61a4defd0d6cee20b1b8a1ea8f5e25007e26aeb413ca53835f0cae2bcd1/cryptography-44.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:cb90f60e03d563ca2445099edf605c16ed1d5b15182d21831f58460c48bffb93", size = 4198081 },
-    { url = "https://files.pythonhosted.org/packages/1b/50/457f6911d36432a8811c3ab8bd5a6090e8d18ce655c22820994913dd06ea/cryptography-44.0.3-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ab0b005721cc0039e885ac3503825661bd9810b15d4f374e473f8c89b7d5460c", size = 3967716 },
-    { url = "https://files.pythonhosted.org/packages/35/6e/dca39d553075980ccb631955c47b93d87d27f3596da8d48b1ae81463d915/cryptography-44.0.3-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:3bb0847e6363c037df8f6ede57d88eaf3410ca2267fb12275370a76f85786a6f", size = 4197398 },
-    { url = "https://files.pythonhosted.org/packages/9b/9d/d1f2fe681eabc682067c66a74addd46c887ebacf39038ba01f8860338d3d/cryptography-44.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b0cc66c74c797e1db750aaa842ad5b8b78e14805a9b5d1348dc603612d3e3ff5", size = 4087900 },
-    { url = "https://files.pythonhosted.org/packages/c4/f5/3599e48c5464580b73b236aafb20973b953cd2e7b44c7c2533de1d888446/cryptography-44.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6866df152b581f9429020320e5eb9794c8780e90f7ccb021940d7f50ee00ae0b", size = 4301067 },
-    { url = "https://files.pythonhosted.org/packages/a7/6c/d2c48c8137eb39d0c193274db5c04a75dab20d2f7c3f81a7dcc3a8897701/cryptography-44.0.3-cp39-abi3-win32.whl", hash = "sha256:c138abae3a12a94c75c10499f1cbae81294a6f983b3af066390adee73f433028", size = 2775467 },
-    { url = "https://files.pythonhosted.org/packages/c9/ad/51f212198681ea7b0deaaf8846ee10af99fba4e894f67b353524eab2bbe5/cryptography-44.0.3-cp39-abi3-win_amd64.whl", hash = "sha256:5d186f32e52e66994dce4f766884bcb9c68b8da62d61d9d215bfe5fb56d21334", size = 3210375 },
-    { url = "https://files.pythonhosted.org/packages/7f/10/abcf7418536df1eaba70e2cfc5c8a0ab07aa7aa02a5cbc6a78b9d8b4f121/cryptography-44.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:cad399780053fb383dc067475135e41c9fe7d901a97dd5d9c5dfb5611afc0d7d", size = 3393192 },
-    { url = "https://files.pythonhosted.org/packages/06/59/ecb3ef380f5891978f92a7f9120e2852b1df6f0a849c277b8ea45b865db2/cryptography-44.0.3-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:21a83f6f35b9cc656d71b5de8d519f566df01e660ac2578805ab245ffd8523f8", size = 3898419 },
-    { url = "https://files.pythonhosted.org/packages/bb/d0/35e2313dbb38cf793aa242182ad5bc5ef5c8fd4e5dbdc380b936c7d51169/cryptography-44.0.3-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fc3c9babc1e1faefd62704bb46a69f359a9819eb0292e40df3fb6e3574715cd4", size = 4117892 },
-    { url = "https://files.pythonhosted.org/packages/dc/c8/31fb6e33b56c2c2100d76de3fd820afaa9d4d0b6aea1ccaf9aaf35dc7ce3/cryptography-44.0.3-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:e909df4053064a97f1e6565153ff8bb389af12c5c8d29c343308760890560aff", size = 3900855 },
-    { url = "https://files.pythonhosted.org/packages/43/2a/08cc2ec19e77f2a3cfa2337b429676406d4bb78ddd130a05c458e7b91d73/cryptography-44.0.3-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:dad80b45c22e05b259e33ddd458e9e2ba099c86ccf4e88db7bbab4b747b18d06", size = 4117619 },
-    { url = "https://files.pythonhosted.org/packages/02/68/fc3d3f84022a75f2ac4b1a1c0e5d6a0c2ea259e14cd4aae3e0e68e56483c/cryptography-44.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:479d92908277bed6e1a1c69b277734a7771c2b78633c224445b5c60a9f4bc1d9", size = 3136570 },
-    { url = "https://files.pythonhosted.org/packages/8d/4b/c11ad0b6c061902de5223892d680e89c06c7c4d606305eb8de56c5427ae6/cryptography-44.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:896530bc9107b226f265effa7ef3f21270f18a2026bc09fed1ebd7b66ddf6375", size = 3390230 },
-    { url = "https://files.pythonhosted.org/packages/58/11/0a6bf45d53b9b2290ea3cec30e78b78e6ca29dc101e2e296872a0ffe1335/cryptography-44.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:9b4d4a5dbee05a2c390bf212e78b99434efec37b17a4bff42f50285c5c8c9647", size = 3895216 },
-    { url = "https://files.pythonhosted.org/packages/0a/27/b28cdeb7270e957f0077a2c2bfad1b38f72f1f6d699679f97b816ca33642/cryptography-44.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02f55fb4f8b79c1221b0961488eaae21015b69b210e18c386b69de182ebb1259", size = 4115044 },
-    { url = "https://files.pythonhosted.org/packages/35/b0/ec4082d3793f03cb248881fecefc26015813199b88f33e3e990a43f79835/cryptography-44.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dd3db61b8fe5be220eee484a17233287d0be6932d056cf5738225b9c05ef4fff", size = 3898034 },
-    { url = "https://files.pythonhosted.org/packages/0b/7f/adf62e0b8e8d04d50c9a91282a57628c00c54d4ae75e2b02a223bd1f2613/cryptography-44.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:978631ec51a6bbc0b7e58f23b68a8ce9e5f09721940933e9c217068388789fe5", size = 4114449 },
-    { url = "https://files.pythonhosted.org/packages/87/62/d69eb4a8ee231f4bf733a92caf9da13f1c81a44e874b1d4080c25ecbb723/cryptography-44.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:5d20cc348cca3a8aa7312f42ab953a56e15323800ca3ab0706b8cd452a3a056c", size = 3134369 },
-]
-
-[[package]]
-name = "cssselect2"
-version = "0.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "tinycss2" },
-    { name = "webencodings" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/86/fd7f58fc498b3166f3a7e8e0cddb6e620fe1da35b02248b1bd59e95dbaaa/cssselect2-0.8.0.tar.gz", hash = "sha256:7674ffb954a3b46162392aee2a3a0aedb2e14ecf99fcc28644900f4e6e3e9d3a", size = 35716 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/e7/aa315e6a749d9b96c2504a1ba0ba031ba2d0517e972ce22682e3fccecb09/cssselect2-0.8.0-py3-none-any.whl", hash = "sha256:46fc70ebc41ced7a32cd42d58b1884d72ade23d21e5a4eaaf022401c13f0e76e", size = 15454 },
-]
-
-[[package]]
-name = "defusedxml"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 },
-]
-
-[[package]]
-name = "deprecated"
-version = "1.2.18"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998 },
-]
-
-[[package]]
-name = "distlib"
-version = "0.3.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973 },
-]
-
-[[package]]
-name = "exceptiongroup"
-version = "1.2.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 },
-]
-
-[[package]]
-name = "filelock"
-version = "3.17.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/9c/0b15fb47b464e1b663b1acd1253a062aa5feecb07d4e597daea542ebd2b5/filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e", size = 18027 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/ec/00d68c4ddfedfe64159999e5f8a98fb8442729a63e2077eb9dcd89623d27/filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338", size = 16164 },
-]
-
-[[package]]
-name = "fixedint"
-version = "0.1.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/32/c6/b1b9b3f69915d51909ef6ebe6352e286ec3d6f2077278af83ec6e3cc569c/fixedint-0.1.6.tar.gz", hash = "sha256:703005d090499d41ce7ce2ee7eae8f7a5589a81acdc6b79f1728a56495f2c799", size = 12750 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/6d/8f5307d26ce700a89e5a67d1e1ad15eff977211f9ed3ae90d7b0d67f4e66/fixedint-0.1.6-py3-none-any.whl", hash = "sha256:b8cf9f913735d2904deadda7a6daa9f57100599da1de57a7448ea1be75ae8c9c", size = 12702 },
-]
-
-[[package]]
-name = "ghp-import"
-version = "2.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "python-dateutil" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034 },
-]
-
-[[package]]
-name = "griffe"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a0/1a/d467b93f5e0ea4edf3c1caef44cfdd53a4a498cb3a6bb722df4dd0fdd66a/griffe-1.6.0.tar.gz", hash = "sha256:eb5758088b9c73ad61c7ac014f3cdfb4c57b5c2fcbfca69996584b702aefa354", size = 391819 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/02/5a22bc98d0aebb68c15ba70d2da1c84a5ef56048d79634e5f96cd2ba96e9/griffe-1.6.0-py3-none-any.whl", hash = "sha256:9f1dfe035d4715a244ed2050dfbceb05b1f470809ed4f6bb10ece5a7302f8dd1", size = 128470 },
-]
-
-[[package]]
-name = "h11"
-version = "0.14.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 },
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.7"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 },
-]
-
-[[package]]
-name = "httpx"
-version = "0.28.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "certifi" },
-    { name = "httpcore" },
-    { name = "idna" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
-]
-
-[[package]]
-name = "identify"
-version = "2.6.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/d1/524aa3350f78bcd714d148ade6133d67d6b7de2cdbae7d99039c024c9a25/identify-2.6.7.tar.gz", hash = "sha256:3fa266b42eba321ee0b2bb0936a6a6b9e36a1351cbb69055b3082f4193035684", size = 99260 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/00/1fd4a117c6c93f2dcc5b7edaeaf53ea45332ef966429be566ca16c2beb94/identify-2.6.7-py2.py3-none-any.whl", hash = "sha256:155931cb617a401807b09ecec6635d6c692d180090a1cedca8ef7d58ba5b6aa0", size = 99097 },
-]
-
-[[package]]
-name = "idna"
-version = "3.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
-]
-
-[[package]]
-name = "importlib-metadata"
-version = "8.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 },
-]
-
-[[package]]
-name = "inflection"
-version = "0.5.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e1/7e/691d061b7329bc8d54edbf0ec22fbfb2afe61facb681f9aaa9bff7a27d04/inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417", size = 15091 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/59/91/aa6bde563e0085a02a435aa99b49ef75b0a4b062635e606dab23ce18d720/inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2", size = 9454 },
-]
-
-[[package]]
-name = "iniconfig"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
-]
-
-[[package]]
-name = "isodate"
-version = "0.7.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320 },
-]
-
-[[package]]
-name = "jinja2"
-version = "3.1.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markupsafe" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 },
-]
-
-[[package]]
-name = "markdown"
-version = "3.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/28/3af612670f82f4c056911fbbbb42760255801b3068c48de792d354ff4472/markdown-3.7.tar.gz", hash = "sha256:2ae2471477cfd02dbbf038d5d9bc226d40def84b4fe2986e49b59b6b472bbed2", size = 357086 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/08/83871f3c50fc983b88547c196d11cf8c3340e37c32d2e9d6152abe2c61f7/Markdown-3.7-py3-none-any.whl", hash = "sha256:7eb6df5690b81a1d7942992c97fad2938e956e79df20cbc6186e9c3a77b1c803", size = 106349 },
-]
-
-[[package]]
-name = "markdown-it-py"
-version = "3.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
-]
-
-[[package]]
-name = "markupsafe"
-version = "3.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 },
-    { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 },
-    { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 },
-    { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 },
-    { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 },
-    { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 },
-    { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 },
-    { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 },
-    { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 },
-    { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 },
-    { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 },
-    { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 },
-    { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 },
-    { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 },
-    { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 },
-    { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 },
-    { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 },
-    { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 },
-    { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 },
-    { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 },
-    { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 },
-    { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 },
-    { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 },
-    { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 },
-    { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 },
-    { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 },
-    { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 },
-    { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 },
-    { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 },
-    { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 },
-    { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 },
-    { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 },
-    { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 },
-    { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 },
-    { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 },
-    { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 },
-    { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 },
-    { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 },
-    { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 },
-    { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 },
-    { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 },
-    { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 },
-    { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 },
-    { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 },
-    { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 },
-    { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 },
-    { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 },
-    { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 },
-    { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 },
-    { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 },
-]
-
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
-]
-
-[[package]]
-name = "mergedeep"
-version = "1.3.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354 },
-]
-
-[[package]]
-name = "mkdocs"
-version = "1.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "ghp-import" },
-    { name = "jinja2" },
-    { name = "markdown" },
-    { name = "markupsafe" },
-    { name = "mergedeep" },
-    { name = "mkdocs-get-deps" },
-    { name = "packaging" },
-    { name = "pathspec" },
-    { name = "pyyaml" },
-    { name = "pyyaml-env-tag" },
-    { name = "watchdog" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451 },
-]
-
-[[package]]
-name = "mkdocs-autorefs"
-version = "1.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown" },
-    { name = "markupsafe" },
-    { name = "mkdocs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/44/140469d87379c02f1e1870315f3143718036a983dd0416650827b8883192/mkdocs_autorefs-1.4.1.tar.gz", hash = "sha256:4b5b6235a4becb2b10425c2fa191737e415b37aa3418919db33e5d774c9db079", size = 4131355 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/29/1125f7b11db63e8e32bcfa0752a4eea30abff3ebd0796f808e14571ddaa2/mkdocs_autorefs-1.4.1-py3-none-any.whl", hash = "sha256:9793c5ac06a6ebbe52ec0f8439256e66187badf4b5334b5fde0b128ec134df4f", size = 5782047 },
-]
-
-[[package]]
-name = "mkdocs-click"
-version = "0.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "markdown" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/c7/8c25f3a3b379def41e6d0bb5c4beeab7aa8a394b17e749f498504102cfa5/mkdocs_click-0.9.0.tar.gz", hash = "sha256:6050917628d4740517541422b607404d044117bc31b770c4f9e9e1939a50c908", size = 18720 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/fc/9124ab36e2341e78d8d9c669511bd70f52ea0de8105760c31fabec1f9396/mkdocs_click-0.9.0-py3-none-any.whl", hash = "sha256:5208e828f4f68f63c847c1ef7be48edee9964090390afc8f5b3d4cbe5ea9bbed", size = 15104 },
-]
-
-[[package]]
-name = "mkdocs-get-deps"
-version = "0.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mergedeep" },
-    { name = "platformdirs" },
-    { name = "pyyaml" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521 },
-]
-
-[[package]]
-name = "mkdocs-material"
-version = "9.6.7"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "babel" },
-    { name = "backrefs" },
-    { name = "colorama" },
-    { name = "jinja2" },
-    { name = "markdown" },
-    { name = "mkdocs" },
-    { name = "mkdocs-material-extensions" },
-    { name = "paginate" },
-    { name = "pygments" },
-    { name = "pymdown-extensions" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9b/d7/93e19c9587e5f4ed25647890555d58cf484a4d412be7037dc17b9c9179d9/mkdocs_material-9.6.7.tar.gz", hash = "sha256:3e2c1fceb9410056c2d91f334a00cdea3215c28750e00c691c1e46b2a33309b4", size = 3947458 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/aa/d3/12f22de41bdd9e576ddc459b38c651d68edfb840b32acaa1f46ae36845e3/mkdocs_material-9.6.7-py3-none-any.whl", hash = "sha256:8a159e45e80fcaadd9fbeef62cbf928569b93df954d4dc5ba76d46820caf7b47", size = 8696755 },
-]
-
-[package.optional-dependencies]
-imaging = [
-    { name = "cairosvg" },
-    { name = "pillow" },
-]
-
-[[package]]
-name = "mkdocs-material-extensions"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728 },
-]
-
-[[package]]
-name = "mkdocs-open-in-new-tab"
-version = "1.0.8"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mkdocs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0a/0e/f72a506a21bdb27b807124e00c688226848a388d1fd3980b80ae3cc27203/mkdocs_open_in_new_tab-1.0.8.tar.gz", hash = "sha256:3e0dad08cc9938b0b13097be8e0aa435919de1eeb2d1a648e66b5dee8d57e048", size = 5791 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/21/94/44f3c868495481c868d08eea065c82803f1affd8553d3383b782f497613c/mkdocs_open_in_new_tab-1.0.8-py3-none-any.whl", hash = "sha256:051d767a4467b12d89827e1fea0ec660b05b027c726317fe4fceee5456e36ad2", size = 7717 },
-]
-
-[[package]]
-name = "mkdocs-simple-hooks"
-version = "0.1.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mkdocs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f1/93/565f98d6810e3b493e61160aea1cceb8653331576e7fa7f048ac7e7cdf62/mkdocs-simple-hooks-0.1.5.tar.gz", hash = "sha256:dddbdf151a18723c9302a133e5cf79538be8eb9d274e8e07d2ac3ac34890837c", size = 4037 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/e9/7bf0f928f5b6cdd602d4a01d52e5fc1eba8d3ba6d97619a88fc271a625f8/mkdocs_simple_hooks-0.1.5-py3-none-any.whl", hash = "sha256:efeabdbb98b0850a909adee285f3404535117159d5cb3a34f541d6eaa644d50a", size = 4596 },
-]
-
-[[package]]
-name = "mkdocstrings"
-version = "0.29.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jinja2" },
-    { name = "markdown" },
-    { name = "markupsafe" },
-    { name = "mkdocs" },
-    { name = "mkdocs-autorefs" },
-    { name = "pymdown-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8e/4d/a9484dc5d926295bdf308f1f6c4f07fcc99735b970591edc414d401fcc91/mkdocstrings-0.29.0.tar.gz", hash = "sha256:3657be1384543ce0ee82112c3e521bbf48e41303aa0c229b9ffcccba057d922e", size = 1212185 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/47/eb876dfd84e48f31ff60897d161b309cf6a04ca270155b0662aae562b3fb/mkdocstrings-0.29.0-py3-none-any.whl", hash = "sha256:8ea98358d2006f60befa940fdebbbc88a26b37ecbcded10be726ba359284f73d", size = 1630824 },
-]
-
-[package.optional-dependencies]
-python = [
-    { name = "mkdocstrings-python" },
-]
-
-[[package]]
-name = "mkdocstrings-python"
-version = "1.16.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "griffe" },
-    { name = "mkdocs-autorefs" },
-    { name = "mkdocstrings" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/81/3575e451682e0ed3c39e9b57d1fd30590cd28a965131ead14bf2efe34a1b/mkdocstrings_python-1.16.5.tar.gz", hash = "sha256:706b28dd0f59249a7c22cc5d517c9521e06c030b57e2a5478e1928a58f900abb", size = 426979 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/27/42f8a520111a4dde9722f08ca75d761b68722158b2232b63def061de12a8/mkdocstrings_python-1.16.5-py3-none-any.whl", hash = "sha256:0899a12e356eab8e83720c63e15d0ff51cd96603216c837618de346e086b39ba", size = 451550 },
-]
-
-[[package]]
-name = "msal"
-version = "1.32.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cryptography" },
-    { name = "pyjwt", extra = ["crypto"] },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3f/90/81dcc50f0be11a8c4dcbae1a9f761a26e5f905231330a7cacc9f04ec4c61/msal-1.32.3.tar.gz", hash = "sha256:5eea038689c78a5a70ca8ecbe1245458b55a857bd096efb6989c69ba15985d35", size = 151449 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/bf/81516b9aac7fd867709984d08eb4db1d2e3fe1df795c8e442cde9b568962/msal-1.32.3-py3-none-any.whl", hash = "sha256:b2798db57760b1961b142f027ffb7c8169536bf77316e99a0df5c4aaebb11569", size = 115358 },
-]
-
-[[package]]
-name = "msal-extensions"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "msal" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/99/5d239b6156eddf761a636bded1118414d161bd6b7b37a9335549ed159396/msal_extensions-1.3.1.tar.gz", hash = "sha256:c5b0fd10f65ef62b5f1d62f4251d51cbcaf003fcedae8c91b040a488614be1a4", size = 23315 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/75/bd9b7bb966668920f06b200e84454c8f3566b102183bc55c5473d96cb2b9/msal_extensions-1.3.1-py3-none-any.whl", hash = "sha256:96d3de4d034504e969ac5e85bae8106c8373b5c6568e4c8fa7af2eca9dbe6bca", size = 20583 },
-]
-
-[[package]]
-name = "msrest"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "azure-core" },
-    { name = "certifi" },
-    { name = "isodate" },
-    { name = "requests" },
-    { name = "requests-oauthlib" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/68/77/8397c8fb8fc257d8ea0fa66f8068e073278c65f05acb17dcb22a02bfdc42/msrest-0.7.1.zip", hash = "sha256:6e7661f46f3afd88b75667b7187a92829924446c7ea1d169be8c4bb7eeb788b9", size = 175332 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/15/cf/f2966a2638144491f8696c27320d5219f48a072715075d168b31d3237720/msrest-0.7.1-py3-none-any.whl", hash = "sha256:21120a810e1233e5e6cc7fe40b474eeb4ec6f757a15d7cf86702c369f9567c32", size = 85384 },
-]
-
-[[package]]
-name = "mypy"
-version = "1.15.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mypy-extensions" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/f8/65a7ce8d0e09b6329ad0c8d40330d100ea343bd4dd04c4f8ae26462d0a17/mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13", size = 10738433 },
-    { url = "https://files.pythonhosted.org/packages/b4/95/9c0ecb8eacfe048583706249439ff52105b3f552ea9c4024166c03224270/mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559", size = 9861472 },
-    { url = "https://files.pythonhosted.org/packages/84/09/9ec95e982e282e20c0d5407bc65031dfd0f0f8ecc66b69538296e06fcbee/mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b", size = 11611424 },
-    { url = "https://files.pythonhosted.org/packages/78/13/f7d14e55865036a1e6a0a69580c240f43bc1f37407fe9235c0d4ef25ffb0/mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3", size = 12365450 },
-    { url = "https://files.pythonhosted.org/packages/48/e1/301a73852d40c241e915ac6d7bcd7fedd47d519246db2d7b86b9d7e7a0cb/mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b", size = 12551765 },
-    { url = "https://files.pythonhosted.org/packages/77/ba/c37bc323ae5fe7f3f15a28e06ab012cd0b7552886118943e90b15af31195/mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828", size = 9274701 },
-    { url = "https://files.pythonhosted.org/packages/03/bc/f6339726c627bd7ca1ce0fa56c9ae2d0144604a319e0e339bdadafbbb599/mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f", size = 10662338 },
-    { url = "https://files.pythonhosted.org/packages/e2/90/8dcf506ca1a09b0d17555cc00cd69aee402c203911410136cd716559efe7/mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5", size = 9787540 },
-    { url = "https://files.pythonhosted.org/packages/05/05/a10f9479681e5da09ef2f9426f650d7b550d4bafbef683b69aad1ba87457/mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e", size = 11538051 },
-    { url = "https://files.pythonhosted.org/packages/e9/9a/1f7d18b30edd57441a6411fcbc0c6869448d1a4bacbaee60656ac0fc29c8/mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c", size = 12286751 },
-    { url = "https://files.pythonhosted.org/packages/72/af/19ff499b6f1dafcaf56f9881f7a965ac2f474f69f6f618b5175b044299f5/mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f", size = 12421783 },
-    { url = "https://files.pythonhosted.org/packages/96/39/11b57431a1f686c1aed54bf794870efe0f6aeca11aca281a0bd87a5ad42c/mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f", size = 9265618 },
-    { url = "https://files.pythonhosted.org/packages/98/3a/03c74331c5eb8bd025734e04c9840532226775c47a2c39b56a0c8d4f128d/mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd", size = 10793981 },
-    { url = "https://files.pythonhosted.org/packages/f0/1a/41759b18f2cfd568848a37c89030aeb03534411eef981df621d8fad08a1d/mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f", size = 9749175 },
-    { url = "https://files.pythonhosted.org/packages/12/7e/873481abf1ef112c582db832740f4c11b2bfa510e829d6da29b0ab8c3f9c/mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464", size = 11455675 },
-    { url = "https://files.pythonhosted.org/packages/b3/d0/92ae4cde706923a2d3f2d6c39629134063ff64b9dedca9c1388363da072d/mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee", size = 12410020 },
-    { url = "https://files.pythonhosted.org/packages/46/8b/df49974b337cce35f828ba6fda228152d6db45fed4c86ba56ffe442434fd/mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e", size = 12498582 },
-    { url = "https://files.pythonhosted.org/packages/13/50/da5203fcf6c53044a0b699939f31075c45ae8a4cadf538a9069b165c1050/mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22", size = 9366614 },
-    { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 },
-    { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 },
-    { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 },
-    { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 },
-    { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 },
-    { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 },
-    { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 },
-]
-
-[[package]]
-name = "mypy-extensions"
-version = "1.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
-]
-
-[[package]]
-name = "nodeenv"
-version = "1.9.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 },
-]
-
-[[package]]
-name = "oauthlib"
-version = "3.2.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6d/fa/fbf4001037904031639e6bfbfc02badfc7e12f137a8afa254df6c4c8a670/oauthlib-3.2.2.tar.gz", hash = "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918", size = 177352 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/80/cab10959dc1faead58dc8384a781dfbf93cb4d33d50988f7a69f1b7c9bbe/oauthlib-3.2.2-py3-none-any.whl", hash = "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca", size = 151688 },
-]
-
-[[package]]
-name = "opentelemetry-api"
-version = "1.31.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "deprecated" },
-    { name = "importlib-metadata" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8a/cf/db26ab9d748bf50d6edf524fb863aa4da616ba1ce46c57a7dff1112b73fb/opentelemetry_api-1.31.1.tar.gz", hash = "sha256:137ad4b64215f02b3000a0292e077641c8611aab636414632a9b9068593b7e91", size = 64059 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/c8/86557ff0da32f3817bc4face57ea35cfdc2f9d3bcefd42311ef860dcefb7/opentelemetry_api-1.31.1-py3-none-any.whl", hash = "sha256:1511a3f470c9c8a32eeea68d4ea37835880c0eed09dd1a0187acc8b1301da0a1", size = 65197 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "packaging" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/49/c9/c52d444576b0776dbee71d2a4485be276cf46bec0123a5ba2f43f0cf7cde/opentelemetry_instrumentation-0.52b1.tar.gz", hash = "sha256:739f3bfadbbeec04dd59297479e15660a53df93c131d907bb61052e3d3c1406f", size = 28406 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/dd/a2b35078170941990e7a5194b9600fa75868958a9a2196a752da0e7b97a0/opentelemetry_instrumentation-0.52b1-py3-none-any.whl", hash = "sha256:8c0059c4379d77bbd8015c8d8476020efe873c123047ec069bb335e4b8717477", size = 31036 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-asgi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "asgiref" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bc/db/79bdc2344b38e60fecc7e99159a3f5b4c0e1acec8de305fba0a713cc3692/opentelemetry_instrumentation_asgi-0.52b1.tar.gz", hash = "sha256:a6dbce9cb5b2c2f45ce4817ad21f44c67fd328358ad3ab911eb46f0be67f82ec", size = 24203 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/de/39ec078ae94a365d2f434b7e25886c267864aca5695b48fa5b60f80fbfb3/opentelemetry_instrumentation_asgi-0.52b1-py3-none-any.whl", hash = "sha256:f7179f477ed665ba21871972f979f21e8534edb971232e11920c8a22f4759236", size = 16338 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-dbapi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a4/4b/c73327bc53671a773ec530ab7ee3f6ecf8686e2c76246d108e30b35a221e/opentelemetry_instrumentation_dbapi-0.52b1.tar.gz", hash = "sha256:62a6c37b659f6aa5476f12fb76c78f4ad27c49fb71a8a2c11609afcbb84f1e1c", size = 13864 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/76/2f1e9f1e1e8d99d8cc1386313d84a6be6f9caf8babdbbc2836f6ca28139b/opentelemetry_instrumentation_dbapi-0.52b1-py3-none-any.whl", hash = "sha256:47e54d26ad39f3951c7f3b4d4fb685a3c75445cfd57fcff2e92c416575c568ab", size = 12374 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-django"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/29/b2/3cbf0edad8bd59a2760a04e5897cff664e128be52c073f8124bed57bd944/opentelemetry_instrumentation_django-0.52b1.tar.gz", hash = "sha256:2541819564dae5edb0afd023de25d35761d8943aa88e6344b1e52f4fe036ccb6", size = 24613 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/65/79/1838524d736308f50ab03dd3cea097d8193bfe4bd0e886e7c806064b53a2/opentelemetry_instrumentation_django-0.52b1-py3-none-any.whl", hash = "sha256:895dcc551fa9c38c62e23d6b66ef250b20ff0afd7a39f8822ec61a2929dfc7c7", size = 19472 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-fastapi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-asgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/30/01/d159829077f2795c716445df6f8edfdd33391e82d712ba4613fb62b99dc5/opentelemetry_instrumentation_fastapi-0.52b1.tar.gz", hash = "sha256:d26ab15dc49e041301d5c2571605b8f5c3a6ee4a85b60940338f56c120221e98", size = 19247 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/89/acef7f625b218523873e32584dc5243d95ffa4facba737fd8b854c049c58/opentelemetry_instrumentation_fastapi-0.52b1-py3-none-any.whl", hash = "sha256:73c8804f053c5eb2fd2c948218bff9561f1ef65e89db326a6ab0b5bf829969f4", size = 12114 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-flask"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/00/55/83d3a859a10696d8e57f39497843b2522ca493ec1f1166ee94838c1158db/opentelemetry_instrumentation_flask-0.52b1.tar.gz", hash = "sha256:c8bc64da425ccbadb4a2ee5e8d99045e2282bfbf63bc9be07c386675839d00be", size = 19192 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/4c/c52dacd39c90d490eb4f9408f31014c370020e0ce2b9455958a2970e07c2/opentelemetry_instrumentation_flask-0.52b1-py3-none-any.whl", hash = "sha256:3c8b83147838bef24aac0182f0d49865321efba4cb1f96629f460330d21d0fa9", size = 14593 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-psycopg2"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-dbapi" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/84/d7/622e732f1914e4dedaa20a56af1edc9b7f7456d710bda471546b49d48874/opentelemetry_instrumentation_psycopg2-0.52b1.tar.gz", hash = "sha256:5bbdb2a2973aae9402946c995e277b1f76e467faebc40ac0f8da51c701918bb4", size = 9748 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/bd/58c72d6fd03810aa87375911d4e3b4029b9e36c05df4ae9735bc62b6574b/opentelemetry_instrumentation_psycopg2-0.52b1-py3-none-any.whl", hash = "sha256:51ac9f3d0b83889a1df2fc1342d86887142c2b70d8532043bc49b36fe95ea9d8", size = 10709 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-requests"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/56/d7/27588187a7092dc64129bc4c8808277460d353fc52299f3e0b9d9d09ce79/opentelemetry_instrumentation_requests-0.52b1.tar.gz", hash = "sha256:711a2ef90e32a0ffd4650b21376b8e102473845ba9121efca0d94314d529b501", size = 14377 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/c5/a1d78cb4beb9e7889799bf6d1c759d7b08f800cc068c94e94386678a7fe0/opentelemetry_instrumentation_requests-0.52b1-py3-none-any.whl", hash = "sha256:58ae3c415543d8ba2b0091b81ac13b65f2993adef0a4b9a5d3d7ebbe0023986a", size = 12746 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d2/39/7cb4380a3b86eb740c5781f55951231aea5c7f09ee0abc0609d4cb9035dd/opentelemetry_instrumentation_urllib-0.52b1.tar.gz", hash = "sha256:1364c742eaec56e11bab8723aecde378e438f86f753d93fcbf5ca8f6e1073a5c", size = 13790 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/1d/4da275bd8057f470589268dccf69ab60d2d9aa2c7a928338f9f5e6af18cb/opentelemetry_instrumentation_urllib-0.52b1-py3-none-any.whl", hash = "sha256:559ee1228194cf025c22b2515bdb855aefd9cec19596a7b30df5f092fbc72e56", size = 12625 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib3"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/97/4b/f0c0f7ee7c06a7068a7016de2f212e03f4a8e9ff17ea1b887b444a20cb62/opentelemetry_instrumentation_urllib3-0.52b1.tar.gz", hash = "sha256:b607aefd2c02ff7fbf6eea4b863f63348e64b29592ffa90dcc970a5bbcbe3c6b", size = 15697 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/01/f5cab7bbe73635e9ab351d6d4add625407dbb4aec4b3b6946101776ceb54/opentelemetry_instrumentation_urllib3-0.52b1-py3-none-any.whl", hash = "sha256:4011bac1639a6336c443252d93709eff17e316523f335ddee4ddb47bf464305e", size = 13124 },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-wsgi"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/db/e4/20540e7739a8beaf5cdbc20999475c61b9c5240ccc48164f1034917fb639/opentelemetry_instrumentation_wsgi-0.52b1.tar.gz", hash = "sha256:2c0534cacae594ef8c749edf3d1a8bce78e959a1b40efbc36f1b59d1f7977089", size = 18243 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/6d/4bccc2f324a75613a1cf7cd95642809424d5b7b5b7987e59a1fd7fb96f05/opentelemetry_instrumentation_wsgi-0.52b1-py3-none-any.whl", hash = "sha256:13d19958bb63df0dc32df23a047e94fe5db66151d29b17c01b1d751dd84029f8", size = 14377 },
-]
-
-[[package]]
-name = "opentelemetry-resource-detector-azure"
-version = "0.1.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-sdk" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/67/e4/0d359d48d03d447225b30c3dd889d5d454e3b413763ff721f9b0e4ac2e59/opentelemetry_resource_detector_azure-0.1.5.tar.gz", hash = "sha256:e0ba658a87c69eebc806e75398cd0e9f68a8898ea62de99bc1b7083136403710", size = 11503 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/c26d8da88ba2e438e9653a408b0c2ad6f17267801250a8f3cc6405a93a72/opentelemetry_resource_detector_azure-0.1.5-py3-none-any.whl", hash = "sha256:4dcc5d54ab5c3b11226af39509bc98979a8b9e0f8a24c1b888783755d3bf00eb", size = 14252 },
-]
-
-[[package]]
-name = "opentelemetry-sdk"
-version = "1.31.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/63/d9/4fe159908a63661e9e635e66edc0d0d816ed20cebcce886132b19ae87761/opentelemetry_sdk-1.31.1.tar.gz", hash = "sha256:c95f61e74b60769f8ff01ec6ffd3d29684743404603df34b20aa16a49dc8d903", size = 159523 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bc/36/758e5d3746bc86a2af20aa5e2236a7c5aa4264b501dc0e9f40efd9078ef0/opentelemetry_sdk-1.31.1-py3-none-any.whl", hash = "sha256:882d021321f223e37afaca7b4e06c1d8bbc013f9e17ff48a7aa017460a8e7dae", size = 118866 },
-]
-
-[[package]]
-name = "opentelemetry-semantic-conventions"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "deprecated" },
-    { name = "opentelemetry-api" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/8c/599f9f27cff097ec4d76fbe9fe6d1a74577ceec52efe1a999511e3c42ef5/opentelemetry_semantic_conventions-0.52b1.tar.gz", hash = "sha256:7b3d226ecf7523c27499758a58b542b48a0ac8d12be03c0488ff8ec60c5bae5d", size = 111275 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/be/d4ba300cfc1d4980886efbc9b48ee75242b9fcf940d9c4ccdc9ef413a7cf/opentelemetry_semantic_conventions-0.52b1-py3-none-any.whl", hash = "sha256:72b42db327e29ca8bb1b91e8082514ddf3bbf33f32ec088feb09526ade4bc77e", size = 183409 },
-]
-
-[[package]]
-name = "opentelemetry-util-http"
-version = "0.52b1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/23/3f/16a4225a953bbaae7d800140ed99813f092ea3071ba7780683299a87049b/opentelemetry_util_http-0.52b1.tar.gz", hash = "sha256:c03c8c23f1b75fadf548faece7ead3aecd50761c5593a2b2831b48730eee5b31", size = 8044 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/00/1591b397c9efc0e4215d223553a1cb9090c8499888a4447f842443077d31/opentelemetry_util_http-0.52b1-py3-none-any.whl", hash = "sha256:6a6ab6bfa23fef96f4995233e874f67602adf9d224895981b4ab9d4dde23de78", size = 7305 },
-]
-
-[[package]]
-name = "outcome"
-version = "1.3.0.post0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692 },
-]
-
-[[package]]
-name = "packaging"
-version = "24.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
-]
-
-[[package]]
-name = "paginate"
-version = "0.5.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746 },
-]
-
-[[package]]
-name = "pathlib"
-version = "1.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ac/aa/9b065a76b9af472437a0059f77e8f962fe350438b927cb80184c32f075eb/pathlib-1.0.1.tar.gz", hash = "sha256:6940718dfc3eff4258203ad5021090933e5c04707d5ca8cc9e73c94a7894ea9f", size = 49298 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/f9/690a8600b93c332de3ab4a344a4ac34f00c8f104917061f779db6a918ed6/pathlib-1.0.1-py3-none-any.whl", hash = "sha256:f35f95ab8b0f59e6d354090350b44a80a80635d22efdedfa84c7ad1cf0a74147", size = 14363 },
-]
-
-[[package]]
-name = "pathspec"
-version = "0.12.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },
-]
-
-[[package]]
-name = "pbr"
-version = "6.1.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "setuptools" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/d2/510cc0d218e753ba62a1bc1434651db3cd797a9716a0a66cc714cb4f0935/pbr-6.1.1.tar.gz", hash = "sha256:93ea72ce6989eb2eed99d0f75721474f69ad88128afdef5ac377eb797c4bf76b", size = 125702 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/ac/684d71315abc7b1214d59304e23a982472967f6bf4bde5a98f1503f648dc/pbr-6.1.1-py2.py3-none-any.whl", hash = "sha256:38d4daea5d9fa63b3f626131b9d34947fd0c8be9b05a29276870580050a25a76", size = 108997 },
-]
-
-[[package]]
-name = "pillow"
-version = "10.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271 },
-    { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658 },
-    { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075 },
-    { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808 },
-    { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290 },
-    { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163 },
-    { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100 },
-    { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880 },
-    { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218 },
-    { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487 },
-    { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219 },
-    { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265 },
-    { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655 },
-    { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304 },
-    { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804 },
-    { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126 },
-    { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541 },
-    { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616 },
-    { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802 },
-    { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213 },
-    { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498 },
-    { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219 },
-    { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350 },
-    { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980 },
-    { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799 },
-    { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973 },
-    { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054 },
-    { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484 },
-    { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375 },
-    { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773 },
-    { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690 },
-    { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951 },
-    { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427 },
-    { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685 },
-    { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883 },
-    { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837 },
-    { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562 },
-    { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761 },
-    { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767 },
-    { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989 },
-    { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255 },
-    { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603 },
-    { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972 },
-    { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375 },
-    { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889 },
-    { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160 },
-    { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020 },
-    { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539 },
-    { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125 },
-    { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373 },
-    { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661 },
-]
-
-[[package]]
-name = "platformdirs"
-version = "4.3.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 },
-]
-
-[[package]]
-name = "pluggy"
-version = "1.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
-]
-
-[[package]]
-name = "pre-commit"
-version = "4.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cfgv" },
-    { name = "identify" },
-    { name = "nodeenv" },
-    { name = "pyyaml" },
-    { name = "virtualenv" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/13/b62d075317d8686071eb843f0bb1f195eb332f48869d3c31a4c6f1e063ac/pre_commit-4.1.0.tar.gz", hash = "sha256:ae3f018575a588e30dfddfab9a05448bfbd6b73d78709617b5a2b853549716d4", size = 193330 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/b3/df14c580d82b9627d173ceea305ba898dca135feb360b6d84019d0803d3b/pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b", size = 220560 },
-]
-
-[[package]]
-name = "psutil"
-version = "6.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5", size = 508502 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8", size = 247511 },
-    { url = "https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377", size = 248985 },
-    { url = "https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003", size = 284488 },
-    { url = "https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160", size = 287477 },
-    { url = "https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3", size = 289017 },
-    { url = "https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53", size = 250602 },
-    { url = "https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649", size = 254444 },
-]
-
-[[package]]
-name = "pycparser"
-version = "2.22"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
-]
-
-[[package]]
-name = "pydantic"
-version = "2.11.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/93/a3/698b87a4d4d303d7c5f62ea5fbf7a79cab236ccfbd0a17847b7f77f8163e/pydantic-2.11.1.tar.gz", hash = "sha256:442557d2910e75c991c39f4b4ab18963d57b9b55122c8b2a9cd176d8c29ce968", size = 782817 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/12/f9221a949f2419e2e23847303c002476c26fbcfd62dc7f3d25d0bec5ca99/pydantic-2.11.1-py3-none-any.whl", hash = "sha256:5b6c415eee9f8123a14d859be0c84363fec6b1feb6b688d6435801230b56e0b8", size = 442648 },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.33.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/05/91ce14dfd5a3a99555fce436318cc0fd1f08c4daa32b3248ad63669ea8b4/pydantic_core-2.33.0.tar.gz", hash = "sha256:40eb8af662ba409c3cbf4a8150ad32ae73514cd7cb1f1a2113af39763dd616b3", size = 434080 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/29/43/0649ad07e66b36a3fb21442b425bd0348ac162c5e686b36471f363201535/pydantic_core-2.33.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:71dffba8fe9ddff628c68f3abd845e91b028361d43c5f8e7b3f8b91d7d85413e", size = 2042968 },
-    { url = "https://files.pythonhosted.org/packages/a0/a6/975fea4774a459e495cb4be288efd8b041ac756a0a763f0b976d0861334b/pydantic_core-2.33.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:abaeec1be6ed535a5d7ffc2e6c390083c425832b20efd621562fbb5bff6dc518", size = 1860347 },
-    { url = "https://files.pythonhosted.org/packages/aa/49/7858dadad305101a077ec4d0c606b6425a2b134ea8d858458a6d287fd871/pydantic_core-2.33.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:759871f00e26ad3709efc773ac37b4d571de065f9dfb1778012908bcc36b3a73", size = 1910060 },
-    { url = "https://files.pythonhosted.org/packages/8d/4f/6522527911d9c5fe6d76b084d8b388d5c84b09d113247b39f91937500b34/pydantic_core-2.33.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dcfebee69cd5e1c0b76a17e17e347c84b00acebb8dd8edb22d4a03e88e82a207", size = 1997129 },
-    { url = "https://files.pythonhosted.org/packages/75/d0/06f396da053e3d73001ea4787e56b4d7132a87c0b5e2e15a041e808c35cd/pydantic_core-2.33.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1b1262b912435a501fa04cd213720609e2cefa723a07c92017d18693e69bf00b", size = 2140389 },
-    { url = "https://files.pythonhosted.org/packages/f5/6b/b9ff5b69cd4ef007cf665463f3be2e481dc7eb26c4a55b2f57a94308c31a/pydantic_core-2.33.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4726f1f3f42d6a25678c67da3f0b10f148f5655813c5aca54b0d1742ba821b8f", size = 2754237 },
-    { url = "https://files.pythonhosted.org/packages/53/80/b4879de375cdf3718d05fcb60c9aa1f119d28e261dafa51b6a69c78f7178/pydantic_core-2.33.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e790954b5093dff1e3a9a2523fddc4e79722d6f07993b4cd5547825c3cbf97b5", size = 2007433 },
-    { url = "https://files.pythonhosted.org/packages/46/24/54054713dc0af98a94eab37e0f4294dfd5cd8f70b2ca9dcdccd15709fd7e/pydantic_core-2.33.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:34e7fb3abe375b5c4e64fab75733d605dda0f59827752debc99c17cb2d5f3276", size = 2123980 },
-    { url = "https://files.pythonhosted.org/packages/3a/4c/257c1cb89e14cfa6e95ebcb91b308eb1dd2b348340ff76a6e6fcfa9969e1/pydantic_core-2.33.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ecb158fb9b9091b515213bed3061eb7deb1d3b4e02327c27a0ea714ff46b0760", size = 2087433 },
-    { url = "https://files.pythonhosted.org/packages/0c/62/927df8a39ad78ef7b82c5446e01dec9bb0043e1ad71d8f426062f5f014db/pydantic_core-2.33.0-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:4d9149e7528af8bbd76cc055967e6e04617dcb2a2afdaa3dea899406c5521faa", size = 2260242 },
-    { url = "https://files.pythonhosted.org/packages/74/f2/389414f7c77a100954e84d6f52a82bd1788ae69db72364376d8a73b38765/pydantic_core-2.33.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e81a295adccf73477220e15ff79235ca9dcbcee4be459eb9d4ce9a2763b8386c", size = 2258227 },
-    { url = "https://files.pythonhosted.org/packages/53/99/94516313e15d906a1264bb40faf24a01a4af4e2ca8a7c10dd173b6513c5a/pydantic_core-2.33.0-cp310-cp310-win32.whl", hash = "sha256:f22dab23cdbce2005f26a8f0c71698457861f97fc6318c75814a50c75e87d025", size = 1925523 },
-    { url = "https://files.pythonhosted.org/packages/7d/67/cc789611c6035a0b71305a1ec6ba196256ced76eba8375f316f840a70456/pydantic_core-2.33.0-cp310-cp310-win_amd64.whl", hash = "sha256:9cb2390355ba084c1ad49485d18449b4242da344dea3e0fe10babd1f0db7dcfc", size = 1951872 },
-    { url = "https://files.pythonhosted.org/packages/f0/93/9e97af2619b4026596487a79133e425c7d3c374f0a7f100f3d76bcdf9c83/pydantic_core-2.33.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a608a75846804271cf9c83e40bbb4dab2ac614d33c6fd5b0c6187f53f5c593ef", size = 2042784 },
-    { url = "https://files.pythonhosted.org/packages/42/b4/0bba8412fd242729feeb80e7152e24f0e1a1c19f4121ca3d4a307f4e6222/pydantic_core-2.33.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e1c69aa459f5609dec2fa0652d495353accf3eda5bdb18782bc5a2ae45c9273a", size = 1858179 },
-    { url = "https://files.pythonhosted.org/packages/69/1f/c1c40305d929bd08af863df64b0a26203b70b352a1962d86f3bcd52950fe/pydantic_core-2.33.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9ec80eb5a5f45a2211793f1c4aeddff0c3761d1c70d684965c1807e923a588b", size = 1909396 },
-    { url = "https://files.pythonhosted.org/packages/0f/99/d2e727375c329c1e652b5d450fbb9d56e8c3933a397e4bd46e67c68c2cd5/pydantic_core-2.33.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e925819a98318d17251776bd3d6aa9f3ff77b965762155bdad15d1a9265c4cfd", size = 1998264 },
-    { url = "https://files.pythonhosted.org/packages/9c/2e/3119a33931278d96ecc2e9e1b9d50c240636cfeb0c49951746ae34e4de74/pydantic_core-2.33.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5bf68bb859799e9cec3d9dd8323c40c00a254aabb56fe08f907e437005932f2b", size = 2140588 },
-    { url = "https://files.pythonhosted.org/packages/35/bd/9267bd1ba55f17c80ef6cb7e07b3890b4acbe8eb6014f3102092d53d9300/pydantic_core-2.33.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b2ea72dea0825949a045fa4071f6d5b3d7620d2a208335207793cf29c5a182d", size = 2746296 },
-    { url = "https://files.pythonhosted.org/packages/6f/ed/ef37de6478a412ee627cbebd73e7b72a680f45bfacce9ff1199de6e17e88/pydantic_core-2.33.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1583539533160186ac546b49f5cde9ffc928062c96920f58bd95de32ffd7bffd", size = 2005555 },
-    { url = "https://files.pythonhosted.org/packages/dd/84/72c8d1439585d8ee7bc35eb8f88a04a4d302ee4018871f1f85ae1b0c6625/pydantic_core-2.33.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:23c3e77bf8a7317612e5c26a3b084c7edeb9552d645742a54a5867635b4f2453", size = 2124452 },
-    { url = "https://files.pythonhosted.org/packages/a7/8f/cb13de30c6a3e303423751a529a3d1271c2effee4b98cf3e397a66ae8498/pydantic_core-2.33.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a7a7f2a3f628d2f7ef11cb6188bcf0b9e1558151d511b974dfea10a49afe192b", size = 2087001 },
-    { url = "https://files.pythonhosted.org/packages/83/d0/e93dc8884bf288a63fedeb8040ac8f29cb71ca52e755f48e5170bb63e55b/pydantic_core-2.33.0-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:f1fb026c575e16f673c61c7b86144517705865173f3d0907040ac30c4f9f5915", size = 2261663 },
-    { url = "https://files.pythonhosted.org/packages/4c/ba/4b7739c95efa0b542ee45fd872c8f6b1884ab808cf04ce7ac6621b6df76e/pydantic_core-2.33.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:635702b2fed997e0ac256b2cfbdb4dd0bf7c56b5d8fba8ef03489c03b3eb40e2", size = 2257786 },
-    { url = "https://files.pythonhosted.org/packages/cc/98/73cbca1d2360c27752cfa2fcdcf14d96230e92d7d48ecd50499865c56bf7/pydantic_core-2.33.0-cp311-cp311-win32.whl", hash = "sha256:07b4ced28fccae3f00626eaa0c4001aa9ec140a29501770a88dbbb0966019a86", size = 1925697 },
-    { url = "https://files.pythonhosted.org/packages/9a/26/d85a40edeca5d8830ffc33667d6fef329fd0f4bc0c5181b8b0e206cfe488/pydantic_core-2.33.0-cp311-cp311-win_amd64.whl", hash = "sha256:4927564be53239a87770a5f86bdc272b8d1fbb87ab7783ad70255b4ab01aa25b", size = 1949859 },
-    { url = "https://files.pythonhosted.org/packages/7e/0b/5a381605f0b9870465b805f2c86c06b0a7c191668ebe4117777306c2c1e5/pydantic_core-2.33.0-cp311-cp311-win_arm64.whl", hash = "sha256:69297418ad644d521ea3e1aa2e14a2a422726167e9ad22b89e8f1130d68e1e9a", size = 1907978 },
-    { url = "https://files.pythonhosted.org/packages/a9/c4/c9381323cbdc1bb26d352bc184422ce77c4bc2f2312b782761093a59fafc/pydantic_core-2.33.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6c32a40712e3662bebe524abe8abb757f2fa2000028d64cc5a1006016c06af43", size = 2025127 },
-    { url = "https://files.pythonhosted.org/packages/6f/bd/af35278080716ecab8f57e84515c7dc535ed95d1c7f52c1c6f7b313a9dab/pydantic_core-2.33.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8ec86b5baa36f0a0bfb37db86c7d52652f8e8aa076ab745ef7725784183c3fdd", size = 1851687 },
-    { url = "https://files.pythonhosted.org/packages/12/e4/a01461225809c3533c23bd1916b1e8c2e21727f0fea60ab1acbffc4e2fca/pydantic_core-2.33.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4deac83a8cc1d09e40683be0bc6d1fa4cde8df0a9bf0cda5693f9b0569ac01b6", size = 1892232 },
-    { url = "https://files.pythonhosted.org/packages/51/17/3d53d62a328fb0a49911c2962036b9e7a4f781b7d15e9093c26299e5f76d/pydantic_core-2.33.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:175ab598fb457a9aee63206a1993874badf3ed9a456e0654273e56f00747bbd6", size = 1977896 },
-    { url = "https://files.pythonhosted.org/packages/30/98/01f9d86e02ec4a38f4b02086acf067f2c776b845d43f901bd1ee1c21bc4b/pydantic_core-2.33.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f36afd0d56a6c42cf4e8465b6441cf546ed69d3a4ec92724cc9c8c61bd6ecf4", size = 2127717 },
-    { url = "https://files.pythonhosted.org/packages/3c/43/6f381575c61b7c58b0fd0b92134c5a1897deea4cdfc3d47567b3ff460a4e/pydantic_core-2.33.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0a98257451164666afafc7cbf5fb00d613e33f7e7ebb322fbcd99345695a9a61", size = 2680287 },
-    { url = "https://files.pythonhosted.org/packages/01/42/c0d10d1451d161a9a0da9bbef023b8005aa26e9993a8cc24dc9e3aa96c93/pydantic_core-2.33.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecc6d02d69b54a2eb83ebcc6f29df04957f734bcf309d346b4f83354d8376862", size = 2008276 },
-    { url = "https://files.pythonhosted.org/packages/20/ca/e08df9dba546905c70bae44ced9f3bea25432e34448d95618d41968f40b7/pydantic_core-2.33.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a69b7596c6603afd049ce7f3835bcf57dd3892fc7279f0ddf987bebed8caa5a", size = 2115305 },
-    { url = "https://files.pythonhosted.org/packages/03/1f/9b01d990730a98833113581a78e595fd40ed4c20f9693f5a658fb5f91eff/pydantic_core-2.33.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ea30239c148b6ef41364c6f51d103c2988965b643d62e10b233b5efdca8c0099", size = 2068999 },
-    { url = "https://files.pythonhosted.org/packages/20/18/fe752476a709191148e8b1e1139147841ea5d2b22adcde6ee6abb6c8e7cf/pydantic_core-2.33.0-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:abfa44cf2f7f7d7a199be6c6ec141c9024063205545aa09304349781b9a125e6", size = 2241488 },
-    { url = "https://files.pythonhosted.org/packages/81/22/14738ad0a0bf484b928c9e52004f5e0b81dd8dabbdf23b843717b37a71d1/pydantic_core-2.33.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:20d4275f3c4659d92048c70797e5fdc396c6e4446caf517ba5cad2db60cd39d3", size = 2248430 },
-    { url = "https://files.pythonhosted.org/packages/e8/27/be7571e215ac8d321712f2433c445b03dbcd645366a18f67b334df8912bc/pydantic_core-2.33.0-cp312-cp312-win32.whl", hash = "sha256:918f2013d7eadea1d88d1a35fd4a1e16aaf90343eb446f91cb091ce7f9b431a2", size = 1908353 },
-    { url = "https://files.pythonhosted.org/packages/be/3a/be78f28732f93128bd0e3944bdd4b3970b389a1fbd44907c97291c8dcdec/pydantic_core-2.33.0-cp312-cp312-win_amd64.whl", hash = "sha256:aec79acc183865bad120b0190afac467c20b15289050648b876b07777e67ea48", size = 1955956 },
-    { url = "https://files.pythonhosted.org/packages/21/26/b8911ac74faa994694b76ee6a22875cc7a4abea3c381fdba4edc6c6bef84/pydantic_core-2.33.0-cp312-cp312-win_arm64.whl", hash = "sha256:5461934e895968655225dfa8b3be79e7e927e95d4bd6c2d40edd2fa7052e71b6", size = 1903259 },
-    { url = "https://files.pythonhosted.org/packages/79/20/de2ad03ce8f5b3accf2196ea9b44f31b0cd16ac6e8cfc6b21976ed45ec35/pydantic_core-2.33.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f00e8b59e1fc8f09d05594aa7d2b726f1b277ca6155fc84c0396db1b373c4555", size = 2032214 },
-    { url = "https://files.pythonhosted.org/packages/f9/af/6817dfda9aac4958d8b516cbb94af507eb171c997ea66453d4d162ae8948/pydantic_core-2.33.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a73be93ecef45786d7d95b0c5e9b294faf35629d03d5b145b09b81258c7cd6d", size = 1852338 },
-    { url = "https://files.pythonhosted.org/packages/44/f3/49193a312d9c49314f2b953fb55740b7c530710977cabe7183b8ef111b7f/pydantic_core-2.33.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff48a55be9da6930254565ff5238d71d5e9cd8c5487a191cb85df3bdb8c77365", size = 1896913 },
-    { url = "https://files.pythonhosted.org/packages/06/e0/c746677825b2e29a2fa02122a8991c83cdd5b4c5f638f0664d4e35edd4b2/pydantic_core-2.33.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26a4ea04195638dcd8c53dadb545d70badba51735b1594810e9768c2c0b4a5da", size = 1986046 },
-    { url = "https://files.pythonhosted.org/packages/11/ec/44914e7ff78cef16afb5e5273d480c136725acd73d894affdbe2a1bbaad5/pydantic_core-2.33.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41d698dcbe12b60661f0632b543dbb119e6ba088103b364ff65e951610cb7ce0", size = 2128097 },
-    { url = "https://files.pythonhosted.org/packages/fe/f5/c6247d424d01f605ed2e3802f338691cae17137cee6484dce9f1ac0b872b/pydantic_core-2.33.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae62032ef513fe6281ef0009e30838a01057b832dc265da32c10469622613885", size = 2681062 },
-    { url = "https://files.pythonhosted.org/packages/f0/85/114a2113b126fdd7cf9a9443b1b1fe1b572e5bd259d50ba9d5d3e1927fa9/pydantic_core-2.33.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f225f3a3995dbbc26affc191d0443c6c4aa71b83358fd4c2b7d63e2f6f0336f9", size = 2007487 },
-    { url = "https://files.pythonhosted.org/packages/e6/40/3c05ed28d225c7a9acd2b34c5c8010c279683a870219b97e9f164a5a8af0/pydantic_core-2.33.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5bdd36b362f419c78d09630cbaebc64913f66f62bda6d42d5fbb08da8cc4f181", size = 2121382 },
-    { url = "https://files.pythonhosted.org/packages/8a/22/e70c086f41eebd323e6baa92cc906c3f38ddce7486007eb2bdb3b11c8f64/pydantic_core-2.33.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:2a0147c0bef783fd9abc9f016d66edb6cac466dc54a17ec5f5ada08ff65caf5d", size = 2072473 },
-    { url = "https://files.pythonhosted.org/packages/3e/84/d1614dedd8fe5114f6a0e348bcd1535f97d76c038d6102f271433cd1361d/pydantic_core-2.33.0-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:c860773a0f205926172c6644c394e02c25421dc9a456deff16f64c0e299487d3", size = 2249468 },
-    { url = "https://files.pythonhosted.org/packages/b0/c0/787061eef44135e00fddb4b56b387a06c303bfd3884a6df9bea5cb730230/pydantic_core-2.33.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:138d31e3f90087f42aa6286fb640f3c7a8eb7bdae829418265e7e7474bd2574b", size = 2254716 },
-    { url = "https://files.pythonhosted.org/packages/ae/e2/27262eb04963201e89f9c280f1e10c493a7a37bc877e023f31aa72d2f911/pydantic_core-2.33.0-cp313-cp313-win32.whl", hash = "sha256:d20cbb9d3e95114325780f3cfe990f3ecae24de7a2d75f978783878cce2ad585", size = 1916450 },
-    { url = "https://files.pythonhosted.org/packages/13/8d/25ff96f1e89b19e0b70b3cd607c9ea7ca27e1dcb810a9cd4255ed6abf869/pydantic_core-2.33.0-cp313-cp313-win_amd64.whl", hash = "sha256:ca1103d70306489e3d006b0f79db8ca5dd3c977f6f13b2c59ff745249431a606", size = 1956092 },
-    { url = "https://files.pythonhosted.org/packages/1b/64/66a2efeff657b04323ffcd7b898cb0354d36dae3a561049e092134a83e9c/pydantic_core-2.33.0-cp313-cp313-win_arm64.whl", hash = "sha256:6291797cad239285275558e0a27872da735b05c75d5237bbade8736f80e4c225", size = 1908367 },
-    { url = "https://files.pythonhosted.org/packages/52/54/295e38769133363d7ec4a5863a4d579f331728c71a6644ff1024ee529315/pydantic_core-2.33.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7b79af799630af263eca9ec87db519426d8c9b3be35016eddad1832bac812d87", size = 1813331 },
-    { url = "https://files.pythonhosted.org/packages/4c/9c/0c8ea02db8d682aa1ef48938abae833c1d69bdfa6e5ec13b21734b01ae70/pydantic_core-2.33.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eabf946a4739b5237f4f56d77fa6668263bc466d06a8036c055587c130a46f7b", size = 1986653 },
-    { url = "https://files.pythonhosted.org/packages/8e/4f/3fb47d6cbc08c7e00f92300e64ba655428c05c56b8ab6723bd290bae6458/pydantic_core-2.33.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8a1d581e8cdbb857b0e0e81df98603376c1a5c34dc5e54039dcc00f043df81e7", size = 1931234 },
-    { url = "https://files.pythonhosted.org/packages/44/77/85e173b715e1a277ce934f28d877d82492df13e564fa68a01c96f36a47ad/pydantic_core-2.33.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e2762c568596332fdab56b07060c8ab8362c56cf2a339ee54e491cd503612c50", size = 2040129 },
-    { url = "https://files.pythonhosted.org/packages/33/e7/33da5f8a94bbe2191cfcd15bd6d16ecd113e67da1b8c78d3cc3478112dab/pydantic_core-2.33.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bf637300ff35d4f59c006fff201c510b2b5e745b07125458a5389af3c0dff8c", size = 1872656 },
-    { url = "https://files.pythonhosted.org/packages/b4/7a/9600f222bea840e5b9ba1f17c0acc79b669b24542a78c42c6a10712c0aae/pydantic_core-2.33.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62c151ce3d59ed56ebd7ce9ce5986a409a85db697d25fc232f8e81f195aa39a1", size = 1903731 },
-    { url = "https://files.pythonhosted.org/packages/81/d2/94c7ca4e24c5dcfb74df92e0836c189e9eb6814cf62d2f26a75ea0a906db/pydantic_core-2.33.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee65f0cc652261744fd07f2c6e6901c914aa6c5ff4dcfaf1136bc394d0dd26b", size = 2083966 },
-    { url = "https://files.pythonhosted.org/packages/b8/74/a0259989d220e8865ed6866a6d40539e40fa8f507e587e35d2414cc081f8/pydantic_core-2.33.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:024d136ae44d233e6322027bbf356712b3940bee816e6c948ce4b90f18471b3d", size = 2118951 },
-    { url = "https://files.pythonhosted.org/packages/13/4c/87405ed04d6d07597920b657f082a8e8e58bf3034178bb9044b4d57a91e2/pydantic_core-2.33.0-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:e37f10f6d4bc67c58fbd727108ae1d8b92b397355e68519f1e4a7babb1473442", size = 2079632 },
-    { url = "https://files.pythonhosted.org/packages/5a/4c/bcb02970ef91d4cd6de7c6893101302637da456bc8b52c18ea0d047b55ce/pydantic_core-2.33.0-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:502ed542e0d958bd12e7c3e9a015bce57deaf50eaa8c2e1c439b512cb9db1e3a", size = 2250541 },
-    { url = "https://files.pythonhosted.org/packages/a3/2b/dbe5450c4cd904be5da736dcc7f2357b828199e29e38de19fc81f988b288/pydantic_core-2.33.0-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:715c62af74c236bf386825c0fdfa08d092ab0f191eb5b4580d11c3189af9d330", size = 2255685 },
-    { url = "https://files.pythonhosted.org/packages/ca/a6/ca1d35f695d81f639c5617fc9efb44caad21a9463383fa45364b3044175a/pydantic_core-2.33.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bccc06fa0372151f37f6b69834181aa9eb57cf8665ed36405fb45fbf6cac3bae", size = 2082395 },
-    { url = "https://files.pythonhosted.org/packages/2b/b2/553e42762e7b08771fca41c0230c1ac276f9e79e78f57628e1b7d328551d/pydantic_core-2.33.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5d8dc9f63a26f7259b57f46a7aab5af86b2ad6fbe48487500bb1f4b27e051e4c", size = 2041207 },
-    { url = "https://files.pythonhosted.org/packages/85/81/a91a57bbf3efe53525ab75f65944b8950e6ef84fe3b9a26c1ec173363263/pydantic_core-2.33.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:30369e54d6d0113d2aa5aee7a90d17f225c13d87902ace8fcd7bbf99b19124db", size = 1873736 },
-    { url = "https://files.pythonhosted.org/packages/9c/d2/5ab52e9f551cdcbc1ee99a0b3ef595f56d031f66f88e5ca6726c49f9ce65/pydantic_core-2.33.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3eb479354c62067afa62f53bb387827bee2f75c9c79ef25eef6ab84d4b1ae3b", size = 1903794 },
-    { url = "https://files.pythonhosted.org/packages/2f/5f/a81742d3f3821b16f1265f057d6e0b68a3ab13a814fe4bffac536a1f26fd/pydantic_core-2.33.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0310524c833d91403c960b8a3cf9f46c282eadd6afd276c8c5edc617bd705dc9", size = 2083457 },
-    { url = "https://files.pythonhosted.org/packages/b5/2f/e872005bc0fc47f9c036b67b12349a8522d32e3bda928e82d676e2a594d1/pydantic_core-2.33.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eddb18a00bbb855325db27b4c2a89a4ba491cd6a0bd6d852b225172a1f54b36c", size = 2119537 },
-    { url = "https://files.pythonhosted.org/packages/d3/13/183f13ce647202eaf3dada9e42cdfc59cbb95faedd44d25f22b931115c7f/pydantic_core-2.33.0-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:ade5dbcf8d9ef8f4b28e682d0b29f3008df9842bb5ac48ac2c17bc55771cc976", size = 2080069 },
-    { url = "https://files.pythonhosted.org/packages/23/8b/b6be91243da44a26558d9c3a9007043b3750334136c6550551e8092d6d96/pydantic_core-2.33.0-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:2c0afd34f928383e3fd25740f2050dbac9d077e7ba5adbaa2227f4d4f3c8da5c", size = 2251618 },
-    { url = "https://files.pythonhosted.org/packages/aa/c5/fbcf1977035b834f63eb542e74cd6c807177f383386175b468f0865bcac4/pydantic_core-2.33.0-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:7da333f21cd9df51d5731513a6d39319892947604924ddf2e24a4612975fb936", size = 2255374 },
-    { url = "https://files.pythonhosted.org/packages/2f/f8/66f328e411f1c9574b13c2c28ab01f308b53688bbbe6ca8fb981e6cabc42/pydantic_core-2.33.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4b6d77c75a57f041c5ee915ff0b0bb58eabb78728b69ed967bc5b780e8f701b8", size = 2082099 },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
-]
-
-[[package]]
-name = "pyjwt"
-version = "2.10.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997 },
-]
-
-[package.optional-dependencies]
-crypto = [
-    { name = "cryptography" },
-]
-
-[[package]]
-name = "pymdown-extensions"
-version = "10.14.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown" },
-    { name = "pyyaml" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7c/44/e6de2fdc880ad0ec7547ca2e087212be815efbc9a425a8d5ba9ede602cbb/pymdown_extensions-10.14.3.tar.gz", hash = "sha256:41e576ce3f5d650be59e900e4ceff231e0aed2a88cf30acaee41e02f063a061b", size = 846846 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/f5/b9e2a42aa8f9e34d52d66de87941ecd236570c7ed2e87775ed23bbe4e224/pymdown_extensions-10.14.3-py3-none-any.whl", hash = "sha256:05e0bee73d64b9c71a4ae17c72abc2f700e8bc8403755a00580b49a4e9f189e9", size = 264467 },
-]
-
-[[package]]
-name = "pytest"
-version = "8.3.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 },
-]
-
-[[package]]
-name = "pytest-asyncio"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4e/51/f8794af39eeb870e87a8c8068642fc07bce0c854d6865d7dd0f2a9d338c2/pytest_asyncio-1.1.0.tar.gz", hash = "sha256:796aa822981e01b68c12e4827b8697108f7205020f24b5793b3c41555dab68ea", size = 46652 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/9d/bf86eddabf8c6c9cb1ea9a869d6873b46f105a5d292d3a6f7071f5b07935/pytest_asyncio-1.1.0-py3-none-any.whl", hash = "sha256:5fe2d69607b0bd75c656d1211f969cadba035030156745ee09e7d71740e58ecf", size = 15157 },
-]
-
-[[package]]
-name = "pytest-cov"
-version = "6.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "coverage", extra = ["toml"] },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 },
-]
-
-[[package]]
-name = "pytest-httpx"
-version = "0.35.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "httpx" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1f/89/5b12b7b29e3d0af3a4b9c071ee92fa25a9017453731a38f08ba01c280f4c/pytest_httpx-0.35.0.tar.gz", hash = "sha256:d619ad5d2e67734abfbb224c3d9025d64795d4b8711116b1a13f72a251ae511f", size = 54146 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/ed/026d467c1853dd83102411a78126b4842618e86c895f93528b0528c7a620/pytest_httpx-0.35.0-py3-none-any.whl", hash = "sha256:ee11a00ffcea94a5cbff47af2114d34c5b231c326902458deed73f9c459fd744", size = 19442 },
-]
-
-[[package]]
-name = "pytest-mock"
-version = "3.14.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 },
-]
-
-[[package]]
-name = "pytest-trio"
-version = "0.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "outcome" },
-    { name = "pytest" },
-    { name = "trio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/13/08/056279526554c6c6e6ad6d4a479a338d14dc785ac30be8bdc6ca0153c1be/pytest-trio-0.8.0.tar.gz", hash = "sha256:8363db6336a79e6c53375a2123a41ddbeccc4aa93f93788651641789a56fb52e", size = 46525 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/22/71953f47e0da5852c899f58cd7a31e6100f37c632b7b9ee52d067613a844/pytest_trio-0.8.0-py3-none-any.whl", hash = "sha256:e6a7e7351ae3e8ec3f4564d30ee77d1ec66e1df611226e5618dbb32f9545c841", size = 27221 },
-]
-
-[[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
-]
-
-[[package]]
-name = "python-dotenv"
-version = "1.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 },
-]
-
-[[package]]
-name = "pyyaml"
-version = "6.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 },
-    { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 },
-    { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 },
-    { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 },
-    { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 },
-    { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 },
-    { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 },
-    { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 },
-    { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 },
-    { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 },
-    { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 },
-    { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 },
-    { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 },
-    { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 },
-    { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 },
-    { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 },
-    { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 },
-    { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 },
-    { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 },
-    { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 },
-    { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 },
-    { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 },
-    { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 },
-    { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 },
-    { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 },
-    { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 },
-    { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 },
-    { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 },
-    { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 },
-    { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 },
-    { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 },
-    { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 },
-    { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 },
-    { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 },
-    { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 },
-    { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 },
-]
-
-[[package]]
-name = "pyyaml-env-tag"
-version = "0.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyyaml" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fb/8e/da1c6c58f751b70f8ceb1eb25bc25d524e8f14fe16edcce3f4e3ba08629c/pyyaml_env_tag-0.1.tar.gz", hash = "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb", size = 5631 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/66/bbb1dd374f5c870f59c5bb1db0e18cbe7fa739415a24cbd95b2d1f5ae0c4/pyyaml_env_tag-0.1-py3-none-any.whl", hash = "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069", size = 3911 },
-]
-
-[[package]]
-name = "requests"
-version = "2.32.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "charset-normalizer" },
-    { name = "idna" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
-]
-
-[[package]]
-name = "requests-oauthlib"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "oauthlib" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179 },
-]
-
-[[package]]
-name = "rich"
-version = "13.9.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown-it-py" },
-    { name = "pygments" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 },
-]
-
-[[package]]
-name = "ruff"
-version = "0.9.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2a/e1/e265aba384343dd8ddd3083f5e33536cd17e1566c41453a5517b5dd443be/ruff-0.9.6.tar.gz", hash = "sha256:81761592f72b620ec8fa1068a6fd00e98a5ebee342a3642efd84454f3031dca9", size = 3639454 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/e3/3d2c022e687e18cf5d93d6bfa2722d46afc64eaa438c7fbbdd603b3597be/ruff-0.9.6-py3-none-linux_armv6l.whl", hash = "sha256:2f218f356dd2d995839f1941322ff021c72a492c470f0b26a34f844c29cdf5ba", size = 11714128 },
-    { url = "https://files.pythonhosted.org/packages/e1/22/aff073b70f95c052e5c58153cba735748c9e70107a77d03420d7850710a0/ruff-0.9.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b908ff4df65dad7b251c9968a2e4560836d8f5487c2f0cc238321ed951ea0504", size = 11682539 },
-    { url = "https://files.pythonhosted.org/packages/75/a7/f5b7390afd98a7918582a3d256cd3e78ba0a26165a467c1820084587cbf9/ruff-0.9.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b109c0ad2ececf42e75fa99dc4043ff72a357436bb171900714a9ea581ddef83", size = 11132512 },
-    { url = "https://files.pythonhosted.org/packages/a6/e3/45de13ef65047fea2e33f7e573d848206e15c715e5cd56095589a7733d04/ruff-0.9.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1de4367cca3dac99bcbd15c161404e849bb0bfd543664db39232648dc00112dc", size = 11929275 },
-    { url = "https://files.pythonhosted.org/packages/7d/f2/23d04cd6c43b2e641ab961ade8d0b5edb212ecebd112506188c91f2a6e6c/ruff-0.9.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac3ee4d7c2c92ddfdaedf0bf31b2b176fa7aa8950efc454628d477394d35638b", size = 11466502 },
-    { url = "https://files.pythonhosted.org/packages/b5/6f/3a8cf166f2d7f1627dd2201e6cbc4cb81f8b7d58099348f0c1ff7b733792/ruff-0.9.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5dc1edd1775270e6aa2386119aea692039781429f0be1e0949ea5884e011aa8e", size = 12676364 },
-    { url = "https://files.pythonhosted.org/packages/f5/c4/db52e2189983c70114ff2b7e3997e48c8318af44fe83e1ce9517570a50c6/ruff-0.9.6-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:4a091729086dffa4bd070aa5dab7e39cc6b9d62eb2bef8f3d91172d30d599666", size = 13335518 },
-    { url = "https://files.pythonhosted.org/packages/66/44/545f8a4d136830f08f4d24324e7db957c5374bf3a3f7a6c0bc7be4623a37/ruff-0.9.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d1bbc6808bf7b15796cef0815e1dfb796fbd383e7dbd4334709642649625e7c5", size = 12823287 },
-    { url = "https://files.pythonhosted.org/packages/c5/26/8208ef9ee7431032c143649a9967c3ae1aae4257d95e6f8519f07309aa66/ruff-0.9.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:589d1d9f25b5754ff230dce914a174a7c951a85a4e9270613a2b74231fdac2f5", size = 14592374 },
-    { url = "https://files.pythonhosted.org/packages/31/70/e917781e55ff39c5b5208bda384fd397ffd76605e68544d71a7e40944945/ruff-0.9.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc61dd5131742e21103fbbdcad683a8813be0e3c204472d520d9a5021ca8b217", size = 12500173 },
-    { url = "https://files.pythonhosted.org/packages/84/f5/e4ddee07660f5a9622a9c2b639afd8f3104988dc4f6ba0b73ffacffa9a8c/ruff-0.9.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5e2d9126161d0357e5c8f30b0bd6168d2c3872372f14481136d13de9937f79b6", size = 11906555 },
-    { url = "https://files.pythonhosted.org/packages/f1/2b/6ff2fe383667075eef8656b9892e73dd9b119b5e3add51298628b87f6429/ruff-0.9.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:68660eab1a8e65babb5229a1f97b46e3120923757a68b5413d8561f8a85d4897", size = 11538958 },
-    { url = "https://files.pythonhosted.org/packages/3c/db/98e59e90de45d1eb46649151c10a062d5707b5b7f76f64eb1e29edf6ebb1/ruff-0.9.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c4cae6c4cc7b9b4017c71114115db0445b00a16de3bcde0946273e8392856f08", size = 12117247 },
-    { url = "https://files.pythonhosted.org/packages/ec/bc/54e38f6d219013a9204a5a2015c09e7a8c36cedcd50a4b01ac69a550b9d9/ruff-0.9.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:19f505b643228b417c1111a2a536424ddde0db4ef9023b9e04a46ed8a1cb4656", size = 12554647 },
-    { url = "https://files.pythonhosted.org/packages/a5/7d/7b461ab0e2404293c0627125bb70ac642c2e8d55bf590f6fce85f508f1b2/ruff-0.9.6-py3-none-win32.whl", hash = "sha256:194d8402bceef1b31164909540a597e0d913c0e4952015a5b40e28c146121b5d", size = 9949214 },
-    { url = "https://files.pythonhosted.org/packages/ee/30/c3cee10f915ed75a5c29c1e57311282d1a15855551a64795c1b2bbe5cf37/ruff-0.9.6-py3-none-win_amd64.whl", hash = "sha256:03482d5c09d90d4ee3f40d97578423698ad895c87314c4de39ed2af945633caa", size = 10999914 },
-    { url = "https://files.pythonhosted.org/packages/e8/a8/d71f44b93e3aa86ae232af1f2126ca7b95c0f515ec135462b3e1f351441c/ruff-0.9.6-py3-none-win_arm64.whl", hash = "sha256:0e2bb706a2be7ddfea4a4af918562fdc1bcb16df255e5fa595bbd800ce322a5a", size = 10177499 },
-]
-
-[[package]]
-name = "rust-just"
-version = "1.39.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a3/e5/37254d353a23f567ac218ddd2c461337fafe3a43d44dcd6f0c8e72d096f4/rust_just-1.39.0.tar.gz", hash = "sha256:247d0b293924cc8089a73428c9c03a3c2c0627bb8f205addb976ded0681f0dac", size = 1395439 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c9/9e/c7151bfa84c1cd3ac4c11a60d1a2f074b7a244ae96959d968e8b9e8e3f29/rust_just-1.39.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3845ab10254c994ddebcf489b30c53a24c1d11585c9e0eeaf1cb0da422bee87f", size = 1781993 },
-    { url = "https://files.pythonhosted.org/packages/e4/0f/c93ef08567835356033bee162c2e5e06b018811f5188b94ef3e74dafe7eb/rust_just-1.39.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fd5c12118a8d65266ccdacfbc24bab26f77d509caaf263095cb96611ea6ce7e8", size = 1652880 },
-    { url = "https://files.pythonhosted.org/packages/f3/e7/22647f9c18537046940b3b4159377665912acccbacedd775917610c0390d/rust_just-1.39.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:428d07b1e798777c4e9a8c245539d72743be095558010f0a86823e1c442930f9", size = 1771788 },
-    { url = "https://files.pythonhosted.org/packages/d5/1f/2a36afad5eeca6756fc8c87e08d102cdadf8e4b31c5f8bcb6f12c109b5b4/rust_just-1.39.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:135a7a65a8641b00a2fe7f3156a97ab7052e4830a922a71e67ca4e38ccd54cd2", size = 1778377 },
-    { url = "https://files.pythonhosted.org/packages/97/5b/45effb44bbfab892774a239446920cfb9b3d999921fe7cff3d99b36394a7/rust_just-1.39.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:94eb45e585fda019f7f9cbac198e10e31f81c704371887cbdec9b7a1ae2e0d29", size = 1896235 },
-    { url = "https://files.pythonhosted.org/packages/b5/12/7e88a7e917c2e933846a32a2f537786829b48c827a6029e85943d5eeadc0/rust_just-1.39.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de4a8566ca1eb87b5ff2669a6dd9474b16977c5d712534a5a9c7a950271da2d0", size = 1954347 },
-    { url = "https://files.pythonhosted.org/packages/9a/36/5dc917a2c0a0b66f0cc4bb0be4985090deefa33433dd869649a4ce2bc8f3/rust_just-1.39.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7ecd8fd862729c243498951caa54d778ff480c2524039280ff3ebb9a64299f", size = 2450909 },
-    { url = "https://files.pythonhosted.org/packages/da/fc/b9224b354da8a89b38cd4145ec0e9e089635a45c1459231e349647cdad64/rust_just-1.39.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:576229024d2ef8fc696d5a049ecd0d8f3d9b920a32e76f65e95840d24d804101", size = 1895058 },
-    { url = "https://files.pythonhosted.org/packages/0b/ef/985cb93c9dd36f9bc41f26b3ce6d420c69fb18166ac61783bced2c328f75/rust_just-1.39.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c1cd9240e2c1b352d7ccc6b89ce84fcc0352f15bb9660cdc6bc34802b36251b6", size = 1767816 },
-    { url = "https://files.pythonhosted.org/packages/50/43/fc644746a7479fadbe6878ae9fa1da83860104d1e64a49de47306fa1a591/rust_just-1.39.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d6eff0461df7e36eba6e7f0addf16ef98563cf8cb483e4c8393be5456d6af5c6", size = 1791992 },
-    { url = "https://files.pythonhosted.org/packages/32/d9/6924547c02afba3a49b14f53bed09b54d4292016b830f366d7ed1f80288a/rust_just-1.39.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0dfcc49a5fa126ba923b58e48921fd117e429660495577a854494c6ced3134c9", size = 1884357 },
-    { url = "https://files.pythonhosted.org/packages/15/96/7e8d3795588c2e8e629f9f0d9cdd0cf1ba1bef5bf9c8b64aae33c78f1993/rust_just-1.39.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:826203ad02c869ad8621993a608adb01394ef9c9c9ca6aa7dd7875b1f272aa46", size = 1936706 },
-    { url = "https://files.pythonhosted.org/packages/23/28/2492c4b7c8f0e526f52a263f20b951880387f992151bbc46c6c8914786a8/rust_just-1.39.0-py3-none-win32.whl", hash = "sha256:dcef0926b287449e853b878f6f34759a797d017cefb83afbcd74820d37259b78", size = 1577519 },
-    { url = "https://files.pythonhosted.org/packages/6f/c2/1d576be1ca714df4a90255cfbcb4ec06d9aafbf7b14924c2881a8596a68e/rust_just-1.39.0-py3-none-win_amd64.whl", hash = "sha256:3139f3f76434a8ebbf35b213d149e647c4d9546312b438e262df7ec41e7ef7bc", size = 1705761 },
-]
-
-[[package]]
-name = "setuptools"
-version = "75.8.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/92/ec/089608b791d210aec4e7f97488e67ab0d33add3efccb83a056cbafe3a2a6/setuptools-75.8.0.tar.gz", hash = "sha256:c5afc8f407c626b8313a86e10311dd3f661c6cd9c09d4bf8c15c0e11f9f2b0e6", size = 1343222 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/8a/b9dc7678803429e4a3bc9ba462fa3dd9066824d3c607490235c6a796be5a/setuptools-75.8.0-py3-none-any.whl", hash = "sha256:e3982f444617239225d675215d51f6ba05f845d4eec313da4418fdbb56fb27e3", size = 1228782 },
-]
-
-[[package]]
-name = "six"
-version = "1.17.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
-]
-
-[[package]]
-name = "sniffio"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
-]
-
-[[package]]
-name = "sortedcontainers"
-version = "2.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
-]
-
-[[package]]
-name = "stevedore"
-version = "5.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pbr" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4a/e9/4eedccff8332cc40cc60ddd3b28d4c3e255ee7e9c65679fa4533ab98f598/stevedore-5.4.0.tar.gz", hash = "sha256:79e92235ecb828fe952b6b8b0c6c87863248631922c8e8e0fa5b17b232c4514d", size = 513899 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/73/d0091d22a65b55e8fb6aca7b3b6713b5a261dd01cec4cfd28ed127ac0cfc/stevedore-5.4.0-py3-none-any.whl", hash = "sha256:b0be3c4748b3ea7b854b265dcb4caa891015e442416422be16f8b31756107857", size = 49534 },
-]
-
-[[package]]
-name = "tenacity"
-version = "9.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/94/91fccdb4b8110642462e653d5dcb27e7b674742ad68efd146367da7bdb10/tenacity-9.0.0.tar.gz", hash = "sha256:807f37ca97d62aa361264d497b0e31e92b8027044942bfa756160d908320d73b", size = 47421 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/cb/b86984bed139586d01532a587464b5805f12e397594f19f931c4c2fbfa61/tenacity-9.0.0-py3-none-any.whl", hash = "sha256:93de0c98785b27fcf659856aa9f54bfbd399e29969b0621bc7f762bd441b4539", size = 28169 },
-]
-
-[[package]]
-name = "termynal"
-version = "0.13.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6f/f4/499b6559a8dc8dd9d06fcab1c573d2e9e5c3b5a4ceedc5fef75de9df1776/termynal-0.13.0.tar.gz", hash = "sha256:8d41cc80b03e040398bf57f37a584d06295b5ad82a7add54f1ad000daf537573", size = 174126 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/2d/a00bb03c0db99de80944fa522d5fbfdc844b9c5aa45db31e6edb0cb5e02c/termynal-0.13.0-py3-none-any.whl", hash = "sha256:0507eba6d8d96a2b29fddb8ae4d58b07b2a48b9144bda976629de3b9e2a47ced", size = 10620 },
-]
-
-[[package]]
-name = "tinycss2"
-version = "1.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "webencodings" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 },
-]
-
-[[package]]
-name = "toml"
-version = "0.10.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588 },
-]
-
-[[package]]
-name = "tomli"
-version = "2.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 },
-    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 },
-    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 },
-    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 },
-    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 },
-    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 },
-    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 },
-    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 },
-    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 },
-    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 },
-    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 },
-    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 },
-    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 },
-    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 },
-    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 },
-    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 },
-    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 },
-    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 },
-    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 },
-    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 },
-    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 },
-    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 },
-    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 },
-    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 },
-    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 },
-    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 },
-    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 },
-    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 },
-    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 },
-    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 },
-    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 },
-]
-
-[[package]]
-name = "trio"
-version = "0.30.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "idna" },
-    { name = "outcome" },
-    { name = "sniffio" },
-    { name = "sortedcontainers" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/c1/68d582b4d3a1c1f8118e18042464bb12a7c1b75d64d75111b297687041e3/trio-0.30.0.tar.gz", hash = "sha256:0781c857c0c81f8f51e0089929a26b5bb63d57f927728a5586f7e36171f064df", size = 593776 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/8e/3f6dfda475ecd940e786defe6df6c500734e686c9cd0a0f8ef6821e9b2f2/trio-0.30.0-py3-none-any.whl", hash = "sha256:3bf4f06b8decf8d3cf00af85f40a89824669e2d033bb32469d34840edcfc22a5", size = 499194 },
-]
-
-[[package]]
-name = "truststore"
-version = "0.10.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0f/a7/b7a43228762966a13598a404f3dfb4803ea29a906f449d8b0e73ed0bcd30/truststore-0.10.1.tar.gz", hash = "sha256:eda021616b59021812e800fa0a071e51b266721bef3ce092db8a699e21c63539", size = 26101 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bc/df/8ad635bdcfa8214c399e5614f7c2121dced47defb755a85ea1fa702ffb1c/truststore-0.10.1-py3-none-any.whl", hash = "sha256:b64e6025a409a43ebdd2807b0c41c8bff49ea7ae6550b5087ac6df6619352d4c", size = 18496 },
-]
-
-[[package]]
-name = "types-toml"
-version = "0.10.8.20240310"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/86/47/3e4c75042792bff8e90d7991aa5c51812cc668828cc6cce711e97f63a607/types-toml-0.10.8.20240310.tar.gz", hash = "sha256:3d41501302972436a6b8b239c850b26689657e25281b48ff0ec06345b8830331", size = 4392 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/a2/d32ab58c0b216912638b140ab2170ee4b8644067c293b170e19fba340ccc/types_toml-0.10.8.20240310-py3-none-any.whl", hash = "sha256:627b47775d25fa29977d9c70dc0cbab3f314f32c8d8d0c012f2ef5de7aaec05d", size = 4777 },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.12.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
-]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/82/5c/e6082df02e215b846b4b8c0b887a64d7d08ffaba30605502639d44c06b82/typing_inspection-0.4.0.tar.gz", hash = "sha256:9765c87de36671694a67904bf2c96e395be9c6439bb6c87b5142569dcdd65122", size = 76222 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 },
-]
-
-[[package]]
-name = "uipath"
-version = "2.1.0"
-source = { editable = "." }
-dependencies = [
-    { name = "azure-monitor-opentelemetry" },
-    { name = "click" },
-    { name = "httpx" },
-    { name = "opentelemetry-sdk" },
-    { name = "pathlib" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "rich" },
-    { name = "tenacity" },
-    { name = "tomli" },
-    { name = "truststore" },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "bandit" },
-    { name = "inflection" },
-    { name = "mkdocs" },
-    { name = "mkdocs-click" },
-    { name = "mkdocs-material", extra = ["imaging"] },
-    { name = "mkdocs-open-in-new-tab" },
-    { name = "mkdocs-simple-hooks" },
-    { name = "mkdocstrings", extra = ["python"] },
-    { name = "mypy" },
-    { name = "pre-commit" },
-    { name = "pytest" },
-    { name = "pytest-asyncio" },
-    { name = "pytest-cov" },
-    { name = "pytest-httpx" },
-    { name = "pytest-mock" },
-    { name = "pytest-trio" },
-    { name = "ruff" },
-    { name = "rust-just" },
-    { name = "termynal" },
-    { name = "toml" },
-    { name = "types-toml" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "azure-monitor-opentelemetry", specifier = ">=1.6.8" },
-    { name = "click", specifier = ">=8.1.8" },
-    { name = "httpx", specifier = ">=0.28.1" },
-    { name = "opentelemetry-sdk", specifier = ">=1.31.1" },
-    { name = "pathlib", specifier = ">=1.0.1" },
-    { name = "pydantic", specifier = ">=2.11.1" },
-    { name = "python-dotenv", specifier = ">=1.0.1" },
-    { name = "rich", specifier = ">=13.0.0" },
-    { name = "tenacity", specifier = ">=9.0.0" },
-    { name = "tomli", specifier = ">=2.2.1" },
-    { name = "truststore", specifier = ">=0.10.1" },
-]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "bandit", specifier = ">=1.8.2" },
-    { name = "inflection", specifier = ">=0.5.1" },
-    { name = "mkdocs", specifier = ">=1.6.1" },
-    { name = "mkdocs-click", specifier = ">=0.9.0" },
-    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.6.7" },
-    { name = "mkdocs-open-in-new-tab", specifier = ">=1.0.8" },
-    { name = "mkdocs-simple-hooks", specifier = ">=0.1.5" },
-    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.18" },
-    { name = "mypy", specifier = ">=1.14.1" },
-    { name = "pre-commit", specifier = ">=4.1.0" },
-    { name = "pytest", specifier = ">=7.4.0" },
-    { name = "pytest-asyncio", specifier = ">=1.0.0" },
-    { name = "pytest-cov", specifier = ">=4.1.0" },
-    { name = "pytest-httpx", specifier = ">=0.35.0" },
-    { name = "pytest-mock", specifier = ">=3.11.1" },
-    { name = "pytest-trio", specifier = ">=0.8.0" },
-    { name = "ruff", specifier = ">=0.9.4" },
-    { name = "rust-just", specifier = ">=1.39.0" },
-    { name = "termynal", specifier = ">=0.13.0" },
-    { name = "toml", specifier = ">=0.10.2" },
-    { name = "types-toml", specifier = ">=0.10.8" },
-]
-
-[[package]]
-name = "urllib3"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 },
-]
-
-[[package]]
-name = "virtualenv"
-version = "20.29.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "distlib" },
-    { name = "filelock" },
-    { name = "platformdirs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f1/88/dacc875dd54a8acadb4bcbfd4e3e86df8be75527116c91d8f9784f5e9cab/virtualenv-20.29.2.tar.gz", hash = "sha256:fdaabebf6d03b5ba83ae0a02cfe96f48a716f4fae556461d180825866f75b728", size = 4320272 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/93/fa/849483d56773ae29740ae70043ad88e068f98a6401aa819b5d6bee604683/virtualenv-20.29.2-py3-none-any.whl", hash = "sha256:febddfc3d1ea571bdb1dc0f98d7b45d24def7428214d4fb73cc486c9568cce6a", size = 4301478 },
-]
-
-[[package]]
-name = "watchdog"
-version = "6.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 },
-    { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 },
-    { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 },
-    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 },
-    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 },
-    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 },
-    { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 },
-    { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 },
-    { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 },
-    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 },
-    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 },
-    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 },
-    { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 },
-    { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 },
-    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 },
-    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 },
-    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 },
-    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 },
-    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 },
-    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 },
-    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 },
-    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 },
-    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 },
-    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 },
-]
-
-[[package]]
-name = "webencodings"
-version = "0.5.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 },
-]
-
-[[package]]
-name = "wrapt"
-version = "1.17.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/d1/1daec934997e8b160040c78d7b31789f19b122110a75eca3d4e8da0049e1/wrapt-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3d57c572081fed831ad2d26fd430d565b76aa277ed1d30ff4d40670b1c0dd984", size = 53307 },
-    { url = "https://files.pythonhosted.org/packages/1b/7b/13369d42651b809389c1a7153baa01d9700430576c81a2f5c5e460df0ed9/wrapt-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5e251054542ae57ac7f3fba5d10bfff615b6c2fb09abeb37d2f1463f841ae22", size = 38486 },
-    { url = "https://files.pythonhosted.org/packages/62/bf/e0105016f907c30b4bd9e377867c48c34dc9c6c0c104556c9c9126bd89ed/wrapt-1.17.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:80dd7db6a7cb57ffbc279c4394246414ec99537ae81ffd702443335a61dbf3a7", size = 38777 },
-    { url = "https://files.pythonhosted.org/packages/27/70/0f6e0679845cbf8b165e027d43402a55494779295c4b08414097b258ac87/wrapt-1.17.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a6e821770cf99cc586d33833b2ff32faebdbe886bd6322395606cf55153246c", size = 83314 },
-    { url = "https://files.pythonhosted.org/packages/0f/77/0576d841bf84af8579124a93d216f55d6f74374e4445264cb378a6ed33eb/wrapt-1.17.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b60fb58b90c6d63779cb0c0c54eeb38941bae3ecf7a73c764c52c88c2dcb9d72", size = 74947 },
-    { url = "https://files.pythonhosted.org/packages/90/ec/00759565518f268ed707dcc40f7eeec38637d46b098a1f5143bff488fe97/wrapt-1.17.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b870b5df5b71d8c3359d21be8f0d6c485fa0ebdb6477dda51a1ea54a9b558061", size = 82778 },
-    { url = "https://files.pythonhosted.org/packages/f8/5a/7cffd26b1c607b0b0c8a9ca9d75757ad7620c9c0a9b4a25d3f8a1480fafc/wrapt-1.17.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4011d137b9955791f9084749cba9a367c68d50ab8d11d64c50ba1688c9b457f2", size = 81716 },
-    { url = "https://files.pythonhosted.org/packages/7e/09/dccf68fa98e862df7e6a60a61d43d644b7d095a5fc36dbb591bbd4a1c7b2/wrapt-1.17.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1473400e5b2733e58b396a04eb7f35f541e1fb976d0c0724d0223dd607e0f74c", size = 74548 },
-    { url = "https://files.pythonhosted.org/packages/b7/8e/067021fa3c8814952c5e228d916963c1115b983e21393289de15128e867e/wrapt-1.17.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3cedbfa9c940fdad3e6e941db7138e26ce8aad38ab5fe9dcfadfed9db7a54e62", size = 81334 },
-    { url = "https://files.pythonhosted.org/packages/4b/0d/9d4b5219ae4393f718699ca1c05f5ebc0c40d076f7e65fd48f5f693294fb/wrapt-1.17.2-cp310-cp310-win32.whl", hash = "sha256:582530701bff1dec6779efa00c516496968edd851fba224fbd86e46cc6b73563", size = 36427 },
-    { url = "https://files.pythonhosted.org/packages/72/6a/c5a83e8f61aec1e1aeef939807602fb880e5872371e95df2137142f5c58e/wrapt-1.17.2-cp310-cp310-win_amd64.whl", hash = "sha256:58705da316756681ad3c9c73fd15499aa4d8c69f9fd38dc8a35e06c12468582f", size = 38774 },
-    { url = "https://files.pythonhosted.org/packages/cd/f7/a2aab2cbc7a665efab072344a8949a71081eed1d2f451f7f7d2b966594a2/wrapt-1.17.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ff04ef6eec3eee8a5efef2401495967a916feaa353643defcc03fc74fe213b58", size = 53308 },
-    { url = "https://files.pythonhosted.org/packages/50/ff/149aba8365fdacef52b31a258c4dc1c57c79759c335eff0b3316a2664a64/wrapt-1.17.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db983e7bca53819efdbd64590ee96c9213894272c776966ca6306b73e4affda", size = 38488 },
-    { url = "https://files.pythonhosted.org/packages/65/46/5a917ce85b5c3b490d35c02bf71aedaa9f2f63f2d15d9949cc4ba56e8ba9/wrapt-1.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9abc77a4ce4c6f2a3168ff34b1da9b0f311a8f1cfd694ec96b0603dff1c79438", size = 38776 },
-    { url = "https://files.pythonhosted.org/packages/ca/74/336c918d2915a4943501c77566db41d1bd6e9f4dbc317f356b9a244dfe83/wrapt-1.17.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b929ac182f5ace000d459c59c2c9c33047e20e935f8e39371fa6e3b85d56f4a", size = 83776 },
-    { url = "https://files.pythonhosted.org/packages/09/99/c0c844a5ccde0fe5761d4305485297f91d67cf2a1a824c5f282e661ec7ff/wrapt-1.17.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f09b286faeff3c750a879d336fb6d8713206fc97af3adc14def0cdd349df6000", size = 75420 },
-    { url = "https://files.pythonhosted.org/packages/b4/b0/9fc566b0fe08b282c850063591a756057c3247b2362b9286429ec5bf1721/wrapt-1.17.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7ed2d9d039bd41e889f6fb9364554052ca21ce823580f6a07c4ec245c1f5d6", size = 83199 },
-    { url = "https://files.pythonhosted.org/packages/9d/4b/71996e62d543b0a0bd95dda485219856def3347e3e9380cc0d6cf10cfb2f/wrapt-1.17.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:129a150f5c445165ff941fc02ee27df65940fcb8a22a61828b1853c98763a64b", size = 82307 },
-    { url = "https://files.pythonhosted.org/packages/39/35/0282c0d8789c0dc9bcc738911776c762a701f95cfe113fb8f0b40e45c2b9/wrapt-1.17.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1fb5699e4464afe5c7e65fa51d4f99e0b2eadcc176e4aa33600a3df7801d6662", size = 75025 },
-    { url = "https://files.pythonhosted.org/packages/4f/6d/90c9fd2c3c6fee181feecb620d95105370198b6b98a0770cba090441a828/wrapt-1.17.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9a2bce789a5ea90e51a02dfcc39e31b7f1e662bc3317979aa7e5538e3a034f72", size = 81879 },
-    { url = "https://files.pythonhosted.org/packages/8f/fa/9fb6e594f2ce03ef03eddbdb5f4f90acb1452221a5351116c7c4708ac865/wrapt-1.17.2-cp311-cp311-win32.whl", hash = "sha256:4afd5814270fdf6380616b321fd31435a462019d834f83c8611a0ce7484c7317", size = 36419 },
-    { url = "https://files.pythonhosted.org/packages/47/f8/fb1773491a253cbc123c5d5dc15c86041f746ed30416535f2a8df1f4a392/wrapt-1.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:acc130bc0375999da18e3d19e5a86403667ac0c4042a094fefb7eec8ebac7cf3", size = 38773 },
-    { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799 },
-    { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821 },
-    { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919 },
-    { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721 },
-    { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899 },
-    { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222 },
-    { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707 },
-    { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685 },
-    { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567 },
-    { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672 },
-    { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865 },
-    { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800 },
-    { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824 },
-    { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920 },
-    { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690 },
-    { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861 },
-    { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174 },
-    { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721 },
-    { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763 },
-    { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585 },
-    { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676 },
-    { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871 },
-    { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312 },
-    { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062 },
-    { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155 },
-    { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471 },
-    { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208 },
-    { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339 },
-    { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232 },
-    { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476 },
-    { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377 },
-    { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986 },
-    { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750 },
-    { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594 },
-]
-
-[[package]]
-name = "zipp"
-version = "3.21.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 },
-]